Android - usługi

ZA serviceto składnik działający w tle w celu wykonywania długotrwałych operacji bez konieczności interakcji z użytkownikiem, który działa nawet po zniszczeniu aplikacji. Usługa może zasadniczo przyjąć dwa stany -
Sr.No. Stan i opis
1

Started

Usługa jest startedgdy składnik aplikacji, taki jak działanie, uruchamia je, wywołując metodę startService () . Uruchomiona usługa może działać w tle przez czas nieokreślony, nawet jeśli składnik, który ją uruchomił, jest zniszczony.

2

Bound

Usługa jest boundgdy składnik aplikacji wiąże się z nim przez wywołanie metody bindService () . Powiązana usługa oferuje interfejs klient-serwer, który umożliwia komponentom interakcję z usługą, wysyłanie żądań, uzyskiwanie wyników, a nawet robienie tego między procesami z komunikacją międzyprocesową (IPC).

Usługa posiada metody wywołania zwrotnego cyklu życia, które można zaimplementować w celu monitorowania zmian stanu usługi i wykonywać prace na odpowiednim etapie. Poniższy diagram po lewej stronie przedstawia cykl życia, gdy usługa jest tworzona za pomocą startService (), a diagram po prawej pokazuje cykl życia, gdy usługa jest tworzona za pomocą bindService (): (dzięki uprzejmości: android.com)

Aby utworzyć usługę, należy utworzyć klasę Java, która rozszerza klasę bazową Service lub jedną z jej istniejących podklas. PlikServiceklasa bazowa definiuje różne metody wywołania zwrotnego, a najważniejsze z nich podano poniżej. Nie musisz implementować wszystkich metod wywołania zwrotnego. Jednak ważne jest, aby zrozumieć każdy z nich i wdrożyć te, które zapewnią, że Twoja aplikacja będzie działać zgodnie z oczekiwaniami użytkowników.

Sr.No. Oddzwonienie i opis
1

onStartCommand()

System wywołuje tę metodę, gdy inny składnik, taki jak działanie, żąda uruchomienia usługi, wywołując metodę startService () . Jeśli zaimplementujesz tę metodę, Twoim obowiązkiem jest zatrzymanie usługi po zakończeniu jej pracy przez wywołanie metod stopSelf () lub stopService () .

2

onBind()

System wywołuje tę metodę, gdy inny komponent chce powiązać się z usługą, wywołując bindService () . Jeśli zaimplementujesz tę metodę, musisz zapewnić interfejs, którego klienci używają do komunikacji z usługą, zwracając obiekt IBinder . Zawsze musisz implementować tę metodę, ale jeśli nie chcesz zezwalać na wiązanie, powinieneś zwrócić null .

3

onUnbind()

System wywołuje tę metodę, gdy wszyscy klienci rozłączyli się z określonym interfejsem opublikowanym przez usługę.

4

onRebind()

System wywołuje tę metodę, gdy nowi klienci połączyli się z usługą, po uprzednim powiadomieniu, że wszyscy rozłączyli się w jego onUnbind (Intent) .

5

onCreate()

System wywołuje tę metodę, gdy usługa jest tworzona po raz pierwszy za pomocą onStartCommand () lub onBind () . To wezwanie jest wymagane do wykonania jednorazowej konfiguracji.

6

onDestroy()

System wywołuje tę metodę, gdy usługa nie jest już używana i jest niszczona. Twoja usługa powinna to zaimplementować, aby wyczyścić wszelkie zasoby, takie jak wątki, zarejestrowane nasłuchiwania, odbiorniki itp.

Poniższa usługa szkieletowa demonstruje każdą z metod cyklu życia -

package com.tutorialspoint;

import android.app.Service;
import android.os.IBinder;
import android.content.Intent;
import android.os.Bundle;

public class HelloService extends Service {
   
   /** indicates how to behave if the service is killed */
   int mStartMode;
   
   /** interface for clients that bind */
   IBinder mBinder;     
   
   /** indicates whether onRebind should be used */
   boolean mAllowRebind;

   /** Called when the service is being created. */
   @Override
   public void onCreate() {
     
   }

   /** The service is starting, due to a call to startService() */
   @Override
   public int onStartCommand(Intent intent, int flags, int startId) {
      return mStartMode;
   }

   /** A client is binding to the service with bindService() */
   @Override
   public IBinder onBind(Intent intent) {
      return mBinder;
   }

   /** Called when all clients have unbound with unbindService() */
   @Override
   public boolean onUnbind(Intent intent) {
      return mAllowRebind;
   }

   /** Called when a client is binding to the service with bindService()*/
   @Override
   public void onRebind(Intent intent) {

   }

   /** Called when The service is no longer used and is being destroyed */
   @Override
   public void onDestroy() {

   }
}

Przykład

Ten przykład poprowadzi Cię przez proste kroki, aby pokazać, jak stworzyć własną usługę Android. Wykonaj następujące kroki, aby zmodyfikować aplikację na Androida, którą stworzyliśmy w rozdziale Hello World Example -

Krok Opis
1 Użyjesz Android StudioIDE do stworzenia aplikacji na Androida i nazwij ją jako Moja aplikacja w pakiecie com.example.tutorialspoint7.myapplication, jak wyjaśniono w rozdziale Hello World Example .
2 Zmodyfikuj główny plik aktywności MainActivity.java, aby dodać metody startService () i stopService () .
3 Utwórz nowy plik java MyService.java w pakiecie com.example.My Application . Ten plik będzie zawierał implementację metod związanych z usługą systemu Android.
4 Zdefiniuj swoją usługę w pliku AndroidManifest.xml za pomocą tagu <service ... />. Aplikacja może mieć jedną lub więcej usług bez żadnych ograniczeń.
5 Zmodyfikuj domyślną zawartość pliku res / layout / activity_main.xml , aby uwzględnić dwa przyciski w układzie liniowym.
6 Nie trzeba zmieniać żadnych stałych w pliku res / values ​​/ strings.xml . Android Studio dba o wartości ciągów
7 Uruchom aplikację, aby uruchomić emulator Androida i zweryfikować wynik zmian wprowadzonych w aplikacji.

Poniżej znajduje się zawartość zmodyfikowanego pliku głównego działania MainActivity.java. Ten plik może zawierać każdą z podstawowych metod cyklu życia. Dodaliśmy metody startService () i stopService () do uruchamiania i zatrzymywania usługi.

package com.example.tutorialspoint7.myapplication;

import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

import android.os.Bundle;
import android.app.Activity;
import android.util.Log;
import android.view.View;

public class MainActivity extends Activity {
   String msg = "Android : ";

   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);
      Log.d(msg, "The onCreate() event");
   }

   public void startService(View view) {
      startService(new Intent(getBaseContext(), MyService.class));
   }

   // Method to stop the service
   public void stopService(View view) {
      stopService(new Intent(getBaseContext(), MyService.class));
   }
}

Poniżej znajduje się treść MyService.java. Ten plik może zawierać implementację jednej lub więcej metod powiązanych z Usługą w oparciu o wymagania. Na razie zaimplementujemy tylko dwie metody onStartCommand () i onDestroy () -

package com.example.tutorialspoint7.myapplication;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.widget.Toast;

/**
   * Created by TutorialsPoint7 on 8/23/2016.
*/

public class MyService extends Service {
   @Nullable
   @Override
   public IBinder onBind(Intent intent) {
      return null;
   }
	
   @Override
   public int onStartCommand(Intent intent, int flags, int startId) {
      // Let it continue running until it is stopped.
      Toast.makeText(this, "Service Started", Toast.LENGTH_LONG).show();
      return START_STICKY;
   }

   @Override
   public void onDestroy() {
      super.onDestroy();
      Toast.makeText(this, "Service Destroyed", Toast.LENGTH_LONG).show();
   }
}

Poniżej znajduje się zmodyfikowana zawartość pliku AndroidManifest.xml . Tutaj dodaliśmy tag <service ... />, aby uwzględnić naszą usługę -

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
   package="com.example.tutorialspoint7.myapplication">

   <application
      android:allowBackup="true"
      android:icon="@mipmap/ic_launcher"
      android:label="@string/app_name"
      android:supportsRtl="true"
      android:theme="@style/AppTheme">
		
      <activity android:name=".MainActivity">
         <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
         </intent-filter>
      </activity>
		
      <service android:name=".MyService" />
   </application>

</manifest>

Poniżej będzie treść res/layout/activity_main.xml plik zawierający dwa przyciski -

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
   android:layout_height="match_parent" android:paddingLeft="@dimen/activity_horizontal_margin"
   android:paddingRight="@dimen/activity_horizontal_margin"
   android:paddingTop="@dimen/activity_vertical_margin"
   android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity">
   
   <TextView
      android:id="@+id/textView1"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="Example of services"
      android:layout_alignParentTop="true"
      android:layout_centerHorizontal="true"
      android:textSize="30dp" />
      
   <TextView
      android:id="@+id/textView2"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="Tutorials point "
      android:textColor="#ff87ff09"
      android:textSize="30dp"
      android:layout_above="@+id/imageButton"
      android:layout_centerHorizontal="true"
      android:layout_marginBottom="40dp" />

   <ImageButton
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:id="@+id/imageButton"
      android:src="@drawable/abc"
      android:layout_centerVertical="true"
      android:layout_centerHorizontal="true" />

   <Button
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:id="@+id/button2"
      android:text="Start Services"
      android:onClick="startService"
      android:layout_below="@+id/imageButton"
      android:layout_centerHorizontal="true" />

   <Button
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="Stop Services"
      android:id="@+id/button"
      android:onClick="stopService"
      android:layout_below="@+id/button2"
      android:layout_alignLeft="@+id/button2"
      android:layout_alignStart="@+id/button2"
      android:layout_alignRight="@+id/button2"
      android:layout_alignEnd="@+id/button2" />

</RelativeLayout>

Spróbujmy uruchomić zmodyfikowany plik Hello World!aplikacja, którą właśnie zmodyfikowaliśmy. Zakładam, że stworzyłeś swójAVDpodczas konfigurowania środowiska. Aby uruchomić aplikację ze studia Android, otwórz jeden z plików aktywności projektu i kliknij

ikonę Uruchom na pasku narzędzi. Android Studio instaluje aplikację na AVD i uruchamia ją, a jeśli wszystko jest w porządku z konfiguracją i aplikacją, wyświetli się następujące okno emulatora -

Teraz, aby rozpocząć usługę, kliknijmy Start Servicespowoduje to uruchomienie usługi i zgodnie z naszym programowaniem w metodzie onStartCommand () , na dole symulatora pojawi się komunikat Uruchomiono usługę w następujący sposób -

Aby zatrzymać usługę, możesz kliknąć przycisk Zatrzymaj usługę.