Ist der Android-Service noch nach dem OnDestroy () aufgerufen?

Für das Studium der Android-Service, schrieb ich ein Test-Programm, das drei Schaltfläche "binden Service", "unbind Service" und "senden Echo" auf dem Bildschirm haben. Wenn sie angeklickt werden, verwenden sie bindService() , unbindService() und einen Messenger , um mit dem Dienst zu kommunizieren.

Hier sind die Service-Codes:

  • Anwendungslizenzierung vs Kopierschutz in Android
  • XML-Rendering-Fehler Android-Vorschau N
  • Erstellen Sie ein Array von Markern Google Maps V2
  • Applizieren listview rows nicht aktualisieren oder laden nach Marshmallow upgrade
  • Zugriff auf string.xml auf Java-Code in Android
  • So starten Sie Genymotion Gerät mit Shell-Befehl?
  •  public class MessengerService extends Service { private final Messenger mMessenger = new Messenger(new TempHandler()); private class TempHandler extends Handler { @Override public void handleMessage(Message msg) { switch (msg.what) { case MSG_SAY_HELLO: Toast.makeText(getApplicationContext(), "Hi, there.", Toast.LENGTH_SHORT).show(); break; case MSG_SAY_GOODBYE: Toast.makeText(getApplicationContext(), "See you next time.", Toast.LENGTH_SHORT).show(); break; case MSG_ECHO: Toast.makeText(getApplicationContext(), "Received " + msg.arg1 + " from client.", Toast.LENGTH_SHORT).show(); Messenger replyMessenger = msg.replyTo; Message replyMsg = Message.obtain(null, MSG_ECHO, msg.arg1, 0); try { replyMessenger.send(replyMsg); } catch (RemoteException e) { // TODO Auto-generated catch block e.printStackTrace(); } default: super.handleMessage(msg); } } } @Override public IBinder onBind(Intent intent) { Toast.makeText(getApplicationContext(), "Service bound", Toast.LENGTH_SHORT).show(); return mMessenger.getBinder(); } @Override public void onDestroy() { Log.d("", "Service.onDestroy()..."); super.onDestroy(); } } 

    Und hier ist der Aktivitätscode:

     public class MessengerActivity extends Activity { private Messenger mMessengerService; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity2); Button bind = (Button) findViewById(R.id.button5); bind.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { doBindService(); } }); Button unbind = (Button) findViewById(R.id.button6); unbind.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { doUnbindService(); } }); Button echo = (Button) findViewById(R.id.button7); echo.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { doSendEcho(); } }); } private void doBindService() { Intent intent = new Intent(getApplicationContext(), MessengerService.class); bindService(intent, mConnection, Context.BIND_AUTO_CREATE); } private void doUnbindService() { Message msg = Message.obtain(null, MessengerService.MSG_SAY_GOODBYE); try { mMessengerService.send(msg); } catch (RemoteException e) { // TODO Auto-generated catch block e.printStackTrace(); } unbindService(mConnection); } private void doSendEcho() { if (mMessengerService != null) { Message msg = Message.obtain(null, MessengerService.MSG_ECHO, 12345, 0); msg.replyTo = mMessenger; try { mMessengerService.send(msg); } catch (RemoteException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } private final Messenger mMessenger = new Messenger(new TempHandler()); private ServiceConnection mConnection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) { Toast.makeText(getApplicationContext(), "Service is connected.", Toast.LENGTH_SHORT).show(); mMessengerService = new Messenger(service); Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO); try { mMessengerService.send(msg); } catch (RemoteException e) { // TODO Auto-generated catch block e.printStackTrace(); } } @Override public void onServiceDisconnected(ComponentName name) { mMessengerService = null; Toast.makeText(getApplicationContext(), "Service is disconnected.", Toast.LENGTH_SHORT).show(); } }; private class TempHandler extends Handler { @Override public void handleMessage(Message msg) { switch (msg.what) { case MessengerService.MSG_ECHO: Toast.makeText(getApplicationContext(), "Get the echo message (" + msg.arg1 + ")", Toast.LENGTH_SHORT).show(); break; default: super.handleMessage(msg); } } } } 

    Wenn ich auf "Binde Service" und "Echo senden" klicken. Ich kann sehen, der Service ist verbunden und die Nachrichtenkommunikation ist gut. Und dann klicken Sie auf "unbind service", ich sah den Service onDestroy() aufgerufen werden, also erwarte ich, dass der Service gestoppt wird und nicht auf die kommende Nachricht wieder antworten sollte. Aber eigentlich ist der Service noch lebendig und ich könnte die Echo-Nachricht wieder bekommen, wenn du auf die Schaltfläche "Echo senden" klickst. Also ich frage mich, da ist alles was ich falsch gemacht habe Oder vielleicht verstehe ich mich nicht ganz über den Service?

    Hoffe jemand kann helfen, danke.

  • Binärdatei mit okhttp aus Ressourcen hochladen
  • Android Maps API v2 mit benutzerdefinierten Markierungen
  • Installieren / Unistall von Shell-Befehl in Android
  • Android-Signierung mit Ant
  • Verwenden Sie SyncAdapter, um mit * local * gmail und facebook app Daten zu synchronisieren
  • Android Valgrind Build scheitert
  • 5 Solutions collect form web for “Ist der Android-Service noch nach dem OnDestroy () aufgerufen?”

    Ein Dienst ist "gebunden", wenn eine Anwendungskomponente an sie bindet, indem sie bindService() . Ein gebundener Dienst bietet eine Client-Server-Schnittstelle, die es Komponenten ermöglicht, mit dem Service zu interagieren, Anfragen zu senden, Ergebnisse zu erhalten und sogar über Prozesse mit Interprozesskommunikation (IPC) zu verfahren. Ein gebundener Dienst läuft nur so lange, wie eine andere Anwendungskomponente daran gebunden ist .

    http://developer.android.com/guide/components/services.html

    Ein Dienst wird heruntergefahren, nachdem alle bindService() Anrufe ihre entsprechenden unbindService() Aufrufe unbindService() . Wenn es keine gebundenen Clients gibt, dann braucht der Service auch stopService () genau dann, wenn jemand den startService () auf den Service angerufen hat.

    Zeichnung aus dem untenstehenden Link.

    Wie überprüfe ich, ob ein Dienst auf Android läuft? .

     private void doSendEcho() { if(isMyServiceRunning()) // if service is running { if (mMessengerService != null) { Message msg = Message.obtain(null, MessengerService.MSG_ECHO, 12345, 0); msg.replyTo = mMessenger; try { mMessengerService.send(msg); } catch (RemoteException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } private boolean isMyServiceRunning() { ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE); for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) { if (MessengerService.class.getName().equals(service.service.getClassName())) { return true; } } return false; } @Override protected void onStop() { super.onStop(); // Unbind from the service unbindService(mConnection); Log.i("Stopped!",""+isMyServiceRunning()); Log.i("stopped", "Service Stopped"); } 

    Beispiel:

    Ich habe das unten getestet.

     public class MessengerService extends Service { public static final int MSG_SAY_HELLO =1; public static final int MSG_SAY_GOODBYE =2; ArrayList<Messenger> mClients = new ArrayList<Messenger>(); private final Messenger mMessenger = new Messenger(new TempHandler()); private class TempHandler extends Handler { @Override public void handleMessage(Message msg) { switch (msg.what) { case MSG_SAY_HELLO: mClients.add(msg.replyTo); Toast.makeText(getApplicationContext(), "Hi, there.", Toast.LENGTH_SHORT).show(); break; case MSG_SAY_GOODBYE: mClients.add(msg.replyTo); break; default: super.handleMessage(msg); } } } @Override public IBinder onBind(Intent intent) { Toast.makeText(getApplicationContext(), "Service bound", Toast.LENGTH_SHORT).show(); return mMessenger.getBinder(); } @Override public void onDestroy() { Log.i("MessengerService", "Service Destroyed..."); super.onDestroy(); } } 

    HauptAktivität.java

     public class MainActivity extends Activity { boolean mIsBound=false; Messenger mService = null; private boolean isMyServiceRunning() { ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE); for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) { if (MessengerService.class.getName().equals(service.service.getClassName())) { return true; } } return false; } @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Button bind = (Button) findViewById(R.id.button1); bind.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { doBindService(); } }); Button unbind = (Button) findViewById(R.id.button2); unbind.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { doUnbindService(); } }); } class TempHandler extends Handler { @Override public void handleMessage(Message msg) { switch (msg.what) { case MessengerService.MSG_SAY_GOODBYE: Toast.makeText(MainActivity.this,"Received from service: " + msg.arg1,1000).show(); break; default: super.handleMessage(msg); } } } /** * Target we publish for clients to send messages to IncomingHandler. */ final Messenger mMessenger = new Messenger(new TempHandler()); /** * Class for interacting with the main interface of the service. */ private ServiceConnection mConnection = new ServiceConnection() { public void onServiceConnected(ComponentName className, IBinder service) { // This is called when the connection with the service has been // established, giving us the service object we can use to // interact with the service. We are communicating with our // service through an IDL interface, so get a client-side // representation of that from the raw service object. mService = new Messenger(service); // mCallbackText.setText("Attached."); // We want to monitor the service for as long as we are // connected to it. try { Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO); msg.replyTo = mMessenger; mService.send(msg); // Give it some value as an example. // msg = Message.obtain(null, // MessengerService.MSG_E, this.hashCode(), 0); // mService.send(msg); } catch (RemoteException e) { // In this case the service has crashed before we could even // do anything with it; we can count on soon being // disconnected (and then reconnected if it can be restarted) // so there is no need to do anything here. } // As part of the sample, tell the user what happened. Toast.makeText(MainActivity.this, "remote_service_connected", Toast.LENGTH_SHORT).show(); } public void onServiceDisconnected(ComponentName className) { // This is called when the connection with the service has been // unexpectedly disconnected -- that is, its process crashed. mService = null; // mCallbackText.setText("Disconnected."); // As part of the sample, tell the" user what happened. Toast.makeText(MainActivity.this, "remote_service_disconnected", Toast.LENGTH_SHORT).show(); } }; void doBindService() { // Establish a connection with the service. We use an explicit // class name because there is no reason to be able to let other // applications replace our component. bindService(new Intent(MainActivity.this, MessengerService.class), mConnection, Context.BIND_AUTO_CREATE); mIsBound=true; Toast.makeText(MainActivity.this, "Binding",1000).show(); } void doUnbindService() { if (mIsBound) { // If we have received the service, and hence registered with // it, then now is the time to unregister. if (mService != null) { try { Message msg = Message.obtain(null, MessengerService.MSG_SAY_GOODBYE); msg.replyTo = mMessenger; mService.send(msg); } catch (RemoteException e) { // There is nothing special we need to do if the service // has crashed. } } // Detach our existing connection. unbindService(mConnection); mIsBound = false; Toast.makeText(MainActivity.this, "UnBinding"+isMyServiceRunning(),1000).show(); } } } 

    Dieser Link ( muss ich sowohl unbindService als auch stopService für Android-Dienste anrufen ), sagt, dass du stopService vor unbindService anrufen musst.

    Versuch das.

    Von http://developer.android.com/guide/components/services.html :

    Diese beiden Wege sind nicht ganz getrennt. Das heißt, Sie können an einen Dienst binden, der bereits mit startService () gestartet wurde. Beispielsweise könnte ein Hintergrundmusikdienst gestartet werden, indem startService () mit einer Absicht aufgerufen wird, die die zu spielende Musik identifiziert. Später, vielleicht, wenn der Benutzer eine gewisse Kontrolle über den Spieler ausüben oder Informationen über den aktuellen Song erhalten möchte, kann eine Aktivität an den Service binden, indem er bindService () anruft. In solchen Fällen stoppt stopService () oder stopSelf () nicht wirklich den Service, bis alle Clients unbind sind.

    Also musst du unBindService () anrufen und nach stopService ()

    Ich persönlich finde die Terminologie / Nomenklatur unzufrieden / irreführend. "OnDestroy" und "stopService" könnten besser verstanden werden, wenn sie "FlagForAndroidOSDestruction" und "FlagForAndroidStopService" genannt wurden.

    Wenn man eines der folgenden Beispiele herunterlädt / kompiliert / ausführt, kann man sehen, dass auch wenn der OnHandleIntent fertig ist oder stopService aufgerufen wurde, kann der Prozess und sogar der Service noch herumhängen! Um dies zu sehen, starten Sie einfach das / die Beispiel (e) unten, und dann auf Ihrem Telefon / Tablet auf Einstellungen-> App-> Running-> Show Running Services und Einstellungen-> App-> Running-> Cache-Prozesse anzeigen

    Wenn Sie diese sehen, versuchen Sie, eine Tonne von anderen Apps am Telefon zu starten und dann sehen Sie Android, das den Service & Prozess zerstört.

    http://developer.android.com/guide/components/services.html#ExtendingIntentService

    http://android-er.blogspot.com/2013/03/stop-intentservice.html

    Wie überprüfe ich alle laufenden Dienste in Android?

    Ja, das ist eine Schlussfolgerung aus den offiziellen Dokumenten :

    Ein Service kann sowohl gestartet werden als auch Verbindungen haben. In einem solchen Fall wird das System den Dienst so lange beibehalten, wie es entweder gestartet wird, oder es gibt eine oder mehrere Verbindungen zu ihm mit dem Context.BIND_AUTO_CREATE-Flag. Sobald keine dieser Situationen vorliegt , wird die onDestroy () – Methode des Dienstes aufgerufen und der Service wird effektiv beendet . Alle Bereinigungen (Stoppen von Threads, unregistrierende Empfänger) sollten bei der Rückkehr von onDestroy () abgeschlossen sein.

    Das Android ist ein Google Android Fan-Website, Alles ├╝ber Android Phones, Android Wear, Android Dev und Android Spiele Apps und so weiter.