Android学习——四大核心组件（Service）

四大核心组件之Service

1.Service的基本概念

Service是android系统中的四大组件之一(Activity、 Service.、BroadcastReceiver,、ContentProvider) ，它跟Activity的级别差不多，但不能自己运行只能后台运行，并且可以和其他组件进行交互。service可以在很多场合的应用中使用，比如播放多媒体的时候用户启动了其他Activity这个时候程序要在后台继续播放，比如检测SD卡上文件的变化，再或者在后台记录你地理信息位置的改变等等，总之服务总是藏在后台的。

两种启动方式

1.startService
2.bindService（绑定服务）

生命周期

2.startService

新建一个Service

package com.example.myapplication6;

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

public class MyService extends Service {
    public MyService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }

    //服务被创建
    @Override
    public void onCreate() {
        super.onCreate();
        System.out.println("my service create.");
    }

    //在该方法中实现服务的核心业务
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        for (int i=0;i<5;i++){
            System.out.println("onStartCommand"+i);
            //设置自动终止服务
            //if (i==3){
            //    this.stopSelf();//终止服务
            //}
        }
        return super.onStartCommand(intent, flags, startId);
    }

    //销毁服务
    @Override
    public void onDestroy() {
        super.onDestroy();
        System.out.println("my service destroy");
    }
}

在清单文件中注册

<service
    android:name=".MyService"
    android:enabled="true"
    android:exported="true">
</service>

在Activity中启动和停止服务
分别布局一个启动按钮和一个停止按钮，设置单击事件

<Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="启动一个服务"
        android:id="@+id/button_start"
        android:onClick="startClick"
        android:layout_alignParentTop="true"
        android:layout_alignParentStart="true"
        android:layout_alignParentLeft="true"/>

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="停止一个服务"
        android:id="@+id/button_stop"
        android:onClick="stopClick"
        android:layout_below="@id/button_start"/>

Main中添加单击事件

package com.example.myapplication6;

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

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    //启动一个服务
    public void startClick(View v){
        Intent intent=new Intent(this,MyService.class);
        startService(intent);
    }
    //停止一个服务
    public void stopClick(View v){
        Intent intent=new Intent(this,MyService.class);
        stopService(intent);
    }
}

点击启动服务，在log中打印的数据

当我们Activity退出，这个服务仍在后台进行中，而为停止（设置-应用中查看）

点击停止服务

后台便不会再有这个Service

默认情况下服务与主线程在同一个进程中的同一个线程执行，如果服务执行一个比较耗时的操作，我们必须使用子线程来完成工作避免阻塞主线程

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    //使用线程完成长时间的工作
    new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i=0;i<20;i++){
                System.out.println("onStartCommand"+i+"-"+Thread.currentThread().getName());
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (i==15){
                    MyService.this.stopSelf();//终止服务
                    break;
                }
            }
        }
    }).start();
    return super.onStartCommand(intent, flags, startId);
}

如何实现一个Service
onStartCommand使用时，返回的是一个(int)整型。这个整型可以有四个返回值：start_sticky、start_no_sticky、START_REDELIVER_INSERT、START_STICKY_COMPATIBILITY。

• START_ STICKY
  ：如果service进程被kill掉，保留service的状态为开始状态，但不保留递送的intent对象。随后系统会尝试重新创建service，由于服务状态为开始状态，所以创建服务后一定会调用onStartCommand(intent,int,int)方法。如果在此期间没有任何启动命令被传递到service，那么参数Intent将为null。
• START_ NOT, STICKY ：“非粘性的”。使用这个返回值时,如果在执行完onStartCommand后，服务被异常kill掉，系统不会自动重启该服务。
• START_ REDELIVER INTENT ：重传Intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务，并将Intent的值传入。
• START_ STICKY_ COMPATIBILITY ：
  START_STICKY的兼容版本，但不保证服务被kill后一定能重启。

StartService小结：
1.服务同时只会被创建一次，可以通过外部调用stopService或调用stopSelf来终止服务。
2.当执行一个已启动的服务，会直接调用onStartCommand方法执行业务。
3.默认情况下服务与主线程在同一个进程中的同一个线程执行，如果服务执行一个比较耗时的操作，我们必须使用子线程来完成工作避免阻塞主线程。
4.使用started service启动的一个服务，在没有关闭之前会一直在后台运行。

3.bindService

虚用程序组件(客户端)通过使用bindServicel方法能移绑定服务，然后Android系统会调用服务的onBind()回调方法，这个方法会返回一个跟服务端交互的lBinder对象。这个绑定是异歩的，bindServicel方法立即返回，并且不蛤客戸端返回lBinder対象。要接收IBinder对象， 客户端必须创建个ServiceConnection类的实例，并且把这个实例传递给bindService方法。ServiceConnection对象包含了一个系统调用的传递IBinder対象的回调方法。

注意:只有Activity、Service、和内容提供器（content provider）能够绑定服务…对于广播接收器不能绑定服务。
创建一个service类MyBoundService

package com.example.myapplication6;

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

public class MyBoundService extends Service {
    public MyBoundService() {
    }

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return new AidlImpl();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        return super.onUnbind(intent);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }
}

创建一个AIDL文件（Android Interface Definition Language）提供给客户端需要绑定业务的方法。

// IMyAidlInterface.aidl
package com.example.myapplication6;

// Declare any non-default types here with import statements

interface IMyAidlInterface {

    //提供给客户端需要绑定业务的方法
    void setName(String name);//自定义方法

    String desc();//输出一个字符串，描述desc

    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

创建完后，系统会自动生成一个类

创建一个业务实现类AidlImpl

package com.example.myapplication6;

import android.os.RemoteException;
/*
* 业务接口的具体实现类
*
* */
public class AidlImpl extends IMyAidlInterface.Stub {
    private String name;
    @Override
    public void setName(String name) throws RemoteException {
        this.name=name;
    }

    @Override
    public String desc() throws RemoteException {
        return "hello my name is"+name+"，呜啦啦啦啦。";
    }

    @Override
    public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

    }

}

MainActivity（客户端）

package com.example.myapplication6;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {

    private IMyAidlInterface iMyAidlInterface;//定义通用接口
    private boolean mBound=false;//标记 是否绑定

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    //绑定服务的连接回调接口
    private ServiceConnection conn=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //绑定成功后回调的方法
            iMyAidlInterface=IMyAidlInterface.Stub.asInterface(service);
            mBound=true;
            Toast.makeText(MainActivity.this, "绑定成功", Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            //服务异常时调用
            mBound=false;
        }
    };

    public void callClick(View v){
        if (iMyAidlInterface==null){
            return;
        }
        try{
            iMyAidlInterface.setName("王大头");
            Toast.makeText(this, iMyAidlInterface.desc(), Toast.LENGTH_SHORT).show();
        } catch (RemoteException e){
            e.printStackTrace();
        }
    }
    //绑定一个服务
    public void boundClick(View v){
        Intent intent=new Intent(this,MyBoundService.class);
        //异步绑定，绑定成功后回调onServiceConnected
        bindService(intent,conn, Context.BIND_AUTO_CREATE);
    }
    //解除绑定服务
    public void unBoundClick(View v){
        if (mBound){
            unbindService(conn);
            Toast.makeText(this, "解除绑定成功", Toast.LENGTH_SHORT).show();
        }
    }
}

将service设置成远程的进程服务
将service设置成远程的进程

自定义类型使用方法
创建一个自定义类并使用implements Parcelable接口

package com.example.myapplication6;

import android.os.Parcel;
import android.os.Parcelable;

public class Persons implements Parcelable {
    String name;
    String work;

    @Override
    public String toString() {
        return "Person("+"name='"+name+"\'"+",work='"+work+"\'"+")";
    }

    public static final Creator<Persons> CREATOR = new Creator<Persons>() {
        @Override
        public Persons createFromParcel(Parcel in) {
            Persons p=new Persons();
            p.name=in.readString();
            p.work=in.readString();
            return p;
        }

        @Override
        public Persons[] newArray(int size) {
            return new Persons[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeString(work);
    }
}

创建一个AIDL类用parcelable关键字定义

// Persons.aidl
package com.example.myapplication6;

parcelable Persons;

然后进行导包，导入其他的AIDL文件中

// IMyAidlInterface.aidl
package com.example.myapplication6;

import com.example.myapplication6.Persons;
// Declare any non-default types here with import statements

interface IMyAidlInterface {

    Persons getPersons();

    //提供给客户端需要绑定业务的方法
    void setName(String name);

    String desc();

    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

并在其业务实现类中写入方法

package com.example.myapplication6;

import android.app.Person;
import android.os.RemoteException;
/*
* 业务接口的具体实现类
* */
public class AidlImpl extends IMyAidlInterface.Stub {
    private String name;

    @Override
    public Persons getPersons() throws RemoteException {
        Persons p=new Persons();
        p.name="王尼玛";
        p.work="主持人";
        return p;
    }

    @Override
    public void setName(String name) throws RemoteException {
        this.name=name;
    }

    @Override
    public String desc() throws RemoteException {
        return "hello here is"+name+"，呜啦啦啦啦。";
    }

    @Override
    public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

    }

}

bindService（绑定服务）小结：
通过绑定服务来实现功能的步骤
1.客户端通过通过bindService方法来绑定一个服务对象，如果绑定成功，会回调ServiceConnection接口方法onServiceConnected
2.通过Service组件来暴露业务接口
3.服务端通过创建*.aidl文件来定义一个可以被客户端调用的业务接口
一个aidl文件
（1）不能有修饰符，类似接口的写法
（2）支持类型有：8种基本数据类型,String,CharSequence,List,Map，自定义类型
（3）自定义类型：1.实现Parcelable接口；2.定义一个aidl文件声明该类型；parcelable Persons;3.在其他aidl文件中使用，必须要使用import（导包）
4.服务端需要提供一个业务接口的实现类，通过我么会extens Stub类
5.通过Service的onBind方法返回被绑定的业务对象
6.客户端如果绑定成功，就可以像调用自己的方法一样调用远程的业务对象方法

使用技巧（先started，后bind）

started启动的服务，只要不停止，便会长期存在
bind启动的服务通常会在解绑时停止

4.IntentService

IntentService是继承于Service#处理异步请求的一个类，在IntentService内有一个工作线程来处理耗时操作， 启动 IntentService的方式和启动传统Service一样，同时，当任务执行完后，IntentService会自动停止，而不需要我们去手动控制。另外，可以启动IntentService多次，而每一个耗时操作会以工作队列的方式在IntentService的onHandlelntent回调方法中执行，并且，每次只会执行一个工作线程，执行完第一个再执行第二个，以此类推。

package com.example.myapplication6;

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

public class MyIntentService extends IntentService {

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

    @Override
    protected void onHandleIntent(Intent intent) {
        System.out.println(intent.getStringExtra("info"));
        for (int i=0;i<20;i++){
            System.out.println("onHandleIntent"+i+"-"+Thread.currentThread().getName());
        }
    }

}

IntentService小结：
1.内部有一个工作线程来完成耗时的操作，只需实现onHandleIntent方法即可
2.完成工作后会自动终止服务
3.如果同时执行多个任务时，会以工作队列的方式，一次执行
4.通过该类来完成本APP中耗时的工作