Le processus du service est tué après l'application est supprimée de l'application du bac

Voici une solution de contournement, je suis tombé sur et fonctionne bien pour le re-démarrage d'un service si son processus est tué sur la fermeture de l'application. Dans votre service, ajoutez le code suivant.

Je suis tombé sur cette solution de contournement dans cette fil.

@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);
 }

Semble être un bug que le processus de l'application est tué. Il n'y a pas de point pour un service à terme, si le processus est tué.

Malheureusement, c'est un problème compliqué en raison de la façon dont Android fonctionne. Il y a un certain nombre de stratégies que chaque travail autour de différentes parties du problème. Pour de meilleurs résultats, combiner plusieurs stratégies d'ensemble.

Noter que certaines de ces stratégies peut ne plus être nécessaire dans les plus récentes versions d'Android.

1. Le démarrage de l'activité

Quoi faire

Prises de De premier plan de services tué lors de la réception de diffusion après acitivty glissé loin dans la liste des tâches:

Dans le premier plan de service:

  @Override
    public void onTaskRemoved( Intent rootIntent ) {
       Intent intent = new Intent( this, DummyActivity.class );
       intent.addFlags( Intent.FLAG_ACTIVITY_NEW_TASK );
       startActivity( intent );
    }

Dans le manifeste:

  <activity
    android:name=".DummyActivity"
    android:theme="@android:style/Theme.NoDisplay"
    android:enabled="true"
    android:allowTaskReparenting="true"
    android:noHistory="true"
    android:excludeFromRecents="true"
    android:alwaysRetainTaskState="false"
    android:stateNotNeeded="true"
    android:clearTaskOnLaunch="true"
    android:finishOnTaskLaunch="true"
    /> 

(Si votre service est dans un processus différent, alors cette activité est procédé à la même).

Dans DummyActivity.java:

  public class DummyActivity extends Activity {
        @Override
        public void onCreate( Bundle icicle ) {
            super.onCreate( icicle );
            finish();
        }
    }

Effets secondaires

Causes les récents activité à proximité. Normalement, le balayage d'une application ne permet pas de fermer les récents activité.

Inconvénients

Cela ne prend effet quand le mannequin le début de l'activité, qui peut prendre une demi-seconde ou plus, donc cela laisse tout de même le service ouvert à être tué pour un peu.

Explication

Lorsque vous supprimez/faites glisser votre application à l'écart, un indicateur appelé waitingToKill est ensemble. Alors que cet indicateur est défini, Android peut tuer le processus à n'importe quel moment dans le futur, comme lorsque vous recevez une émission. Le démarrage d'une activité efface ce drapeau.

2. Spam un BroadcastReceiver avec au premier plan des émissions

Quoi faire

De fusion dans votre code de service:

if (Build.VERSION.SDK_INT >= 16) {
    Intent intent = new Intent(this, DummyReceiver.class);
    intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);

    //This seems to be timing-related; the more times we do this,
    //the less likely the process gets killed
    for (int i = 0; i < 50; ++i)
        sendBroadcast(intent);
}

Créer un mannequin récepteur de radiodiffusion:

public class DummyReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {}
}

Ajouter le récepteur à votre manifeste:

<receiver android:name=".DummyReceiver" />

Effets secondaires

Peut causer une légère (~250ms) retard/de blocage lorsque la tâche est supprimée de l'récents de l'écran.

Inconvénients

Ce ne garde que les processus en vie alors que c'est la réception des émissions. la waitingToKill drapeau est toujours, de sorte que le processus peut encore être tué par la suite, comme lorsqu'une émission est reçue.

Explication

Si le processus n'est pas en cours d'exécution dans la priorité de premier plan, Android va essayer de le tuer immédiatement. La réception de premier plan des émissions empêche temporairement ce, résultant dans la waitingToKill drapeau a été mis à la place.

3. Ne pas se lier à des services de

La liaison à un service semble augmenter la probabilité de processus du service d'être tué immédiatement lorsqu'une tâche est supprimée.

onDestroy n'est pas toujours appelée. Le Principal problème dans votre cas est ur impossible de démarrer le service lors de l'application fermée,que le temps système d'exploitation android(Dans Certains OS) va tuer le service de, Si vous n'êtes pas en mesure de redémarrer le service, appeler une alarme mangeoire pour démarrer le reciver comme ça,

Manifeste est,

         <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>

Principale Activité de début de l'alarme de manger de cette façon,

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);

cela appel reciver et reciver est,

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;
    }
}

Et ce Alaram reciver appelle une fois lors de l'application android est ouvert, et lorsque l'application est fermée.AINSI, le service est comme ça,

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");
    }
}