Abschnittseinleitung
Im vorherigen Abschnitt haben wir den Lebenszyklus von Service und die beiden Methoden zum Starten eines Service kennengelernt. In diesem Abschnitt vertiefen wir unser Verständnis von IntentService in Service weiter und behandeln Service-Anwendungsbeispiele: Implementierung von Vordergrunddiensten und Polling!
1. Verwendung von IntentService
Nach dem vorherigen Abschnitt wissen wir bereits, wie man einen Service definiert und startet. Aber wenn wir direkt einen zeitaufwändigen Thread in die onStart()-Methode eines Service einfügen, ist dies zwar möglich, kann aber leicht eine ANR-Ausnahme (Application Not Responding) verursachen. In der offiziellen Android-Einführung in Service gibt es folgenden Abschnitt:

Direkte Übersetzung:
1. Ein Service ist kein separater Prozess; er läuft im selben Prozess wie seine Anwendung.
2. Ein Service ist kein Thread, was bedeutet, dass wir zeitaufwändige Operationen in einem Service vermeiden sollten.
Daher bietet uns Android eine Alternative, um das obige Problem zu lösen, und das ist das, worüber wir als Nächstes sprechen werdenIntentService; IntentService ist eine Klasse, die von Service erbt und asynchrone Anfragen verarbeitet. In IntentService gibt es einen Worker-Thread, um zeitaufwändige Operationen zu verarbeiten, und die angeforderten Intent-Einträge werden einer Warteschlange hinzugefügt.
Workflow:
Der Client startet IntentService über startService(Intent); wir müssen IntentService nicht manuell steuern. Wenn die Aufgabe abgeschlossen ist, wird IntentService automatisch beendet. IntentService kann mehrmals gestartet werden, und jeder zeitaufwändige Vorgang wird in der onHandleIntent-Callback-Methode von IntentService nach Art einer Arbeitswarteschlange ausgeführt, wobei jeweils nur ein Worker-Thread ausgeführt wird. Nach Abschluss des ersten wird mit dem zweiten fortgefahren, und so weiter!
Als Nächstes folgt die Code-Demonstration. Der Großteil des Online-Codes vergleicht Service und IntentService, definiert eine ausreichend lange Sleep-Zeit, um die ANR-Ausnahme von Service zu demonstrieren, und zeigt dann, wie gut IntentService ist. Wir werden Service hier nicht demonstrieren. Online-Beispiele definieren einen benutzerdefinierten Service und verwenden dann Thread.sleep(20000) in der onStart()-Methode, um eine ANR-Ausnahme zu verursachen. Wenn Sie interessiert sind, können Sie versuchen, den Code selbst zu schreiben. Hier demonstrieren wir nur die Verwendung von IntentService!
TestService3.java
public class TestService3 extends IntentService {
private final String TAG = "hehe";
//必须实现父类的构造方法
public TestService3()
{
super("TestService3");
}
//必须重写的核心方法
@Override
protected void onHandleIntent(Intent intent) {
//Intent是从Activity发过来的,携带识别参数,根据参数不同执行不同的任务
String action = intent.getExtras().getString("param");
if(action.equals("s1"))Log.i(TAG,"启动service1");
else if(action.equals("s2"))Log.i(TAG,"启动service2");
else if(action.equals("s3"))Log.i(TAG,"启动service3");
//让服务休眠2秒
try{
Thread.sleep(2000);
}catch(InterruptedException e){e.printStackTrace();}
}
//重写其他方法,用于查看方法的调用顺序
@Override
public IBinder onBind(Intent intent) {
Log.i(TAG,"onBind");
return super.onBind(intent);
}
@Override
public void onCreate() {
Log.i(TAG,"onCreate");
super.onCreate();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.i(TAG,"onStartCommand");
return super.onStartCommand(intent, flags, startId);
}
@Override
public void setIntentRedelivery(boolean enabled) {
super.setIntentRedelivery(enabled);
Log.i(TAG,"setIntentRedelivery");
}
@Override
public void onDestroy() {
Log.i(TAG,"onDestroy");
super.onDestroy();
}
}
Registrieren Sie den Service in AndroidManifest.xml
<service android:name=".TestService3" android:exported="false">
<intent-filter >
<action android:name="com.test.intentservice"/>
</intent-filter>
</service>
Starten Sie den Service dreimal in MainActivity:
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Intent it1 = new Intent("com.test.intentservice");
Bundle b1 = new Bundle();
b1.putString("param", "s1");
it1.putExtras(b1);
Intent it2 = new Intent("com.test.intentservice");
Bundle b2 = new Bundle();
b2.putString("param", "s2");
it2.putExtras(b2);
Intent it3 = new Intent("com.test.intentservice");
Bundle b3 = new Bundle();
b3.putString("param", "s3");
it3.putExtras(b3);
//接着启动多次IntentService,每次启动,都会新建一个工作线程
//但始终只有一个IntentService实例
startService(it1);
startService(it2);
startService(it3);
}
}
Screenshot der Ausführung:

Zusammenfassung:
Wenn eine Hintergrundaufgabe in mehrere Teilaufgaben unterteilt und nacheinander ausgeführt werden muss, die Teilaufgaben (einfach ausgedrückt: asynchrone Operationen) – wenn wir dann immer noch einen normalen Service definieren und anschließend Threads in der onStart-Methode erstellen und dann die Threads steuern müssen, wird es sehr umständlich. An diesem Punkt sollten wir einen benutzerdefinierten IntentService definieren und dann die relevanten Aufgaben in der onHandleIntent()-Methode erledigen!
2. Kommunikation zwischen Activity und Service
Unsere bisherigen Operationen haben den Service über die Activity gestartet und gestoppt. Angenommen, wir starten einen Hintergrund-Service zum Herunterladen, und wir möchten den Fortschritt der Download-Aufgabe im Service wissen! Dann erfordert dies sicherlich eine Kommunikation zwischen dem Service und der Activity, und das Medium für ihre Kommunikation ist die onBind()-Methode im Service! Sie gibt ein benutzerdefiniertes Binder-Objekt zurück, das wir definieren!
Der grundlegende Ablauf ist wie folgt:
- 1. Definieren Sie in einem benutzerdefinierten Service eine benutzerdefinierte Binder-Klasse und schreiben Sie alle Methoden, die verfügbar gemacht werden sollen, in diese Klasse!
- 2. Instanziieren Sie in der Service-Klasse diese benutzerdefinierte Binder-Klasse, überschreiben Sie dann die onBind()-Methode und geben Sie dieses Binder-Objekt zurück!
- 3. Instanziieren Sie in der Activity-Klasse ein ServiceConnection-Objekt, überschreiben Sie die onServiceConnected()-Methode, rufen Sie dann das Binder-Objekt ab und rufen Sie die relevanten Methoden auf!
3. Implementierung eines einfachen Vordergrunddienstes
Bis jetzt wissen wir alle, dass ein Service normalerweise im Hintergrund läuft, aber die Systempriorität eines Service relativ niedrig ist. Wenn der Systemspeicher knapp wird, kann der im Hintergrund laufende Service recycelt werden. Für diese Situation können wir einen Vordergrunddienst verwenden, damit der Service etwas seltener vom System beendet wird. Natürlich kann er trotzdem beendet werden ... Der sogenannte Vordergrunddienst ist die in der Statusleiste angezeigte Benachrichtigung!
Die Umsetzung ist ebenfalls sehr einfach. Das Projekt, an dem ich kürzlich gearbeitet habe, hat zufällig diesen Vordergrunddienst verwendet, also habe ich den Kerncode extrahiert und teile ihn:
In der benutzerdefinierten Service-Klasse überschreiben Sie onCreate() und passen dann die Benachrichtigung nach Ihren Bedürfnissen an. Rufen Sie nach der Anpassung startForeground(1, Benachrichtigungsobjekt) auf, und schon sind Sie fertig!Der Kerncode sieht wie folgt aus:
public void onCreate()
{
super.onCreate();
Notification.Builder localBuilder = new Notification.Builder(this);
localBuilder.setContentIntent(PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), 0));
localBuilder.setAutoCancel(false);
localBuilder.setSmallIcon(R.mipmap.ic_cow_icon);
localBuilder.setTicker("Foreground Service Start");
localBuilder.setContentTitle("Socket服务端");
localBuilder.setContentText("正在运行...");
startForeground(1, localBuilder.getNotification());
}
Screenshot des Laufeffekts:

4. Implementierung eines einfachen geplanten Hintergrund-Threads
Neben dem oben genannten Vordergrunddienst hat Service in der tatsächlichen Entwicklung eine weitere häufige Verwendung: die Ausführung geplanter Aufgaben, wie z. B. Polling, bei dem in Intervallen der Server angefragt wird, um den Client-Status zu bestätigen oder Informationen zu aktualisieren usw.! Android bietet uns zwei Zeitsteuerungsmethoden: die Verwendung der Timer-Klasse und des Alarm-Mechanismus!
Ersterer ist nicht für geplante Aufgaben geeignet, die über lange Zeit im Hintergrund laufen müssen. Sobald die CPU schläft, können die geplanten Aufgaben im Timer nicht ausgeführt werden; beim Alarm gibt es dieses Problem nicht. Er hat die Funktion, die CPU aufzuwecken. Darüber hinaus müssen wir auch zwischen dem Aufwecken der CPU und dem Aufwecken des Bildschirms unterscheiden!
Verwendungsablauf:
- Schritt 1: Den Service abrufen: AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
- Schritt 2: Die geplante Aufgabe über die set-Methode festlegen int anHour = 2 * 1000; long triggerAtTime = SystemClock.elapsedRealtime() + anHour; manager.set(AlarmManager.RTC_WAKEUP,triggerAtTime,pendingIntent);
- Schritt 3: Einen Service definierenStarten Sie in onStartCommand einen Worker-Thread, um eine gewisse Zeitsteuerungslogik zu behandeln.
- Schritt 4: Definiere einen Broadcast, um den Service zu starten.Vergiss schließlich nicht, den Service und den Broadcast in AndroidManifest.xml zu registrieren!
Parametererklärung: set(int type,long startTime,PendingIntent pi)
①type:Es gibt fünf mögliche Werte:
AlarmManager.ELAPSED_REALTIME:Der Alarm ist nicht verfügbar, wenn sich das Telefon im Schlafmodus befindet. In diesem Zustand verwendet der Alarm relative Zeit (relativ zum Systemstart), mit Statuswert 3;
AlarmManager.ELAPSED_REALTIME_WAKEUPDer Alarm weckt das System auf und führt die Benachrichtigungsfunktion aus, wenn das System schläft. In diesem Zustand verwendet der Alarm ebenfalls relative Zeit, mit Statuswert 2;
AlarmManager.RTCDer Alarm ist nicht verfügbar, wenn das System schläft. In diesem Zustand verwendet der Alarm absolute Zeit, d. h. die aktuelle Systemzeit, mit Statuswert 1;
AlarmManager.RTC_WAKEUPGibt an, dass der Alarm das System aufweckt und die Benachrichtigungsfunktion ausführt, wenn das System schläft. In diesem Zustand verwendet der Alarm absolute Zeit, mit Statuswert 0;
AlarmManager.POWER_OFF_WAKEUPGibt an, dass der Alarm die Benachrichtigungsfunktion auch dann normal ausführen kann, wenn das Telefon ausgeschaltet ist, daher ist er einer der am häufigsten verwendeten Zustände unter den fünf Zuständen. In diesem Zustand verwendet der Alarm ebenfalls absolute Zeit, mit Statuswert 4. Dieser Zustand scheint jedoch von der SDK-Version beeinflusst zu werden, und einige Versionen unterstützen ihn nicht;
PS: Der erste Parameter bestimmt den Typ des zweiten Parameters. Wenn es REALTIME ist, verwende: SystemClock.elapsedRealtime()-Methode, um die Anzahl der Millisekunden abzurufen, die seit dem Systemstart bis jetzt vergangen sind. Wenn es RTC ist, verwende: System.currentTimeMillis(), um die Anzahl der Millisekunden abzurufen, die seit 1970.1.1 0:00 bis jetzt vergangen sind.
②startTime:Die erste Ausführungszeit des Alarms, in Millisekunden. Sie können die Zeit anpassen, aber im Allgemeinen wird die aktuelle Zeit verwendet. Es ist zu beachten, dass diese Eigenschaft eng mit der ersten Eigenschaft (type) zusammenhängt. Wenn der Alarm, der dem ersten Parameter entspricht, relative Zeit verwendet (ELAPSED_REALTIMEundELAPSED_REALTIME_WAKEUP), dann muss diese Eigenschaft relative Zeit verwenden (relativ zur Systemstartzeit). Zum Beispiel wird die aktuelle Zeit ausgedrückt als: SystemClock.elapsedRealtime(); wenn der Alarm, der dem ersten Parameter entspricht, absolute Zeit verwendet (RTC, RTC_WAKEUP, POWER_OFF_WAKEUP), dann muss diese Eigenschaft absolute Zeit verwenden. Zum Beispiel wird die aktuelle Zeit ausgedrückt als: System.currentTimeMillis().
③PendingIntent:Er bindet die Ausführungsaktion des Alarms, z. B. das Senden eines Broadcasts, das Anzeigen einer Benachrichtigung usw. PendingIntent ist eine Wrapper-Klasse für Intent.
Es ist zu beachten, dass, wenn die Alarmbenachrichtigung durch Starten eines Dienstes implementiert wird, das PendingIntent-Objekt mit der Methode Pending.getService(Context c, int i, Intent intent, int j) abgerufen werden sollte;
Wenn die Alarmbenachrichtigung über einen Broadcast implementiert wird, sollte das PendingIntent-Objekt mit der Methode PendingIntent.getBroadcast (Context c,int i,Intent intent,int j) abgerufen werden;
Wenn die Alarmbenachrichtigung mithilfe einer Activity implementiert wird, sollte das PendingIntent-Objekt mit der Methode PendingIntent.getActivity(Context c,int i,Intent intent,int j) abgerufen werden.
Wenn diese drei Methoden falsch verwendet werden, wird zwar kein Fehler gemeldet, aber der Effekt der Alarmbenachrichtigung wird nicht zu sehen sein.
Zusätzlich:
Ab Version 4.4 (API 19) kann die Auslösezeit von Alarm-Aufgaben ungenau werden und sich verzögern. Dies ist die Optimierung des Systems für den Stromverbrauch. Wenn Genauigkeit erforderlich ist, können Sie die Methode setExtra() aufrufen~
Kerncode:
public class LongRunningService extends Service {
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
//这里开辟一条线程,用来执行具体的逻辑操作:
new Thread(new Runnable() {
@Override
public void run() {
Log.d("BackService", new Date().toString());
}
}).start();
AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
//这里是定时的,这里设置的是每隔两秒打印一次时间=-=,自己改
int anHour = 2 * 1000;
long triggerAtTime = SystemClock.elapsedRealtime() + anHour;
Intent i = new Intent(this,AlarmReceiver.class);
PendingIntent pi = PendingIntent.getBroadcast(this, 0, i, 0);
manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pi);
return super.onStartCommand(intent, flags, startId);
}
}
AlarmReceiver.java
public class AlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
Intent i = new Intent(context,LongRunningService.class);
context.startService(i);
}
}
Zusammenfassung des Abschnitts:
In diesem Abschnitt vertiefen wir unsere Untersuchung von Service, IntentService und zwei häufigen Fällen von Service in der tatsächlichen Entwicklung: der Implementierung von Foreground-Service und der Implementierung von Background-Service! Im nächsten Abschnitt werden wir weiterhin AIDL von Service und prozessübergreifende Kommunikation untersuchen. Bleiben Sie dran~
Referenzen:"First Line of Code Android" — Guo Lin: Ein sehr gutes Einführungsbuch zu Android!