Einführung in diesen Abschnitt
Also gut, in den vorherigen drei Abschnitten haben wir Activity in Android studiert und gelernt. Ich glaube, jeder hat sehr davon profitiert! In diesem Abschnitt lernen wir weiter über die zweite Komponente in Android: Service. Nun, ohne weitere Umschweife, beginnen wir mit dem Inhalt dieses Abschnitts!
1. Thread-bezogene Konzepte
Bevor wir mit dem Lernen über Service beginnen, wollen wir zunächst einige Konzepte zu Threads verstehen!
1) Verwandte Konzepte:
- Programm: Eine Menge von Anweisungen, die in einer bestimmten Sprache geschrieben wurden, um eine bestimmte Aufgabe zu erfüllen (eine Menge vonstatischem Code)
- Prozess:Ein laufendes Programm, eine Einheit der Systemplanung und Ressourcenzuweisung, eine unabhängige Einheit, das Betriebssystem weist jedem Prozess einen Speicherbereich zu! Der sequenzielle dynamische Ablauf eines Programms ist der vollständige Vorgang des Ladens, Ausführens und Beendens von Code!
- Thread: Eine Ausführungseinheit, die kleiner als ein Prozess ist. Jeder Prozess kann mehrere Threads haben,Threadmuss in einemProzessplatziert werden, um ausgeführt zu werden,Threads werden vom Programm verwaltet, währendProzesse vom System geplant werden!
- Multithreading verstehen:Parallelmehrere Anweisungen ausführen undCPU-Zeitscheibennach dem Planungsalgorithmus auf jeden Thread verteilen. Tatsächlich ist esTime-SharingAusführung, aber die Umschaltzeit ist sehr kurz, sodass Nutzer einfach das Gefühl haben, es sei "gleichzeitig"!
2) Lebenszyklus eines Threads:

3) Drei Möglichkeiten zum Erstellen von Threads:
- Von der Thread-Klasse erben
- Das Runnable-Interface implementieren
- Implementiere die Callable-SchnittstelleFalls du den in 2 erstellten Thread verwendest, kannst du ihn direkt so starten:
new Thread(myThread).start();Häufiger verwenden wir anonyme Klassen, d. h. den folgenden Stil:new Thread(new Runnable(){ public void run(); }).start();
2. Unterschiede zwischen Service und Thread
Eigentlich besteht zwischen ihnen nicht viel Beziehung, aber viele Freunde verwechseln die beiden oft! Thread ist ein Thread, die kleinste Einheit der Programmausführung und die grundlegende Einheit für die CPU-Zuweisung! Service hingegen ist eine von Android bereitgestellte Komponente, die sich langfristig im Hintergrund aufhalten kann. Der häufigste Verwendungszweck ist die Durchführung von Polling-Operationen! Oder wenn du etwas im Hintergrund erledigen möchtest, z. B. Updates im Hintergrund herunterladen! Denk daran, diese beiden Konzepte nicht zu verwechseln!
3. Lebenszyklusdiagramm von Service

4. Analyse des Lebenszyklus
Okay, aus dem obigen Lebenszyklusdiagramm können wir erkennen, dass es in Android zwei Möglichkeiten gibt, Service zu verwenden:
1)StartService() zum Starten von Service
2)BindService() zum Starten von Service
PS: Es gibt noch eine andere Möglichkeit, nämlich den Service nach dem Start zu binden!
1) Detaillierte Erklärung der zugehörigen Methoden:
- onCreate()onCreate(): Wenn der Service zum ersten Mal erstellt wird, wird diese Methode sofort aufgerufen; diese Methode wird im gesamten Lebenszyklus nur einmal aufgerufen!
- onDestory()onDestroy(): Wenn der Service geschlossen wird, wird diese Methode aufgerufen; diese Methode wird nur einmal aufgerufen!
- onStartCommand(intent,flag,startId)onStartCommand(): In früheren Versionen war es onStart(intent, startId). Wenn ein Client die Methode startService(Intent) aufruft, wird onStartCommand() aufgerufen. Die Methode StartService kann mehrfach aufgerufen werden, aber es wird kein neues Service-Objekt erstellt; stattdessen wird das zuvor erstellte Service-Objekt wiederverwendet, aber die Methode onStartCommand() wird weiterhin aufgerufen!
- IBinder onOnbind(intent)onBind(): Diese Methode muss von allen Services implementiert werden. Diese Methode gibt ein IBinder-Objekt zurück, über das die App mit der Service-Komponente kommuniziert!
- onUnbind(intent)onUnbind(): Diese Methode wird aufgerufen, wenn alle an den Service gebundenen Clients getrennt werden!
2) StartService zum Starten des Service
①Beim ersten Start wird eine Service-Instanz erstellt und die Methoden onCreate() und onStartCommand() werden nacheinander aufgerufen. An diesem Punkt geht der Service in den laufenden Zustand über. Wenn StartService erneut aufgerufen wird, um den Service zu starten, wird kein neues Service-Objekt erstellt. Das System verwendet das zuvor erstellte Service-Objekt direkt wieder und ruft seine Methode onStartCommand() auf!
②Aber ein solcher Service hat keine notwendige Verbindung zu seinem Aufrufer. Das heißt, wenn der Aufrufer seinen eigenen Lebenszyklus beendet, läuft der Service weiter, solange stopService nicht aufgerufen wird!
③Unabhängig davon, wie oft der Service gestartet wurde, müssen Sie StopService nur einmal aufrufen, um den Service zu stoppen.
3) BindService zum Starten des Service
①Wenn ein Service zum ersten Mal mit bindService gebunden wird, instanziiert das System eine Service-Instanz und ruft deren onCreate()- und onBind()-Methoden auf. Danach kann der Aufrufer über IBinder mit dem Service interagieren. Wenn anschließend bindService erneut verwendet wird, um den Service zu binden, erstellt das System keine neue Service-Instanz und ruft die onBind()-Methode auch nicht erneut auf; es übergibt das IBinder-Objekt einfach direkt an weitere später hinzugefügte Clients!
②Wenn wir die Bindung an den Service aufheben möchten, müssen wir nur unbindService() aufrufen. Zu diesem Zeitpunkt werden die Methoden onUnbind und onDestroy aufgerufen! Dies ist der Fall bei einem Client. Wenn mehrere Clients an denselben Service binden, ist die Situation wie folgt: Nachdem ein Client seine Interaktion mit dem Service beendet hat, ruft er die unbindService()-Methode auf, um die Bindung aufzuheben. Wenn alle Clients die Bindung an den Service aufgehoben haben, zerstört das System den Service. (Es sei denn, der Service wurde auch durch die startService()-Methode gestartet.)
③Darüber hinaus unterscheidet sich der Service im bindService-Modus von der oben genannten Situation: Er ist mit dem Aufrufer verbunden. Man kann es verstehen als "Grashüpfer, an dasselbe Seil gebunden" — wenn einer stirbt, sterben alle zusammen. Nach bindService wird der Service, sobald der Aufrufer zerstört wird, ebenfalls sofort beendet!
Analyse von Context.bindService() beim Aufrufen des Service über BindServicebindService(Intent Service,ServiceConnection conn,int flags)
service: Der zu startende Service wird durch diesen Intent festgelegt.
conn: ServiceConnection-Objekt, wird verwendet, um die Verbindung zwischen dem Besucher und dem Service zu überwachen. Bei erfolgreicher Verbindung wird die onServiceConnected(ComponentName, IBinder)-Methode in diesem Objekt als Callback aufgerufen; wenn der Host, auf dem der Service läuft, aufgrund einer fehlerhaften Beendigung oder aus anderen Gründen beendet wird, wodurch die Verbindung zwischen dem Service und dem Besucher getrennt wird, wird aufgerufenonServiceDisconnected(ComponentName)-Methode: Wenn aktiv überunBindService()die Verbindung getrennt wird, wird die obige Methode nicht aufgerufen!
flags:Gibt an, ob der Service beim Binden automatisch erstellt werden soll (falls der Service noch nicht erstellt wurde). Der Parameter kann 0 sein (nicht automatisch erstellen) oder BIND_AUTO_CREATE (automatisch erstellen).4) Binden über bindService nach dem Starten des Service mit StartService
4) Binden über bindService nach dem Starten des Service mit StartService
Die Voraussetzung ist: Die onUnbind()-Methode gibt true zurück!!!
onCreate( )->onStartCommand( )->onBind( )->onUnbind( )->onRebind( )
PS:Hier könnten einige Leser verwirrt sein. Sollte der Service nach dem Aufruf von unbindService nicht die onDestroy()-Methode aufrufen? Tatsächlich liegt das daran, dass dieser Service durch unser StartService gestartet wurde; wenn Sie also die onUnbind()-Methode aufrufen, um die Bindung zu lösen, wird der Service ebenfalls nicht beendet!
Fazit:Wenn wir bindService verwenden, um einen gestarteten Service zu binden, beachten Sie, dass es sich um einen bereits gestarteten Service handelt!!! Das System übergibt nur das interne IBinder-Objekt des Service an die Activity und bindet den Lebenszyklus des Service nicht an die Activity. Wenn daher unBindService() zum Lösen der Bindung aufgerufen wird, wird der Service nicht zerstört!
5. Überprüfung des Lebenszyklus
Als Nächstes schreiben wir Code, um den Lebenszyklus zu überprüfen:
1) Überprüfen der Aufrufreihenfolge beim Starten des Service mit StartService
Zuerst definieren wir einen benutzerdefinierten Service, überschreiben die relevanten Methoden und geben die Überprüfung in logcat aus:
TestService1.java
public class TestService1 extends Service {
private final String TAG = "TestService1";
//必须要实现的方法
@Override
public IBinder onBind(Intent intent) {
Log.i(TAG, "onBind方法被调用!");
return null;
}
//Service被创建时调用
@Override
public void onCreate() {
Log.i(TAG, "onCreate方法被调用!");
super.onCreate();
}
//Service被启动时调用
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.i(TAG, "onStartCommand方法被调用!");
return super.onStartCommand(intent, flags, startId);
}
//Service被关闭之前回调
@Override
public void onDestroy() {
Log.i(TAG, "onDestory方法被调用!");
super.onDestroy();
}
}
Vollständige Service-Registrierung in AndroidManifest.xml
<!-- 配置Service组件,同时配置一个action -->
<service android:name=".TestService1">
<intent-filter>
<action android:name="com.jay.example.service.TEST_SERVICE1"/>
</intent-filter>
</service>
Als Nächstes folgt eine einfache Layoutdatei mit zwei Schaltflächen und schließlich die MainActivity. Rufen Sie in den Klickereignissen der Schaltflächen jeweils startService() und stopService() auf!
public class MainActivity extends Activity {
private Button start;
private Button stop;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
start = (Button) findViewById(R.id.btnstart);
stop = (Button) findViewById(R.id.btnstop);
//创建启动Service的Intent,以及Intent属性
final Intent intent = new Intent();
intent.setAction("com.jay.example.service.TEST_SERVICE1");
//为两个按钮设置点击事件,分别是启动与停止service
start.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startService(intent);
}
});
stop.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
stopService(intent);
}
});
}
}
Screenshot der Ausführung:

Klicken, um den Service zu starten:

Da Sie nichts Besseres zu tun haben, klicken Sie noch ein paar Mal:

Klicken Sie schließlich, um den Service zu stoppen:

Ergebnisanalyse:
Anhand der obenstehenden Ausführungsergebnisse können wir überprüfen, was in unserem Lebenszyklusdiagramm erklärt wurde: Wir stellen fest, dass die Methode onBind() nicht aufgerufen wird. Außerdem wird durch mehrfaches Klicken zum Starten des Service nur wiederholt die Methode onStartCommand aufgerufen! Egal, wie oft wir den Service starten, ein stopService stoppt den Service!
2) Überprüfen Sie die Reihenfolge beim Starten des Service mit BindService:
Bevor wir mit dem Schreiben von Code beginnen, müssen wir zuerst ein paar Dinge verstehen: Zuerst die Methode bindService von Context, die unter dem ersten großen Diagramm angegeben ist:
- ServiceConnection-Objekt: überwacht die Verbindung zwischen dem Besucher und dem Service. Wenn die Verbindung erfolgreich ist, wird onServiceConnected() aufgerufen. Wenn die Verbindung abnormal oder aus anderen Gründen beendet wird, sodass der Service vom Besucher getrennt wird, wird die Methode onServiceDisconnected aufgerufen. Der Aufruf von unBindService() ruft diese Methode nicht auf!
- In der Methode onServiceConnected gibt es ein IBinder-Objekt, mit dem mit dem gebundenen Service kommuniziert werden kann! Wenn wir eine Service-Klasse entwickeln, müssen wir standardmäßig die IBinder-Methode onBind() implementieren. Das von dieser Methode zurückgegebene IBinder-Objekt wird an den Parameter von onServiceConnected im ServiceConnection-Objekt übergeben. Hier können wir über dieses IBinder mit dem Service kommunizieren!
Zusammenfassung:
Schritt 1:Erben Sie im benutzerdefinierten Service von Binder, um Ihr eigenes IBinder-Objekt zu implementieren.
Schritt 2:Geben Sie Ihr eigenes IBinder-Objekt über die onBind()-Methode zurück.
Schritt 3:Definieren Sie in der Klasse, die den Service bindet, ein ServiceConnection-Objekt und überschreiben Sie zwei Methoden, onServiceConnected und onDisconnected! Dann lesen Sie einfach direkt die vom IBinder übergebenen Parameter!
Gut, als Nächstes schreiben wir Code zur Überprüfung. Hier definieren wir einen Service für die Zeitmessung und demonstrieren dann die Verwendung von BindService und den Ablauf der Methodenaufrufe! Der Code ist relativ einfach, daher erklären wir ihn nicht!
TestService2.java:
public class TestService2 extends Service {
private final String TAG = "TestService2";
private int count;
private boolean quit;
//定义onBinder方法所返回的对象
private MyBinder binder = new MyBinder();
public class MyBinder extends Binder
{
public int getCount()
{
return count;
}
}
//必须实现的方法,绑定改Service时回调该方法
@Override
public IBinder onBind(Intent intent) {
Log.i(TAG, "onBind方法被调用!");
return binder;
}
//Service被创建时回调
@Override
public void onCreate() {
super.onCreate();
Log.i(TAG, "onCreate方法被调用!");
//创建一个线程动态地修改count的值
new Thread()
{
public void run()
{
while(!quit)
{
try
{
Thread.sleep(1000);
}catch(InterruptedException e){e.printStackTrace();}
count++;
}
};
}.start();
}
//Service断开连接时回调
@Override
public boolean onUnbind(Intent intent) {
Log.i(TAG, "onUnbind方法被调用!");
return true;
}
//Service被关闭前回调
@Override
public void onDestroy() {
super.onDestroy();
this.quit = true;
Log.i(TAG, "onDestroyed方法被调用!");
}
@Override
public void onRebind(Intent intent) {
Log.i(TAG, "onRebind方法被调用!");
super.onRebind(intent);
}
}
Registrieren Sie die Service-Komponente in AndroidManifest.xml:
<service android:name=".TestService2" android:exported="false">
<intent-filter>
<action android:name="com.jay.example.service.TEST_SERVICE2"/>
</intent-filter>
</service>
MainActivity.java:
public class MainActivity extends Activity {
private Button btnbind;
private Button btncancel;
private Button btnstatus;
//保持所启动的Service的IBinder对象,同时定义一个ServiceConnection对象
TestService2.MyBinder binder;
private ServiceConnection conn = new ServiceConnection() {
//Activity与Service断开连接时回调该方法
@Override
public void onServiceDisconnected(ComponentName name) {
System.out.println("------Service DisConnected-------");
}
//Activity与Service连接成功时回调该方法
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
System.out.println("------Service Connected-------");
binder = (TestService2.MyBinder) service;
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btnbind = (Button) findViewById(R.id.btnbind);
btncancel = (Button) findViewById(R.id.btncancel);
btnstatus = (Button) findViewById(R.id.btnstatus);
final Intent intent = new Intent();
intent.setAction("com.jay.example.service.TEST_SERVICE2");
btnbind.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
//绑定service
bindService(intent, conn, Service.BIND_AUTO_CREATE);
}
});
btncancel.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
//解除service绑定
unbindService(conn);
}
});
btnstatus.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(getApplicationContext(), "Service的count的值为:"
+ binder.getCount(), Toast.LENGTH_SHORT).show();
}
});
}
}
Screenshot der Ausführung:

Klicken Sie, um den Service zu binden:

Klicken Sie weiter auf Binden: keine Änderung.

Aktuellen Service-Status abrufen:

Bindung aufheben:

Wenn wir die Activity nach dem Binden direkt schließen, wird ein Fehler gemeldet, und dann werden automatisch die Methoden onUnbind und onDestroy aufgerufen!
。。。

Aus den obigen Ausführungsergebnissen wird Folgendes im Lebenszyklusdiagramm verifiziert:
Mit BindService wird ein Service gebunden; dabei werden die Methoden onCreate() und onBind() in dieser Reihenfolge aufgerufen. In der Methode onBind() können wir ein benutzerdefiniertes IBinder-Objekt zurückgeben. Als Nächstes wird die Methode onServiceConnected() von ServiceConnection aufgerufen, in der das IBinder-Objekt für zugehörige Operationen abgerufen werden kann. Wenn die Bindung des Service aufgehoben wird, werden die Methoden onUnbind und onDestroy automatisch aufgerufen. Wenn mehrere Clients gebunden sind, müssen natürlich erst alle Bindungen aufgehoben werden, bevor die Methode onDestroy zur Zerstörung aufgerufen wird!