Su Android, ho un Activity
chiamato FirstActivity
che avvia un Service
denominato MyService
per fare roba di rete in background. Il Activity
e lo Service
comunicano tra loro continuamente chiamando metodi.Attività con servizio di lunga durata in background che non verrà ucciso
Ora, quando l'utente si sposta FirstActivity
-SecondActivity
, il servizio in background dovrebbe non essere uccisi o ri-creato, ma tenuto in vita e passato a SecondActivity
che ora sarà quello di comunicare con il servizio.
In altre parole, il Service
deve continuare a funzionare fino a quando una delle due Activity
s è in esecuzione, e non dovrebbe fermarsi mentre l'utente naviga tra i due Activity
s.
Uno dei Activity
s sarà sempre in primo piano e durante questo periodo, il servizio dovrebbe (in modo ottimale) non essere mai ucciso. Penso che questo non dovrebbe essere un problema perché uno di questi due Activity
s è sempre attivo e quindi Android sa che il servizio è importante e non qualcosa che deve essere ucciso.
(Se non ci fosse alcun modo per impedire Android di uccidere e ri-creazione del servizio di tanto in tanto, avrei bisogno di un modo per ripristinare la piena stato del servizio con grazia.)
Per riassumere , lo Service
dovrebbe avere la stessa durata dei due "Activity
s" combinati ". Dovrebbe iniziare con il primo di essi e fermarsi non prima che entrambi siano stati distrutti.
Quindi il seguente codice è corretto per quella configurazione e gli obiettivi?
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));
}
...
}
È questo il modo migliore per garantire una lunga durata di servizio in background delle Activity
s che non saranno uccisi o ricreato?
Che dire di Context.BIND_AUTO_CREATE
? È corretto avere questo flag impostato qui? Che dire di Context.BIND_ADJUST_WITH_ACTIVITY
e Context.BIND_WAIVE_PRIORITY
- ho bisogno di questi?
Hai provato quel codice o stai chiedendo prima di provare? Se ci hai provato, hai ricevuto degli errori? Non si è comportato come ti aspettavi? Avremo una discussione molto più produttiva e una risposta più utile per la comunità e per te stesso se effettivamente la proverai e poi ci chiedi la soluzione un problema concreto che hai – DallaRosa
@DallaRosa Sì, certo, ho provato questo.Questa è una domanda generale su come progettare una classe di servizio e le corrispondenti classi di attività, in modo che il servizio duri il più a lungo possibile e non venga ucciso. Gli utenti hanno segnalato che le funzionalità fornite da questo servizio smettono di essere disponibili in una delle classi 'Activity' di volta in volta. E io (a) trovo difficile eseguire il debug quando il sistema potrebbe uccidere questo servizio e (b) vorrebbe conoscere alcune best practice o miglioramenti che dovrebbero essere applicati a questo servizio per gli obiettivi e i requisiti ben definiti. – caw
Posso vedere molti problemi nella gestione del 'Servizio'. Devi fermarlo solo quando il primo 'Activity' viene distrutto, o dipende dal binding e gestirlo correttamente. Ci sono alcune istruzioni generali su questo nei libri Android iniziali: https://books.google.com.pk/books?id=mRGrCQbqHkoC&pg=PA399 – corsair992