solucion - El servicio Android se detiene cuando la aplicación está cerrada
todas las aplicaciones se detienen android (13)
Estoy comenzando un servicio de mi actividad principal de Android de la siguiente manera:
final Context context = base.getApplicationContext();
final Intent intent = new Intent(context, MyService.class);
startService(intent);
Cuando cierro la página de actividad deslizándola desde la lista de aplicaciones recientes, el servicio deja de ejecutarse y se reinicia después de un tiempo. No puedo usar servicios persistentes con notificaciones debido a los requisitos de mi aplicación. ¿Cómo puedo hacer que el servicio NO se reinicie o apague y solo siga funcionando al salir de la aplicación?
¿Por qué no usar un IntentService?
IntentService abre un nuevo hilo aparte del hilo principal y funciona allí, de esa manera el cierre de la aplicación no lo afectará
Tenga en cuenta que IntentService ejecuta onHandleIntent () y cuando se complete el servicio, verifique si se ajusta a sus necesidades. http://developer.android.com/reference/android/app/IntentService.html
Debe agregar este código en su clase de servicio para que maneje el caso cuando su proceso sea asesinado
@Override
public void onTaskRemoved(Intent rootIntent) {
Intent restartServiceIntent = new Intent(getApplicationContext(), this.getClass());
restartServiceIntent.setPackage(getPackageName());
PendingIntent restartServicePendingIntent = PendingIntent.getService(getApplicationContext(), 1, restartServiceIntent, PendingIntent.FLAG_ONE_SHOT);
AlarmManager alarmService = (AlarmManager) getApplicationContext().getSystemService(Context.ALARM_SERVICE);
alarmService.set(
AlarmManager.ELAPSED_REALTIME,
SystemClock.elapsedRealtime() + 1000,
restartServicePendingIntent);
super.onTaskRemoved(rootIntent);
}
Ejecutar un servicio intencionado será más fácil. Servicio para crear un hilo en la aplicación, pero todavía está en la aplicación.
El problema principal no puede iniciar el servicio cuando la aplicación se cerró, el sistema operativo Android ( en algunos sistemas operativos ) matará el servicio para optimización de recursos. Si no puede reiniciar el servicio, llame a un administrador de alarmas para iniciar el receptor de esta manera, aquí es el código completo, este código mantendrá vivo su servicio.
Manifiesto es,
<service
android:name=".BackgroundService"
android:description="@string/app_name"
android:enabled="true"
android:label="Notification" />
<receiver android:name="AlarmReceiver">
<intent-filter>
<action android:name="REFRESH_THIS" />
</intent-filter>
</receiver>
IN Main Activty inicia el administrador de alarmas de esta manera,
String alarm = Context.ALARM_SERVICE;
AlarmManager am = (AlarmManager) getSystemService(alarm);
Intent intent = new Intent("REFRESH_THIS");
PendingIntent pi = PendingIntent.getBroadcast(this, 123456789, intent, 0);
int type = AlarmManager.RTC_WAKEUP;
long interval = 1000 * 50;
am.setInexactRepeating(type, System.currentTimeMillis(), interval, pi);
esto llamará a un receptor y un receptor es,
public class AlarmReceiver extends BroadcastReceiver {
Context context;
@Override
public void onReceive(Context context, Intent intent) {
this.context = context;
System.out.println("Alarma Reciver Called");
if (isMyServiceRunning(this.context, BackgroundService.class)) {
System.out.println("alredy running no need to start again");
} else {
Intent background = new Intent(context, BackgroundService.class);
context.startService(background);
}
}
public static boolean isMyServiceRunning(Context context, Class<?> serviceClass) {
ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
List<ActivityManager.RunningServiceInfo> services = activityManager.getRunningServices(Integer.MAX_VALUE);
if (services != null) {
for (int i = 0; i < services.size(); i++) {
if ((serviceClass.getName()).equals(services.get(i).service.getClassName()) && services.get(i).pid != 0) {
return true;
}
}
}
return false;
}
}
Y este receptor de Alaram llama una vez cuando se abre la aplicación de Android y cuando se cierra la aplicación. El servicio es así,
public class BackgroundService extends Service {
private String LOG_TAG = null;
@Override
public void onCreate() {
super.onCreate();
LOG_TAG = "app_name";
Log.i(LOG_TAG, "service created");
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.i(LOG_TAG, "In onStartCommand");
//ur actual code
return START_STICKY;
}
@Override
public IBinder onBind(Intent intent) {
// Wont be called as service is not bound
Log.i(LOG_TAG, "In onBind");
return null;
}
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
@Override
public void onTaskRemoved(Intent rootIntent) {
super.onTaskRemoved(rootIntent);
Log.i(LOG_TAG, "In onTaskRemoved");
}
@Override
public void onDestroy() {
super.onDestroy();
Log.i(LOG_TAG, "In onDestroyed");
}
}
Estoy en la misma situación, hasta el momento he aprendido que cuando la aplicación está cerrada, el servicio también se cierra porque están en un solo hilo, por lo que el servicio debe estar en otro hilo para que no se cierre, mire eso y busque mantener el servicio con el administrador de alarmas aquí, un ejemplo http://www.vogella.com/articles/AndroidServices/article.html esta manera su servicio no se mostrará en la notificación.
Finalmente, después de toda la investigación que he hecho, me doy cuenta de que la mejor opción para un servicio de larga duración es startForeground() , porque está hecho para eso y el sistema realmente se ocupa de su servicio.
La mejor solución es usar el adaptador de sincronización en Android para iniciar el servicio. Cree un adaptador de sincronización y llame al servicio de inicio su ... dentro del método PerformSync. para crear una cuenta de sincronización, consulte este enlace https://developer.android.com/training/sync-adapters/index.html
¿Por qué SyncAdapter? Resp .: Porque antes solía comenzar el servicio usando su contexto de aplicación. por lo tanto, cada vez que se mate el proceso de su aplicación (cuando lo elimine del administrador de tareas o del sistema operativo, ciérrelo por falta de recursos), en ese momento también se eliminará su servicio. SyncAdapter no funcionará en el hilo de la aplicación ... así que si llamas dentro de él ... el servicio ya no se eliminará ... a menos que escribas el código para eliminarlo.
Los servicios son bastante complicados a veces.
Cuando comienza un servicio de una actividad (o su proceso), el servicio se basa esencialmente en el mismo proceso.
Citando de las notas del desarrollador
La mayoría de la confusión sobre la clase de servicio en realidad gira en torno a lo que no es:
Un servicio no es un proceso separado. El objeto de servicio en sí no implica que se esté ejecutando en su propio proceso; a menos que se especifique lo contrario, se ejecuta en el mismo proceso que la aplicación de la que forma parte.
Un servicio no es un hilo. No es un medio para hacer el trabajo fuera del hilo principal (para evitar errores de la aplicación no responde).
Entonces, lo que esto significa es que si el usuario elimina la aplicación de las tareas recientes, eliminará su proceso (esto incluye todas sus actividades, etc.). Ahora, vamos a tomar tres escenarios.
Primero, donde el servicio no tiene una notificación en primer plano.
En este caso, su proceso se mata junto con su servicio.
Segundo donde el servicio tiene una notificación en primer plano
En este caso, el servicio no se elimina y tampoco es el proceso
Tercer escenario Si el servicio no tiene una notificación en primer plano, puede seguir funcionando si la aplicación está cerrada. Podemos hacer esto haciendo que el servicio se ejecute en un proceso diferente. (Sin embargo, he escuchado a algunas personas decir que puede no funcionar. Dejado para que lo pruebes tú mismo )
puede crear un servicio en un proceso separado al incluir el atributo a continuación en su manifiesto.
android: process = ": yourService"
o
El nombre del proceso android: process = "yourService" debe comenzar con minúsculas.
citando notas del desarrollador
Si el nombre asignado a este atributo comienza con dos puntos ('':''), se crea un nuevo proceso, privado para la aplicación, cuando es necesario y el servicio se ejecuta en ese proceso. Si el nombre del proceso comienza con un carácter en minúscula , el servicio se ejecutará en un proceso global de ese nombre, siempre que tenga permiso para hacerlo. Esto permite que los componentes en diferentes aplicaciones compartan un proceso, reduciendo el uso de recursos.
esto es lo que he reunido, si alguien es un experto, por favor corrígeme si estoy equivocado :)
Simplemente anule el método Destroy en su primera actividad visible, como después de la presentación, tiene página de inicio y mientras redirige de splash a página de inicio, ya ha terminado de salpicar. así que ponte a destruir en la página de inicio. y detener el servicio en ese método.
Usar el mismo proceso para el servicio y la actividad y START_STICKY o START_REDELIVER_INTENT en el servicio es la única manera de poder reiniciar el servicio cuando la aplicación se reinicia, lo que sucede cuando el usuario cierra la aplicación, por ejemplo, pero también cuando el sistema decide para cerrarlo por razones de optimización. NO PUEDE tener un servicio que se ejecutará permanentemente sin interrupción. Esto es por diseño, los teléfonos inteligentes no están hechos para ejecutar procesos continuos durante un largo período de tiempo. Esto se debe al hecho de que la duración de la batería es la más alta prioridad. Necesita diseñar su servicio para que se pueda detener en cualquier momento.
hacerte servir así en tu Mainifest
<service
android:name=".sys.service.youservice"
android:exported="true"
android:process=":ServiceProcess" />
entonces su servicio se ejecutará en otro proceso llamado ServiceProcess
si quieres que tu servicio nunca muera:
onStartCommand () return START_STICKY
onDestroy () -> startself
crear un servicio Deamon
jin -> crea un proceso Native Deamon, puedes encontrar algunos proyectos de código abierto en github
startForeground (), hay una manera de iniciarForeground sin notificación, google it
intente esto, mantendrá el servicio ejecutándose en segundo plano.
BackServices.class
public class BackServices extends Service{
@Override
public IBinder onBind(Intent arg0) {
// TODO Auto-generated method stub
return null;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
// Let it continue running until it is stopped.
Toast.makeText(this, "Service Started", Toast.LENGTH_LONG).show();
return START_STICKY;
}
@Override
public void onDestroy() {
super.onDestroy();
Toast.makeText(this, "Service Destroyed", Toast.LENGTH_LONG).show();
}
}
en su MainActivity onCreate suelte esta línea de código
startService(new Intent(getBaseContext(), BackServices.class));
Ahora el servicio seguirá funcionando en segundo plano.
This puede ayudarte. Puede que me equivoque, pero me parece que esto está relacionado con la devolución de START_STICKY en su método onStartCommand() . Puede evitar que se vuelva a llamar al servicio al devolver START_NOT_STICKY .
<service android:name=".Service2"
android:process="@string/app_name"
android:exported="true"
android:isolatedProcess="true"
/>
Declara esto en tu manifiesto. Dale un nombre personalizado a tu proceso y aisla y exporta ese proceso.