Aktivität mit lang anhaltenden Service im Hintergrund, die nicht getötet wird

Question

Auf Android habe ich eine Activity namens FirstActivity, die eine Service namens MyService startet, um Netzwerk-Sachen im Hintergrund zu tun. Die Activity und die Service kommunizieren ständig miteinander durch Aufruf von Methoden.

Jetzt, wenn der Benutzer FirstActivity-SecondActivity navigiert, sollte der Hintergrunddienst nicht getötet oder neu erstellt werden, aber am Leben gehalten und zu SecondActivity geführt, die nun die mit dem Dienst zu kommunizieren ist.

Mit anderen Worten wird die Service so lange laufen, wie einer der beiden Activity s läuft, und es sollte nicht aufhören, während der Benutzer zwischen den beiden Activity s navigiert.

Eines der Activity s wird immer im Vordergrund stehen und während dieser Zeit sollte der Dienst (optimal) niemals abgetötet werden. Ich denke, das sollte kein Problem sein, denn einer der beiden Activity s ist immer aktiv und somit weiß Android, dass der Dienst wichtig ist und nicht etwas, das getötet werden muss.

(Wenn es keine Möglichkeit gab, Android zu verhindern, dass das Töten und neu zu erstellen, den Service von Zeit zu Zeit, ich würde einen Weg brauchen den vollen Zustand des Dienstes ordnungsgemäß wiederherzustellen.)

Zusammengefasst sollte die Service die gleiche Lebensdauer wie die beiden Activity s "kombiniert" haben. Es sollte mit dem ersten von ihnen beginnen und nicht aufhören, bevor beide zerstört wurden.

Also ist der folgende Code richtig für diese Einrichtung und Ziele?

public class MyService extends Service { 

    public class LocalBinder extends Binder { 
     public MyService getService() { 
      return MyService.this; 
     } 
    } 

    ... 

} 

public class FirstActivity extends Activity { 

    private MyService mMyService; 

    private ServiceConnection mMainServiceConnection = new ServiceConnection() { 

     @Override 
     public void onServiceConnected(ComponentName className, IBinder service) { 
      MyService mainService = ((LocalBinder) service).getService(); 
      mMyService = mainService; 
      mMyService.setCallback(FirstActivity.this); 
     } 

     @Override 
     public void onServiceDisconnected(ComponentName className) { 
      mMyService = null; 
     } 
    }; 

    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     ... 
     startService(new Intent(FirstActivity.this, MyService.class)); 
    } 

    @Override 
    protected void onResume() { 
     super.onResume(); 
     bindService(new Intent(FirstActivity.this, MyService.class), mMainServiceConnection, Context.BIND_AUTO_CREATE); 
    } 

    @Override 
    protected void onPause() { 
     super.onPause(); 
     if (mMainServiceConnection != null) { 
      unbindService(mMainServiceConnection); 
     } 

     if (mMyService != null) { 
      mMyService.setCallback(null); 
     } 

     if (!isUserMovingToSecondActivity) { 
      stopService(new Intent(FirstActivity.this, MyService.class)); 
     } 
    } 

    @Override 
    public void onBackPressed() { 
     stopService(new Intent(FirstActivity.this, MyService.class)); 
     super.onBackPressed(); 
    } 

    ... 

} 

public class SecondActivity extends Activity { 

    private MyService mMyService; 

    private ServiceConnection mMainServiceConnection = new ServiceConnection() { 

     @Override 
     public void onServiceConnected(ComponentName className, IBinder service) { 
      MyService mainService = ((LocalBinder) service).getService(); 
      mMyService = mainService; 
      mMyService.setCallback(SecondActivity.this); 
     } 

     @Override 
     public void onServiceDisconnected(ComponentName className) { 
      mMyService = null; 
     } 
    }; 

    @Override 
    protected void onResume() { 
     super.onResume(); 
     bindService(new Intent(SecondActivity.this, MyService.class), mMainServiceConnection, Context.BIND_AUTO_CREATE); 
    } 

    @Override 
    protected void onPause() { 
     super.onPause(); 
     if (mMainServiceConnection != null) { 
      unbindService(mMainServiceConnection); 
     } 
    } 

    @Override 
    protected void onDestroy() { 
     ... 
     stopService(new Intent(SecondActivity.this, MyService.class)); 
    } 

    ... 

} 

Ist dies der beste Weg, um einen lang anhaltenden Dienst im Hintergrund des Activity s zu gewährleisten, die getötet oder neu erstellt werden nicht?

Was ist mit Context.BIND_AUTO_CREATE? Ist es richtig, diese Flagge hier zu setzen? Was ist mit Context.BIND_ADJUST_WITH_ACTIVITY und Context.BIND_WAIVE_PRIORITY - brauche ich diese?

Answer 1

(Vielen Dank an @ corsair992 für seine nützlichen Hinweise!)

---

Wenn die Aktivitäten immer in dieser Reihenfolge genannt werden (dh FirstActivity beginnt SecondActivity, und nie anders herum, dann . Sie sollten grundsätzlich Versuch den Dienst des Lebenszyklus FirstActivity ‚s-Lebenszyklus zu„binden“

Im allgemeinen (siehe Einsprüche später) bedeutet dies:

• Rufen Sie startService() in FirstActivity.onCreate().
• Rufen Sie stopService() in FirstActivity.onDestroy().
• Rufen Sie bindService()/unbindService() in den onStart()/onStop() Methoden beider Aktivitäten auf (um Zugriff auf das Binder-Objekt zu erhalten und Methoden aufzurufen).

Dienst gestartet diese Weise am Leben sein wird, bis stopService()und jeder Kunde entbindet genannt wird, sehen Managing the Lifecycle of a Service:

Diese beiden Pfade nicht vollständig getrennt sind. Das heißt, Sie können an einen Dienst binden, der bereits mit startService() gestartet wurde. (...) In solchen Fällen stoppt stopService() oder stopSelf() den Dienst nicht wirklich, bis alle Clients unbind haben.

und:

Wenn der letzte Client aus dem Dienst entbindet, zerstört das System den Service (es sei denn, der Dienst auch von Startservice() gestartet wurde).

Mit dieser grundlegenden Strategie wird der Dienst so lange leben, wie FirstActivity herum ist (d. H. Es wird nicht zerstört). Es bleibt jedoch ein wichtiger Punkt: Im Falle einer Konfigurationsänderung (z. B. einer Bildschirmdrehung), die nicht explizit behandelt wird, wird die Aktivität neu gestartet und der Dienst wird zerstört (da wir stopService() in onDestroy() aufrufen) .

Um dies zu verhindern, können Sie isChangingConfigurations() überprüfen, bevor Sie den Dienst tatsächlich gestoppt (da ein onDestroy() Rückruf wegen auftretenden diesem Grund bedeutet, dass, obwohl diese bestimmte Instanz der Aktivität zerstört wird, wird es danach neu erstellt werden.

daher wäre die vollständige Lösung so etwas wie:

public class FirstActivity extends Activity 
{ 
    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     startService(new Intent(this, MyService.class)); 
    } 

    private ServiceConnection mServiceConnection = new ServiceConnection() { ... } 

    @Override 
    protected void onStart() { 
     super.onStart(); 
     bindService(new Intent(this, MyService.class), mServiceConnection, Context.BIND_AUTO_CREATE); 
    } 

    @Override 
    protected void onStop() { 
     unbindService(mServiceConnection); 
     super.onStop(); 
    } 

    @Override 
    protected void onDestroy() { 
     if (!isChangingConfigurations()) 
      stopService(new Intent(this, MyService.class)); 

     super.onDestroy(); 
    } 

Während SecondActivity würde nur die onStart()/onStop() Methoden implementieren (in der gleichen Weg).

---

Ein paar Notizen über Ihre spezielle Implementierung:

• Es ist nicht notwendig onBackPressed(), außer Kraft zu setzen, da, wenn die Aktivität aufgerufen werden die notwendigen Lebenszyklus Methoden zerstört werden (plus, könnte es ohne fertig sein Drücken Sie die Zurück - Taste, zum Beispiel wenn Sie finish() aufrufen.
• Wenn Sie den Dienst in onDestroy() anstelle von onPause() stoppen, ersparen Sie sich die Suche nach isUserMovingToSecondActivity.