Android - Serviços

UMA serviceé um componente executado em segundo plano para realizar operações de longa duração sem a necessidade de interagir com o usuário e funciona mesmo se o aplicativo for destruído. Um serviço pode ter essencialmente dois estados -

Sr. Não.	Estado e descrição
1	Started Um serviço é startedquando um componente do aplicativo, como uma atividade, o inicia chamando startService () . Depois de iniciado, um serviço pode ser executado em segundo plano indefinidamente, mesmo se o componente que o iniciou for destruído.
2	Bound Um serviço é boundquando um componente de aplicativo se liga a ele chamando bindService () . Um serviço vinculado oferece uma interface cliente-servidor que permite que os componentes interajam com o serviço, enviem solicitações, obtenham resultados e até mesmo façam isso em processos com comunicação entre processos (IPC).

Um serviço tem métodos de retorno de chamada do ciclo de vida que você pode implementar para monitorar as mudanças no estado do serviço e pode executar o trabalho no estágio apropriado. O diagrama a seguir à esquerda mostra o ciclo de vida quando o serviço é criado com startService () e o diagrama à direita mostra o ciclo de vida quando o serviço é criado com bindService (): (cortesia de imagem: android.com)

Para criar um serviço, você cria uma classe Java que estende a classe base Service ou uma de suas subclasses existentes. oServiceA classe base define vários métodos de retorno de chamada e os mais importantes são fornecidos a seguir. Você não precisa implementar todos os métodos de retorno de chamada. No entanto, é importante que você entenda cada um e implemente aqueles que garantem que seu aplicativo se comporte da maneira que os usuários esperam.

Sr. Não.	Retorno de chamada e descrição
1	onStartCommand() O sistema chama esse método quando outro componente, como uma atividade, solicita que o serviço seja iniciado, chamando startService () . Se você implementar esse método, é sua responsabilidade interromper o serviço quando seu trabalho for concluído, chamando os métodos stopSelf () ou stopService () .
2	onBind() O sistema chama esse método quando outro componente deseja se vincular ao serviço chamando bindService () . Se você implementar este método, deverá fornecer uma interface que os clientes usam para se comunicar com o serviço, retornando um objeto IBinder . Você deve sempre implementar esse método, mas se não quiser permitir a vinculação, deverá retornar nulo .
3	onUnbind() O sistema chama esse método quando todos os clientes se desconectam de uma interface específica publicada pelo serviço.
4	onRebind() O sistema chama este método quando novos clientes se conectam ao serviço, após terem sido previamente notificados que todos haviam se desconectado em seu onUnbind (Intent) .
5	onCreate() O sistema chama esse método quando o serviço é criado pela primeira vez usando onStartCommand () ou onBind () . Esta chamada é necessária para realizar uma configuração única.
6	onDestroy() O sistema chama esse método quando o serviço não é mais usado e está sendo destruído. Seu serviço deve implementar isso para limpar quaisquer recursos, como threads, ouvintes registrados, receptores, etc.

O seguinte esqueleto de serviço demonstra cada um dos métodos de ciclo de vida -

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() {

   }
}

Exemplo

Este exemplo o levará por etapas simples para mostrar como criar seu próprio serviço Android. Siga as etapas a seguir para modificar o aplicativo Android que criamos no capítulo de exemplo Hello World -

Degrau	Descrição
1	Você usará o Android StudioIDE para criar um aplicativo Android e nomeá-lo como My Application em um pacote com.example.tutorialspoint7.myapplication, conforme explicado no capítulo Exemplo Hello World .
2	Modifique o arquivo de atividade principal MainActivity.java para adicionar os métodos startService () e stopService () .
3	Crie um novo arquivo java MyService.java sob o pacote com.example.My Application . Este arquivo terá implementação de métodos relacionados ao serviço Android.
4	Defina seu serviço no arquivo AndroidManifest.xml usando a tag <service ... />. Um aplicativo pode ter um ou mais serviços sem quaisquer restrições.
5	Modifique o conteúdo padrão do arquivo res / layout / activity_main.xml para incluir dois botões no layout linear.
6	Não há necessidade de alterar nenhuma constante no arquivo res / values ​​/ strings.xml . Android Studio cuida dos valores das strings
7	Execute o aplicativo para iniciar o emulador Android e verifique o resultado das alterações feitas no aplicativo.

A seguir está o conteúdo do arquivo de atividade principal modificado MainActivity.java. Este arquivo pode incluir cada um dos métodos fundamentais do ciclo de vida. Adicionamos os métodos startService () e stopService () para iniciar e parar o serviço.

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));
   }
}

A seguir está o conteúdo de MyService.java. Este arquivo pode ter implementação de um ou mais métodos associados ao Serviço com base em requisitos. Por enquanto, vamos implementar apenas dois métodos 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();
   }
}

A seguir, o conteúdo modificado do arquivo AndroidManifest.xml . Aqui, adicionamos a tag <service ... /> para incluir nosso serviço -

<?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>

A seguir estará o conteúdo de res/layout/activity_main.xml arquivo para incluir dois botões -

<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>

Vamos tentar executar nosso modificado Hello World!aplicativo que acabamos de modificar. Suponho que você tenha criado o seuAVDao fazer a configuração do ambiente. Para executar o aplicativo do Android Studio, abra um dos arquivos de atividade do seu projeto e clique no ícone Executar na barra de ferramentas. O Android Studio instala o aplicativo em seu AVD e o inicia e, se tudo correr bem com sua configuração e aplicativo, ele será exibido na janela do emulador seguinte -

Agora, para iniciar seu serviço, vamos clicar em Start Service, isso iniciará o serviço e de acordo com nossa programação no método onStartCommand () , uma mensagem Service Started aparecerá na parte inferior do simulador como segue -

Para interromper o serviço, você pode clicar no botão Interromper serviço.