Android四大组件（二）：Service

Service也是一个单独的Android组件。通常用于为其他组件提供后台服务或者监控其他组件的运行状态。

Activity与Service的对比

相似点

都是单独的Android组件
都拥有独立的生命周期
都是Context的派生类，所以可以调用Context类定义的如getResources()、getContentResolver()等方法
都拥有自己生命周期回调方法

不同点

Activity运行于前台有图形用户界面，负责与用户交互；Service通常位于后台运行，不需要与用户交互，也没有图形用户界面。

应用场景
如果某个程序组件需要在运行时向用户呈现界面，或者程序需要与用户交互，就需要用Activity，否则就应该考虑使用Service了。

创建Service

定义一个继承Service的子类；

package com.rave.simpledemo.service;

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

/**
 * Created by Administrator on 2019/1/21.
 */
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);

    }
}

在Manifest.xml文件中配置该Service。

启动和停止Service

启动Service
① 通过Context的startService()方法启动Service，访问者与Service之间没有关联，Service和访问者之间也无法进行通信、数据交换。即使访问者退出，Service依然运行：

        Intent intentService = new Intent(this, FirstService.class);
        intentService.setAction("com.rave.simpledemo.service.FIRST_SERVICE");
        //启动Service
        startService(intentService);
        //停止Service
        //stopService(intentService);

特点：每当Service被创建时会回调onCreate方法，每次Service被启动时都会回调onStartCommand方法。多次启动一个已有的Service组件将不会再回调onCreate方法，但每次启动时都会回调onStartCommand方法。

② 通过Context的bindService()方法启动Service，访问者与Service绑定在一起。访问者与Service之间可以进行方法调用或数据交换。访问者一旦退出，Service也就终止：

boolean bindService(Intent service, ServiceConnection conn,int flags);
unbindService(ServiceConnection conn)

①service：该参数通过Intent指定要启动的Service；
②conn：该参数是一个ServiceConnection对象，该对象用于监听访问者与Service之间的连接情况。当访问者与Service之间连接成功时将回调ServiceConnection对象的onServiceConnected(ComponentName name，IBinder service)方法；当访问者与Service之间断开连接时将回调ServiceConnection对象的onServiceDisconnected(ComponentName name)方法；
③flags：指定绑定时是否自动创建Service（如果Service还未创建）。该参数可指定为0（不自动创建）或BIND_AUTO_CREATE（自动创建）。

如何与被绑定的Service进行本地通信（远程的、跨进程的通信会采用AIDL，下文会单独介绍）

ServiceConnection对象的onServiceConnected方法中有一个IBinder对象，该对象可实现与被绑定Service之间的通信。在开发Service类时，该Service类必须提供一个IBinder onBind(Intent intent)方法，在绑定本地Service的情况下，onBind(Intent intent)方法所返回的IBinder对象将会传给ServiceConnection对象里onServiceConnected(ComponentName name, IBinder service)方法的service参数，访问者就可通过该IBinder对象与Service进行通信。在实际开发中通常会采用继承Binder（IBinder的实现类）的方式实现自己的IBinder对象。

具体步骤：
①在Service里面创建一个IBinder对象（通过继承Binder类来实现自定义的Binder）；
②在onBind(Intent intent)方法里面返回这个Binder对象；
③客户端在绑定Service时所需的ServiceConnection对象的onServiceConnected方法里面获取到onBind方法返回的Binder对象；
④客户端通过持有的Binder对象来访问Service。

通过Binder通信

对于Service的onBind()方法所返回的IBinder对象来说，它可被当成该Service组件所返回的回调对象，Service允许客户端通过该IBinder对象来访问Service内部的数据，这样即可实现客户端与Service之间的通信。

package com.rave.simpledemo.service;

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

/**
 * Created by Administrator on 2019/1/22.
 */
public class BindService extends Service {
    private boolean quit = false;
    private int count = 0;
    //定义onBinder方法要返回的Binder对象
    private MyBinder binder = new MyBinder();
    // 通过继承Binder来实现IBinder类
    public class MyBinder extends Binder {

        public int getCount() {
            return count;
        }
    }
    
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        System.out.println("==================BindService onBind====================");
        return binder;
    }

    @Override
    public boolean onUnbind(Intent intent) {
        System.out.println("==================BindService onUnbind====================");
        return true;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        System.out.println("==================BindService onCreate====================");
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (!quit) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count++;
                }
                stopSelf();
            }
        }).start();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        this.quit = true;
        System.out.println("==================BindService onDestroy====================");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        System.out.println("===================BindService onStartCommand=================");
        return super.onStartCommand(intent, flags, startId);

    }
}

package com.rave.simpledemo.service;

import android.app.Service;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import com.rave.simpledemo.R;

public class BindServiceActivity extends AppCompatActivity {

    private Button btnStartService;
    private Button btnStopService;
    private Button btnGetStatus;

    //启动Service时返回的IBinder对象
    BindService.MyBinder binder;
    //定义一个ServiceConnection对象
    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            System.out.println("===================BindService onServiceConnected=================");
            binder = (BindService.MyBinder) service;
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            System.out.println("===================BindService onServiceDisconnected=================");
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_bind_service);
        btnStartService = (Button) findViewById(R.id.btn_startservice);
        btnStopService = (Button) findViewById(R.id.btn_stopservice);
        btnGetStatus = (Button) findViewById(R.id.btn_getstatus);

        final Intent intent = new Intent(BindServiceActivity.this, BindService.class);
        intent.setAction("com.rave.simpledemo.service.BIND_SERVICE");

        btnStartService.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //绑定指定的Service
                bindService(intent, conn, Service.BIND_AUTO_CREATE);
            }
        });

        btnStopService.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //解除绑定Service(这里的参数ServiceConnection对象)
                unbindService(conn);
            }
        });

        btnGetStatus.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                int count = binder.getCount();
                Toast.makeText(BindServiceActivity.this, count + "", Toast.LENGTH_LONG).show();
            }
        });
    }

}

Service的生命周期

上文的启动Service的两个示例中，我们都有对Service的生命周期方法进行观测。我们发现根据启动方式的不同Service回调的生命周期方法也不同。

Service的生命周期

总结一下Service的生命周期方法回调：

startService()和bindService()是两个独立的操作，我们可以只启动不绑定；也可以通过bindService()方法的第三个参数，在绑定时启动；还可以先启动后绑定；
①被启动的服务的生命周期：如果一个Service被某个Activity调用Context.startService方法启动(Service也可以启动服务)，那么不管是否有Activity使用bindService绑定或者unbindService解除绑定该Service，该Service都在后台运行。如果一个Service被startService方法多次启动，那么onCreate方法只会调用一次，但是onStartCommand将会每次都被回调，并且系统只会创建Service的一个实例（因此你只需要调用一次stopService来停止）。该Service将会一直在后台运行，而不管对应程序的Activity是否在运行，直到被调用stopService，或自身的stopSelf方法。当然如果系统资源不足，Android系统也可能结束服务。

②被绑定的服务的生命周期：如果一个Service被某个Activity调用Context.bindService方法绑定启动，不管调用bindService调用几次，onCreate方法都只会调用一次，同时onStartCommand方法始终不会调用。当链接建立之后，Service将会一直运行，除非调用Context.unbindService断开连接或者之前调用bindService的Context不存在了（如Activity被finish的时候），系统将会自动停止Service，对应onDestroy将被调用。

③被启动又被绑定的服务的生命周期：如果一个Service先被启动，后又被绑定，则该Service将会一直在后台运行。并且不管如何调用，onCreate始终只会调用一次，对应startService调用多少次，Service的onStartCommand就会调用多少次。调用unbindService将不会停止Service，而必须调用stopService或Service自身的stopSelf来停止服务（在没有解绑的前提下使用stopService是无法停止服务的）。

④当服务被停止时的清除工作：当一个Service被终止（1、调用stopService；2、调用stopSelf；3、不再有绑定的连接（通过bindService启动））时，onDestroy方法将会被回调，在这里应当做一些清除工作（如停止Service中创建并运行的线程、注册的侦听器、接收器等）。

使用Service时的注意事项

①在调用bindService绑定到Service的时候，就应当保证在某处调用unbindService解除绑定（尽管Activity被finish的时候会自动解除绑定，并且会自动停止Service）；

②使用startService启动服务之后，一定要使用stopService停止服务，不管你是否使用bindService；

③同时使用startService和bindService时要注意：Service的终止，需要unbindService与stopService同时调用，才能终止Service。关于调用顺序，如果先调用unbindService此时服务不会自动终止，再调用stopService服务才会停止；如果先调用stopService此时服务也不会终止，需要再调用unbindService（或者调用bindService的Context不存在了，如Activity被finish的时候）服务才会自动停止。

④当旋转手机屏幕的时候，如果发生了Activity的重建（请参考Android四大组件（一）Activity），旋转之前的使用bindService建立的连接便会断开（Context不存在了）。

⑤在sdk 2.0之前的版本，使用的onStart方法被onStartCommand方法替换了，但是onStart方法仍然有效。

跨进程调用Service（AIDL服务）

理解什么是AIDL（Android Interface Definition Language,即Android接口定义语言）
Android系统中，应用程序都运行在自己的进程中，进程之间一般无法直接进行数据交换。在Java技术中，RMI可实现跨进程调用；在Android的中，采用了相似的方式来实现跨进程调用Service，这就是AIDL。与RMI相似，也是先定义一个远程调用接口，然后为该接口提供一个实现类；与RMI不同的是，客户端访问Service时，Android并不是直接返回Service对象给客户端。这点在绑定本地Service时已经看到，Service只是将一个回调对象（IBinder对象）通过onBind()方法返回给客户端。因此Android的AIDL远程接口的实现类就是IBinder实现类。与绑定本地Service不同的是，本地Service的onBind()方法会直接把IBinder对象本身传给客户端的ServiceConnection的onServiceConnected方法的第二个参数。远程Service的onBind方法只是将IBinder对象的代理传给客户端的ServiceConnection的onServiceConnected方法的第二个参数。客户端获取了远程Service的IBinder对象的代理后，就可通过该IBinder对象去回调远程Service的属性或方法了。

AIDL的操作步骤

Service端
1、新建AIDL文件

新建AIDL文件

2、按需求自己定义接口

自己定义IUserInfo接口

3、重新build工程，AS会在build目录中生成aidl对应的java实现

4、编写Service类

package com.rave.simpledemo.aidldemo;

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

import java.util.Timer;
import java.util.TimerTask;

/**
 * Created by Administrator on 2019/1/25.
 */
public class AidlUserService extends Service {
    private String name = "rave";
    private int age = 0;

    private int count = 0;
    private Timer timer = new Timer();

    /**
     * 这里跟本地Service不一样，没有直接继承Binder类，而是继承了ADT所生成的IUserInfo.Stub
     * 但是IUserInfo.Stub也是Binder的子类
     */
    private IBinder stub = new IUserInfo.Stub() {

        @Override
        public String getName() throws RemoteException {
            return name + count;
        }

        @Override
        public int getAge() throws RemoteException {
            return age + count;
        }
    };

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        /**返回catBinder对象
         * 在绑定本地Service的情况下，该catBinder对象会直接传给客户端的
         * ServiceConnection对象的onServiceConnected方法的第二个参数；
         * 在绑定远程Service的情况下，只将catBinder对象的代理传给客户端的
         * ServiceConnection对象的onServiceConnected方法的第二个参数。
         */
        return stub;
    }

    @Override
    public void onCreate() {
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                count++;
            }
        }, 0, 1 * 1000);
    }

    @Override
    public void onDestroy() {
        /**
         * 在onDestroy里面做清理回收工作
         */
        timer.cancel();
    }
}

5、当然不要忘记在manifest.xml里注册该Service

客户端访问AIDL服务
1、将Service端的AIDL接口文件复制到客户端应用中，要连文件路径一起复制

需要复制的部分

2、同Service端一样，重新build工程，AS会调用ADT在build目录中生成aidl对应的java实现

3、创建ServiceConnection对象，并以ServiceConnection对象作为参数，调用bindService()方法绑定远程Service

package com.richinfo.aidlclient;

import android.app.Service;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import com.rave.simpledemo.aidldemo.IUserInfo;

public class UserInfoActivity extends AppCompatActivity {

    private TextView tvUserName, tvUserAge;
    private Button btnBind, btnUnbind, btnGet;
    private Intent intent;

    private IUserInfo userInfoService;
    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            /**
             * 与本地绑定Service不同，绑定远程Service的ServiceConnection不能直接获取Service的onBind方法所返回的对象；
             * 它只能返回onBind()方法所返回的对象的代理，因此需要在这里做asInterface的处理。
             */
            userInfoService = IUserInfo.Stub.asInterface(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_user_info);
        tvUserName = (TextView) findViewById(R.id.tv_username);
        tvUserAge = (TextView) findViewById(R.id.tv_userage);
        btnBind = (Button) findViewById(R.id.btn_bind);
        btnUnbind = (Button) findViewById(R.id.btn_unbind);
        btnGet = (Button) findViewById(R.id.btn_get);

        intent = new Intent();
        // Android 5.0以后需要用显示意图来启动Service，否则会报异常
        // java.lang.IllegalArgumentException: Service Intent must be explicit
        // 这里由于是跨进程所以用Component来解决这个问题,试过用setPackage的方式，无法解决这个问题
        intent.setComponent(new ComponentName("com.rave.simpledemo", "com.rave.simpledemo.aidldemo.AidlUserService"));
        //这种方式很多博客上说可以，经测试这种方式可以startService成功的启动远程service，但是在启动之后再绑定会出现绑定失败的情况。
        //intent.setPackage("com.rave.simpledemo");

        intent.setAction("com.rave.simpledemo.service.AIDL_USER_SERVICE");
        btnBind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startService(intent);
                bindService(intent, conn, Service.BIND_AUTO_CREATE);
            }
        });

        btnUnbind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                unbindService(conn);
            }
        });

        btnGet.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    tvUserName.setText(userInfoService.getName());
                    tvUserAge.setText(userInfoService.getAge()+"");
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //记得解绑
        unbindService(conn);
        stopService(intent);
    }
}

实践中遇到的问题
1、Android 5.0以后系统禁止使用隐式意图来启动Service，所以在跨进程特别是跨APP的绑定Service的时候，可以采用如下方式：

        Intent intent = new Intent();
        intent.setAction("com.rave.simpledemo.service.AIDL_USER_SERVICE");
        // Android 5.0以后需要用显示意图来启动Service，否则会报异常
        // java.lang.IllegalArgumentException: Service Intent must be explicit
        // 这里由于是跨进程所以用Component来解决这个问题,试过用setPackage的方式，无法解决这个问题
        intent.setComponent(new ComponentName("com.rave.simpledemo", "com.rave.simpledemo.aidldemo.AidlUserService"));

        //这种方式很多博客上说可以，经测试这种方式可以startService成功的启动远程service，但是在启动之后再绑定会出现绑定失败的情况。
        //intent.setPackage("com.rave.simpledemo");

2、无法通过bindService设置BIND_AUTO_CREATE来创建服务，只能先startService启动，再调用bindService绑定：

        // 在使用AIDL的时候，必须要先用startService来启动服务，再用bindService来绑定服务，否则会绑定失败。
        startService(intent);
        boolean flag = bindService(intent, conn, Service.BIND_AUTO_CREATE);

3、在Service的onDestroy里面一定要清理资源，避免内存泄漏。已经客户端调用bindService之后要手动解绑。

传递复杂数据的AIDL服务

上面我们所展示的都是通过AIDL传输基本数据类型。如果是自定义类的话，Android要求调用远程Service的参数和返回值都必须实现Parcelable接口。具体步骤如下：

服务端
1、使用AIDL代码来定义这些自定义类型（包括参数类型和返回值类型）：

使用AIDL定义参数类型

使用AIDL定义返回值类型

2、定义实现Parcelable接口的参数类和返回值类(返回值类一样这里demo省略代码)

package com.rave.simpledemo.aidldemo;

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

/**
 * Created by Administrator on 2019/1/28.
 */
public class Person implements Parcelable {
    private Integer id;
    private String name;
    private String pass;

    public Person() {

    }

    public Person(Integer id, String name, String pass) {
        super();
        this.id = id;
        this.name = name;
        this.pass = pass;
    }

    protected Person(Parcel in) {
        name = in.readString();
        pass = in.readString();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getPass() {
        return pass;
    }

    public void setPass(String pass) {
        this.pass = pass;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((pass == null) ? 0 : pass.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }

        if (getClass() != obj.getClass()) {
            return false;
        }

        Person other = (Person) obj;
        if (this.name == null) {
            if (other.name != null) {
                return false;
            }
        } else if (!this.name.equals(other.name)) {
            return false;
        }

        if (this.pass == null) {
            if (other.pass != null) {
                return false;
            }
        } else if (!this.pass.equals(other.pass)) {
            return false;
        }

        return true;
    }

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        //把对象所包含的数据写到Parcel中
        dest.writeInt(id);
        dest.writeString(name);
        dest.writeString(pass);
    }

    public static final Creator CREATOR = new Creator() {
        @Override
        public Person createFromParcel(Parcel in) {
            return new Person(in.readInt(), in.readString(), in.readString());
        }

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

3、使用AIDL定义通信接口

AIDL定义通信接口

在AIDL接口中定义方法时，需要指定形参的传递模式。对于java语言来说，一般都是采用传入参数的方式，因此上面指定为in模式。具体的传参方式有以下几种：
① in：参数由客户端设置，或者理解为客户端传入参数值；
② out：参数由服务器设置，或者理解成由服务端返回值；
③ inout：客户端服务端都可以设置，或者理解成可以双向通信。
任何自定义类型都需要在这里显示使用import引入(即便该类的AIDL文件和通信接口是在同一个包下)，否则会报错：

Error:Execution failed for task ':app:compileDebugAidl'.
com.android.ide.common.process.ProcessException: org.gradle.process.internal.ExecException: Process 'command 'G:\Android\sdk1\build-tools\23.0.1\aidl.exe'' finished with non-zero exit value 1

4、再次不要忘记在manifest.xml里注册该Service

客户端
1、跟传输基本类型一样，将Service端的AIDL接口文件复制到客户端应用中（包括定义接口的aidl的文件IPet.aidl、定义的自定义类型的AIDL文件（包括参数类型和返回值类型）、定义的自定义类型的Java类文件（包括参数类型和返回值类型））。同样要保证文件路径和类的包名和跟Service端一致。

复制到客户端的文件

2、后面的启动服务和绑定服务的操作跟传输基本数据类型一样。下面给出本例的客户端代码：

package com.richinfo.aidlclient;

import android.app.Service;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import com.rave.simpledemo.aidldemo.IPet;
import com.rave.simpledemo.aidldemo.Person;
import com.rave.simpledemo.aidldemo.Pet;

import java.util.List;

public class ComplexTypeActivity extends AppCompatActivity {
    private TextView tvContent;
    private Button btnBind;
    private Button btnUnbind;
    private Button btnGet;

    private Intent complexServiceIntent;
    private IPet iPetService;

    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            iPetService = IPet.Stub.asInterface(service);
            System.out.println("onServiceConnected");
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_complex_type);

        tvContent = (TextView) findViewById(R.id.tv_content);
        btnBind = (Button) findViewById(R.id.btn_bind);
        btnGet = (Button) findViewById(R.id.btn_get);
        btnUnbind = (Button) findViewById(R.id.btn_unbind);

        complexServiceIntent = new Intent();
        complexServiceIntent.setAction("com.rave.simpledemo.service.COMPLEX_SERVICE");
        complexServiceIntent.setComponent(new ComponentName("com.rave.simpledemo", "com.rave.simpledemo.aidldemo.ComplexService"));

        btnBind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startService(complexServiceIntent);
                boolean isSuccess = bindService(complexServiceIntent, conn, Service.BIND_AUTO_CREATE);
                System.out.println("bind successed:" + isSuccess);
            }
        });

        btnGet.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    List petList = iPetService.getPets(new Person(1, "rava", "rave"));
                    int size = petList.size();
                    tvContent.setText("pet count:" + size + "");
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });

        btnUnbind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                unbindService(conn);
            }
        });

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conn);
        stopService(complexServiceIntent);
    }
}

获取系统服务

1、电话管理器（TelephonyManager）：

//getSystemService(String name)：根据服务名称来获取系统服务。
TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

获取网络状态
获取SIM卡信息
监听通话状态

2、短信管理器（SmsManager）:

//获取SmsManager
SmsManager smsManager = SmsManager.getDefault();

短信发送

3、音频管理器（AudioManager）：

//获取音频管理器
AudioManager audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);

调节系统音量：adjustStreamVolume(int streamType, int direction, int flags)，streamType声音类型；direction对声音进行增大还是减小；flags调整声音时的标志。
设置麦克风静音：setMicrophoneMute(boolean on)。
设置声音模式：setMode(int mode)，可设置的值有NORMAL、RINGTONE和IN_CALL。
设置手机的电话铃声模式：setRingerMode(int ringerMode)，可设置铃声模式、静音模式、振动模式。
设置打卡扩音器：setSpeakerphoneOn(boolean on)。
将制定类型的声音调整为静音：setStreamMute(int streamType, boolean state)，streamType声音类型。
设置手机指定类型的音量值：setStreamVolume(int streamType, int index, int flags)，streamType声音类型；index具体的音量值；flags调整声音时的标志。

4、振动器（Vibrator）：

Vibrator vibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);

控制手机振动：vibrate(long milliseconds)、vibrate(long[] pattern, int repeat)振动；cancel()关闭振动。

5、手机闹钟服务（AlarmManager）：

AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);

开发闹钟应用
全局定时器

特殊的Service——IntentService

通过上面的内容，我们已经发现了。服务的代码默认运行在主线程里的。如果要在服务里面执行耗时操作的代码，就需要开启一个主线程去处理这些代码。比如在启动和停止Service的例子中：

    @Override
    public void onCreate() {
        super.onCreate();
        System.out.println("==================BindService onCreate====================");
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (!quit) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count++;
                }
                stopSelf();
            }
        }).start();
    }

我们知道服务一旦启动就会一直运行下去，必须手动调用stopService()或者stopSelf()方法才能让服务停止下来。所以在上例中我们需要在run()方法的最后，调用stopSelf来结束服务。谷歌给我们提供IntentService，就是为了方便开发者处理在Service中开启子线程的情况。它帮我们开发者封装了开启子线程、线程间通信（采用Handler）、以及自动销毁服务等操作。

IntentService的使用步骤
1、继承IntentService创建自定义的IntentService类

package com.rave.simpledemo.service;

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

/**
 * Created by Administrator on 2019/1/30.
 */
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、在Manifest里面注册IntentService，注册方式跟Service一样

3、启动IntentService
我们推荐使用startService(intent)的方式来启动服务。

注意!!!也可以使用bindService的方式来启动服务。但是在使用bindService的启动的时候，即使onHandleIntent里面的逻辑执行完毕，也不会自动销毁服务。原因应该是Service还是被绑定状态，调用stopSelf无法停止。所以如果使用bindService启动服务将会失去IntentService的一大特点，使用时请谨慎.

4、销毁IntentService
IntentService的一大特点就是onHandleIntent里面的代码逻辑执行完之后，自动销毁Service。所以我们可以不用专门做停止IntentService的操作。

注意!!!我们也可以在客户端手动调用stopService来销毁服务，但是用这种方式不会停止IntentService里面启动的子线程。如果要采用这种方式销毁服务，一定要注意子线程无法停止，从而导致内存泄漏的问题。

Android四大组件（二）：Service

Activity与Service的对比

创建Service

启动和停止Service

Service的生命周期

跨进程调用Service（AIDL服务）

获取系统服务

特殊的Service——IntentService

你可能感兴趣的:(Android四大组件（二）：Service)