Android - Servizi
UN serviceè un componente che viene eseguito in background per eseguire operazioni di lunga durata senza dover interagire con l'utente e funziona anche se l'applicazione viene distrutta. Un servizio può essenzialmente assumere due stati:
| Sr.No. | Stato e descrizione |
|---|---|
| 1 | Started Un servizio è startedquando un componente dell'applicazione, come un'attività, lo avvia chiamando startService () . Una volta avviato, un servizio può essere eseguito in background indefinitamente, anche se il componente che lo ha avviato viene distrutto. |
| 2 | Bound Un servizio è boundquando un componente dell'applicazione si collega ad esso chiamando bindService () . Un servizio associato offre un'interfaccia client-server che consente ai componenti di interagire con il servizio, inviare richieste, ottenere risultati e persino farlo attraverso processi con comunicazione interprocesso (IPC). |
Un servizio dispone di metodi di callback del ciclo di vita che è possibile implementare per monitorare i cambiamenti nello stato del servizio ed è possibile eseguire il lavoro nella fase appropriata. Il diagramma seguente a sinistra mostra il ciclo di vita quando il servizio viene creato con startService () e il diagramma a destra mostra il ciclo di vita quando il servizio viene creato con bindService (): (image courtesy: android.com)
Per creare un servizio, creare una classe Java che estende la classe base del servizio o una delle sue sottoclassi esistenti. IlServicela classe base definisce vari metodi di callback e i più importanti sono riportati di seguito. Non è necessario implementare tutti i metodi di callback. Tuttavia, è importante comprenderli tutti e implementare quelli che garantiscono che la tua app si comporti come gli utenti si aspettano.
| Sr.No. | Richiamata e descrizione |
|---|---|
| 1 | onStartCommand() Il sistema chiama questo metodo quando un altro componente, come un'attività, richiede l'avvio del servizio, chiamando startService () . Se implementate questo metodo, è vostra responsabilità arrestare il servizio quando il suo lavoro è terminato , chiamando i metodi stopSelf () o stopService () . |
| 2 | onBind() Il sistema chiama questo metodo quando un altro componente desidera collegarsi al servizio chiamando bindService () . Se si implementa questo metodo, è necessario fornire un'interfaccia utilizzata dai client per comunicare con il servizio, restituendo un oggetto IBinder . È necessario implementare sempre questo metodo, ma se non si desidera consentire l'associazione, è necessario restituire null . |
| 3 | onUnbind() Il sistema chiama questo metodo quando tutti i client si sono scollegati da una particolare interfaccia pubblicata dal servizio. |
| 4 | onRebind() Il sistema chiama questo metodo quando nuovi client si sono connessi al servizio, dopo che gli era stato precedentemente notificato che tutti si erano disconnessi nel suo onUnbind (Intent) . |
| 5 | onCreate() Il sistema chiama questo metodo quando il servizio viene creato per la prima volta utilizzando onStartCommand () o onBind () . Questa chiamata è necessaria per eseguire una configurazione una tantum. |
| 6 | onDestroy() Il sistema chiama questo metodo quando il servizio non è più utilizzato e viene distrutto. Il tuo servizio dovrebbe implementarlo per ripulire qualsiasi risorsa come thread, listener registrati, ricevitori, ecc. |
Il seguente servizio di scheletro dimostra ciascuno dei metodi del ciclo di vita:
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() {
}
}Esempio
Questo esempio ti guiderà attraverso semplici passaggi per mostrare come creare il tuo servizio Android. Segui i seguenti passaggi per modificare l'applicazione Android che abbiamo creato nel capitolo Hello World Example -
| Passo | Descrizione |
|---|---|
| 1 | Utilizzerai Android StudioIDE per creare un'applicazione Android e chiamarla My Application in un pacchetto com.example.tutorialspoint7.myapplication come spiegato nel capitolo Hello World Example . |
| 2 | Modificare il file di attività principale MainActivity.java per aggiungere i metodi startService () e stopService () . |
| 3 | Crea un nuovo file java MyService.java nel pacchetto com.example.My Application . Questo file avrà l'implementazione dei metodi relativi al servizio Android. |
| 4 | Definisci il tuo servizio nel file AndroidManifest.xml utilizzando il tag <service ... />. Un'applicazione può avere uno o più servizi senza alcuna restrizione. |
| 5 | Modifica il contenuto predefinito del file res / layout / activity_main.xml per includere due pulsanti nel layout lineare. |
| 6 | Non è necessario modificare le costanti nel file res / values / strings.xml . Android Studio si prende cura dei valori delle stringhe |
| 7 | Esegui l'applicazione per avviare l'emulatore Android e verifica il risultato delle modifiche apportate nell'applicazione. |
Di seguito è riportato il contenuto del file di attività principale modificato MainActivity.java. Questo file può includere ciascuno dei metodi fondamentali del ciclo di vita. Abbiamo aggiunto i metodi startService () e stopService () per avviare e arrestare il servizio.
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));
}
}Di seguito è riportato il contenuto di MyService.java. Questo file può avere l'implementazione di uno o più metodi associati al servizio in base ai requisiti. Per ora implementeremo solo due metodi onStartCommand () e 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();
}
}Di seguito verrà visualizzato il contenuto modificato del file AndroidManifest.xml . Qui abbiamo aggiunto il tag <service ... /> per includere il nostro servizio -
<?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>Di seguito sarà il contenuto di res/layout/activity_main.xml file per includere due pulsanti -
<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>Proviamo a eseguire il nostro file modificato Hello World!applicazione che abbiamo appena modificato. Presumo che tu abbia creato il tuoAVDdurante l'impostazione dell'ambiente. Per eseguire l'app da Android Studio, apri uno dei file di attività del tuo progetto e fai clic 
sull'icona Esegui dalla barra degli strumenti. Android Studio installa l'app sul tuo AVD e la avvia e se tutto va bene con la configurazione e l'applicazione, verrà visualizzata la seguente finestra dell'emulatore:
Ora per avviare il servizio, facciamo clic su Start Servicepulsante, questo avvierà il servizio e come da nostra programmazione nel metodo onStartCommand () , un messaggio Service Started apparirà nella parte inferiore del simulatore come segue:
Per interrompere il servizio, puoi fare clic sul pulsante Interrompi servizio.