componente de servicio de los cuatro componentes de la Android

¿Qué es Servicio

Servicios (servicio) es una manera de llevar a cabo una operación de larga duración en el fondo sin una interfaz de usuario componentes de la aplicación. El servicio se inicia por parte de otros componentes de la aplicación (tales como la actividad), una vez iniciado el servicio será siempre ejecutarse en segundo plano, incluso si el componente para iniciar el servicio (Actividad) han sido destruidos no se verán afectados. Además, los componentes se pueden unir al servicio para interactuar con, e incluso realizar la comunicación entre procesos (IPC). Por ejemplo, el servicio puede procesar transacciones de red, reproducir música, un archivo de E / S o la interacción con los proveedores de contenido, todos los cuales pueden llevarse a cabo en el fondo realice, estado de servicio se divide básicamente en dos formas:

    estado de inicio

Cuando los componentes de aplicaciones (tales como la actividad) llamando StartService () para iniciar el servicio, el servicio que se encuentra en estado "on". Una vez activado, el servicio puede ejecutarse en segundo plano de forma indefinida, incluso si no se verá afectado el componente para iniciar el servicio han sido destruidos, a menos que llamar manualmente para detener el servicio, por lo general se inicia el servicio para realizar una sola operación, y no devolverá los resultados de la convocatoria fiesta.

    el estado de unión

Cuando un componente de aplicación está ligado al servicio llamando bindService (), el servicio que se encuentra en una "unión" de estado. enlace de servicio proporciona un cliente - Interfaz de servidor, permitiendo componentes interactúen con el servicio, enviar una solicitud para obtener los resultados, o incluso el uso de comunicación entre procesos (IPC) a través de los procesos para realizar estas operaciones. Sólo cuando se une a otros componentes de la aplicación, enlace de servicio se ejecutará. componentes múltiples pueden unirse simultáneamente al servicio, pero después de todo unbind, a saber, el servicio será destruido.

Comparación de la actividad y Servicio

similitudes

• Son componentes separados Android
• Tenemos un ciclo de vida independiente
• Contexto es una clase derivada, es posible llamar a la clase Contexto como getResources definidos () método, getContentResolver () y similares
• Tiene sus propios métodos de devolución de llamada de ciclo de vida

diferentes puntos

• Actividad carreras en el primer plano con una interfaz gráfica de usuario, es responsable de la interacción con el usuario, el servicio es generalmente se ejecuta en segundo plano, y no requiere la interacción del usuario o tener una interfaz gráfica de usuario.

Escenarios
Si un programa necesita para hacer que la interfaz del componente, o un programa para ejecutarse cuando el usuario necesita para interactuar con el usuario, es necesario el uso de actividades, de lo contrario se debe considerar el uso del Servicio.

Servicio para crear un servicio en segundo plano

Servicios en segundo plano se pueden dividir en los servicios no interactivos y servicios interactivos. La diferencia es la manera de empezar el servicio StartService()y bindService(). Este último devolverá Bindun objeto para Serviceun método y procesamiento de resultados, y el primero no voluntad

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

/**
定义一个类继承Service即可
*/
public class FirstService extends Service {
    /**
     * Service子类必须实现的方法。该方法返回一个IBinder对象，应用程序可通过IBinder对象与Service组件通信
     * @param intent
     * @return
     */
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        System.out.println("===================onBind FirstService=================");
        return null;
    }

    /**
     * 当Service上绑定的所有客户端都断开连接时会回调该方法
     * @param intent
     * @return
     */
    @Override
    public boolean onUnbind(Intent intent) {
        System.out.println("===================onUnbind FirstService=================");
        return super.onUnbind(intent);
    }

    /**
     * Service第一次被创建后回调该方法
     */
    @Override
    public void onCreate() {
        super.onCreate();
        System.out.println("===================onCreate FirstService=================");
    }

    /**
     * Service被关闭之前回调该方法
     */
    @Override
    public void onDestroy() {
        super.onDestroy();
        System.out.println("===================onDestroy FirstService=================");
    }

    /**
     * 该方法的早期版本是onStart(Intent intent, int startId),
     * 当客户端调用startService(Intent)方法启动Service时都会回调该方法
     * @param intent
     * @param flags
     * @param startId
     * @return
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        System.out.println("===================onStartCommand FirstService=================");
        return super.onStartCommand(intent, flags, startId);

    }
}

Los servicios anteriores registrados en Manifest.xml

<service android:name="com.javayihao.demo.TestService">
            <!-- 配置intent-filter元素说明该Service可被哪些Intent启动,可选 -->
            <intent-filter>
                <!-- 为intent-filter配置action -->
                <action android:name="com.javayihao.demo.TEST_SERVICE" />
            </intent-filter>
        </service>

Inicio y detención de Servicio 

el primer

() El método comienza por ninguna correlación entre StartService contexto de servicio, Servicio y visitantes, no puede comunicarse, intercambiar datos entre el servicio y los visitantes. Incluso si las salidas de los visitantes, el servicio es todavía en marcha:

Características: Cada vez que se creará Servicio de devolución de llamada método onCreate, cada vez que el método de devolución de llamada cuando se activa Servicio onStartCommand. Varias veces para iniciar un componente de servicio existente método de devolución de llamada ya no onCreate, pero cada vez que inicie la devolución de llamada se onStartCommand método.

        Intent intentService = new Intent(this, FirstService.class);
        intentService.setAction("com.javayihao.demo.TEST_SERVICE");
        //启动Service
        startService(intentService);
        //停止Service
        //stopService(intentService);

la segunda

servicio de prueba

public class TestService extends Service {
    //定义onBinder方法要返回的Binder对象
    private MyBinder binder = new MyBinder();
    // 通过继承Binder来实现IBinder类
    public class MyBinder extends Binder {
        public int getCount() {
            return 111;
        }
    }
    /**
     * service子类必须实现的方法。该方法返回一个IBinder对象，应用程序可通过IBinder对象与Service组件通信
     * @param intent
     * @return
     */
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        System.out.println("===================onBind TestService=================");
        return binder;//返回一个对象
    }
    /**
     * 当Service上绑定的所有客户端都断开连接时会回调该方法
     * @param intent
     * @return
     */
    @Override
    public boolean onUnbind(Intent intent) {
        System.out.println("===================onUnbind TestService=================");
        return super.onUnbind(intent);
    }

    /**
     * Service第一次被创建后回调该方法.用于初始化服务，只会被调用一次
     */
    @Override
    public void onCreate() {
        super.onCreate();
        System.out.println("===================onCreate TestService=================");
    }

    /**
     * Service被关闭之前回调该方法
     */
    @Override
    public void onDestroy() {
        super.onDestroy();
        System.out.println("===================onDestroy TestService=================");
    }

    /**
     * 该方法的早期版本是onStart(Intent intent, int startId),
     * 当客户端调用startService(Intent)方法启动Service时都会回调该方法
     * @param intent
     * @param flags
     * @param startId
     * @return
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        System.out.println("===================onStartCommand TestService=================");
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 耗时操作
            }
        }).start();
        return super.onStartCommand(intent, flags, startId);
    }
}

 

 comienzo

public class MainActivity extends AppCompatActivity {
    private  ServiceConnection connection;
    //启动Service时返回的IBinder对象
    TestService.MyBinder binder;
    //绑定服务
    public void  bindTestService(){
        Intent intent = new Intent(this, TestService.class);
        if(connection==null){
            ServiceConnection connection =new ServiceConnection() {
                //当与服务连接调用
                @Override
                public void onServiceConnected(ComponentName name, IBinder service) {
                    binder =  (TestService.MyBinder)service;
                    System.out.println("=============与TestService服务连接===========");
                }

                //当与服务断开调用
                @Override
                public void onServiceDisconnected(ComponentName name) {
                    System.out.println("============与TestService服务断开===============");
                }
            };
            //进行绑定
            bindService(intent,connection, Context.BIND_AUTO_CREATE);
        }else{
            System.out.println("============已经绑定");
        }
    }
    //解除绑定
    public void unbindTestService(){
        if(connection!=null){
            unbindService(connection);
            connection=null;
            System.out.println("============解除绑定==============");
        }else{
            System.out.println("============还没有绑定==============");
        }
    }
    //Activity
    @Override
    public void  onDestroy() {

        super.onDestroy();
        if(connection!=null) {
            unbindService(connection);//死亡之前调用
            connection = null;
        }
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        bindTestService();
       // unbindTestService();
    }

El objeto ServiceConnection método onServiceConnected tiene un objeto IBinder se puede lograr con una comunicación enlazado entre Servicio. En el desarrollo de la clase de servicio, la clase debe proporcionar un método (Intención intención) Servicio IBinder onBind, enlaces de servicio local en el caso de, IBinder objetos onBind método (Intención intención) devuelve un objeto que se pasará ServiceConnection en onServiceConnected (ComponentName nombrar los parámetros de servicio, método de servicio IBinder), puede comunicarse con el visitante a través del objeto servicio IBinder. En el desarrollo real a menudo usan heredada aglutinante (clase de implementación IBinder) IBinder manera de lograr su objetivo.

Para onBind de servicio () devuelve el objeto IBinder, puede ser entendido como el servicio objeto de devolución de llamada componente devuelto, Servicio permite al cliente acceder a los datos a través del interior del objeto de servicio IBinder se puede realizar para que el cliente la comunicación entre el Servicio.

proceso de implementación

ciclo de vida útil

Dos ejemplos de uso por encima de inicio, que tienen un enfoque de ciclo de vida de las observaciones del Servicio. Hemos encontrado que los diferentes modos de inicio del servicio de devolución de llamada enfoque de ciclo de vida también es diferente.

ciclo de vida útil

Para resumir el ciclo de vida del método de devolución de llamada de servicio:

la StartService () y bindService () son dos operaciones independientes, que no sólo se puede iniciar la unión, en tercer parámetro puede ser el método, cuando se une por bindService start (); también se puede iniciar después de la primera obligado;
① el inicio del ciclo de vida de los servicios: Si un servicio se denomina una forma de actividad Context.startService para empezar (servicio también puede iniciar el servicio), a continuación, independientemente de si la unión no uso o actividad bindService compromiso.Por unbindService el servicio, el servicio en ejecutándose en segundo plano. Si un servicio es StartService Método de arranque varias veces, entonces el método onCreate sólo se le llama una vez, pero cada vez onStartCommand será llamado de nuevo, y el sistema sólo creará una instancia de servicio (por lo que sólo tiene que llamar a uno stopService de parada). El servicio siempre se ejecutará en segundo plano, independientemente de la correspondiente actividad del programa se está ejecutando, hasta que fue llamado stopService, o su método stopSelf. Por supuesto, si hay suficientes recursos del sistema, el sistema Android también es probable que el servicio final.

② servicios de ciclo de vida ligados: Si un método de servicio Context.bindService se llama unión inicio de una actividad, no importa bindService llamar varias veces a la llamada, el método onCreate sólo se llama una vez, pero siempre onStartCommand método no se llama. Cuando se establece el enlace, el servicio siempre se ejecutará, a menos que llame Context.unbindService desconectado o antes no existe la bindService llamada del contexto (por ejemplo, cuando la actividad del acabado), el sistema se detendrá automáticamente servicio, OnDestroy correspondencia se llama.

③ se inicia de nuevo el ciclo de vida se unen de servicios: Si un servicio se inició por primera vez, y luego se une, el servicio se ejecuta en segundo plano. Y con independencia de la llamada, siempre onCreate única llama una vez, la llamada correspondiente StartService muchas veces, Servicio de onStartCommand llamará muchas veces. UnbindService llamadas no dejarán de servicio, y deben llamarse stopSelf stopService o servicio para detener el servicio (utilizando stopService bajo la premisa de ninguna desagregación no es fuera de servicio).

④ Cuando la limpieza cuando se detiene el servicio: cuando un servicio se termina (1, stopService llamada; 2, stopSelf llamada; 3, ya no está conectado a la unión (por bindService start)) cuando, método OnDestroy será llamado de nuevo, aquí se debe hacer algo de limpieza (por ejemplo, creación y ejecución de hilos de parada de servicio, los oyentes registrados, receptores, etc.).

Consideraciones al utilizar el Servicio

① al llamar bindService obligado al Servicio, usted debe asegurarse de que en algún lugar llamado unbindService unbind (aunque la actividad es acabado automáticamente cuando no unido y se detendrá automáticamente servicio);

Después ② StartService empezar a utilizar el servicio, asegúrese de usar stopService detener el servicio, independientemente de si utiliza bindService;

③ debe prestar atención a durante el uso de StartService y bindService: terminación de servicio, con necesidades llamadas unbindService StopService al mismo tiempo, con el fin de interrumpir el servicio. En llamar a la secuencia, si la primera llamada unbindService en este momento no termina automáticamente el servicio, entonces el servicio stopService llamada se detendrá; si el primer servicio de llamadas stopService en este momento no se dará por terminado, necesidad unbindService a la llamada (o llame bindService de contexto que no existe, La actividad fue como hora de finalización) el servicio se detendrá automáticamente.

④ Cuando la pantalla de teléfono de disco, si la actividad se lleva a cabo la reconstrucción, utilizando la conexión establecida la rotación anterior bindService será desconectado (no existe Contexto).

⑤ en las versiones anteriores a 2.0 SDK, método onStart utilizado fue reemplazado método onStartCommand, pero el método onStart sigue siendo válida.

 

recepción

Debido a las prioridades de los servicios de fondo es relativamente bajo, cuando el sistema de memoria, es probable que se reciclen a cabo, por lo que es la recepción para compensar esta deficiencia, se puede dejar funcionando sin sistema de recuperación. Por ejemplo: la tinta del tiempo Tiempo en la barra de estado

 

recepción

 

IntentService

El código de servicio por defecto se ejecuta en el hilo principal. Si desea ejecutar el código dentro de las operaciones que consumen mucho tiempo en el servicio, es necesario abrir un hilo conductor para manejar estos códigos. Por ejemplo, en el ejemplo de inicio y parada del Servicio, Servicio IntentService está diseñado para resolver mucho tiempo la operación no se puede realizar en este problema, cree un IntentService es también muy simple, siempre y cuando la herencia y anular la función onHandlerIntent IntentService, la función puede ser una operación que consume tiempo.

IntentService siguiendo los pasos
1, heredada IntentService crear una clase personalizada IntentService

import android.app.IntentService;
import android.content.Intent;


public class BindIntentService extends IntentService {
    private boolean quit = false;
    private int count = 0;

    public BindIntentService() {
        super("BindIntentService");
    }

    /**
     * 必须实现的抽象方法，我们的业务逻辑就是在这个方法里面去实现的
     * 方法在子线程运行，我们不用去关心ANR的问题
     * 在OnCreate方法里面创建并启动子线程，
     * 在OnStartCommand方法里面，将Intent封装成Message并传递到子线程的handler，然后回调onHandleIntentonStart
     *
     * @param intent
     */
    @Override
    protected void onHandleIntent(Intent intent) {
        while (!quit) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count++;
            System.out.println("==================Current count：" + count + "====================");
            if (count == 10)
                quit = true;
        }
    }

    /**
     * 为了验证onHandleIntent执行后，服务会不会自动销毁，我们在这里重写onDestroy方法
     * 如果会自动销毁，那么在"IntetnService Running"出现后，应该会出现"IntetnService Stop"
     */
    @Override
    public void onDestroy() {
        System.out.println("==================BindIntentService onDestroy：" + count + "====================");
        //经测试，如果onHandleIntent里面的代码逻辑没有走完，在服务外部调用stopService来停止服务，并不会立即结束子线程
        quit = true;
        super.onDestroy();
    }
}

2, en el que el registro Manifiesto IntentService, registrado la misma manera que con el Servicio

3, iniciar IntentService
recomendamos manera StartService (intención) para iniciar el servicio.

Nota! También puede utilizar manera bindService para iniciar el servicio. Sin embargo, al usar comienzo bindService, incluso si se ha completado la lógica dentro de la ejecución onHandleIntent, el servicio no se destruye automáticamente. La razón debe ser el servicio o el estado vinculados, llamando stopSelf no ser detenido. Así que si bindService empezar a utilizar el servicio perderá IntentService una característica importante, por favor, tenga cuidado.

4, destruir IntentService
IntentService una característica importante de los cuales es, después de la lógica del código onHandleIntent ejecutado, la destrucción automática de servicio. Así que no podemos dejar de IntentService se especializan en la operación.

Nota! También puede llamar a servicio al cliente stopService manual para destruir, pero de esta manera no se IntentService hilo parada niño dentro comenzado. Si desea destruir este servicio de forma, se debe prestar atención a la rosca niño no puede ser detenido, lo que lleva a la pérdida de memoria.

Servicios del sistema

Servicios del sistema proporciona muchos servicios convenientes, puede consultar Wifi, estado de la red, consulta la batería, el volumen de consultas, consulta el nombre del paquete, consulta y otra información relacionada, etc. Uso y más servicios, podemos confiadamente consulta documentos específicos, por ejemplo, dos servicios comunes aquí .

Wifi

WifiManager wm = (WifiManager) getSystemService(WIFI_SERVICE);
boolean enabled = wm.isWifiEnabled();

volumen máximo

AudioManager am = (AudioManager) getSystemService(AUDIO_SERVICE);
int max = am.getStreamMaxVolume(AudioManager.STREAM_SYSTEM);

conexión de referencia:

https://blog.csdn.net/javazejian/article/details/52709857

https://www.jianshu.com/p/d48b386225fc

https://www.jianshu.com/p/d4d147fd8549

https://blog.csdn.net/geyunfei_/article/details/78851024