Service之基础（开启服务、绑定本地服务）

Service

什么是Service

• 一个组件长期后台运行，没有界面。

• 简单的理解：service理解成一个没有界面长期运行的activity。

• 特点：

  • 即使进程被杀死，稍后service会重新启动

开启服务的第一种方式（很简单）

前提（略）

1. 继承Service
2. 清单注册Service

如何开启服务

    startService(this,MyService.class)

如何关闭服务

    stopService（）

也可以在手机上—打开设置—打开应用程序服务列表—点击停止来关闭服务

startService方法开启服务的生命周期

• onCreate() –>onStartCommand–>onStart(过时） –>ondestory(销毁）
• 如果服务已经开启了，就不会重新调用oncreate方法，服务只会被创建一次（oncreate只会被调用一次）。

开启服务的第二种方式（有点绕）

Activity

public class BindServiceActivity extends AppCompatActivity {

    private MyBindService.MyBinder binder;
    private ServiceConnection serviceConnection;

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

        serviceConnection = new ServiceConnection() {
            /**
             * 当服务被成功绑定的时候执行的方法，得到中间人IBinder service。
             */
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                binder = (MyBindService.MyBinder) service;
                binder.callMethod();
            }
            /**
             * 当服务失去绑定的时候调用的方法。当服务突然异常终止的时候
             */
            @Override
            public void onServiceDisconnected(ComponentName name) {

            }
        };
        bindService(new Intent(this, MyBindService.class), serviceConnection, BIND_AUTO_CREATE);
    }

        @Override
        protected void onDestroy() {
            super.onDestroy();
    //        一定要在activity销毁时，把这个activity绑定的service解绑，否则会leaked---漏气
            unbindService(serviceConnection);
        }
}

Service

 public class MyBindService extends Service {
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.e("qwe", "onBind");
    //  返回的这个IBinder就是activity和service之间的通讯的中间人
    //  这里的IBinder将会在activity调用bindService绑定服务时所用的一个参数ServiceConnection的回调方法中获取
    //  获取到了这个IBinder，就相当于activity打通了service的内部，可以调用service内部的所有方法

    // IBinder是一个接口，不要实现这个接口（要重写的方法太多了），继承Binder（IBinder的一个实现类）即可
        return new MyBinder();
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.e("qwe", "onCreate");
    }

    private void method() {
        Toast.makeText(this, "我是写在Service内部的方法", Toast.LENGTH_SHORT).show();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
    //  在绑定服务开启服务时，不会走onStartCommand这个生命周期方法
        Log.e("qwe", "onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        Log.e("qwe", "onDestroy");

        super.onDestroy();
    }

    public class MyBinder extends Binder {
        /**
         * 中间人帮助我们调用服务的方法。
         * 中间人这里可以做很多事情
         */
        public void callMethod() {
            method();
        }
    }
}

绑定服务总结

最核心的思路：

• activity里拿到service里的Ibinder
• 通过Ibinder去和service通讯

最核心的方法是：

• activity里的binderService方法（参数ServiceConnection的回调方法的参数IBinder service）

• service里的onBinde方法（返回值Ibinder）

• 1. 使用bindService的方式开启服务。
  2. 
     bindService(intent, new MyConn(), Context.BIND_AUTO_CREATE);

  3. 实现一个MyConn 服务与activity的通讯频道（中间人的联系渠道）

     private class MyConn implements ServiceConnection{
     /**
     * 当服务被成功绑定的时候执行的方法，得到中间人。
     */
     @Override
     public void onServiceConnected(ComponentName name, IBinder service) {
     binder = (MyBinder) service;
     }
     /**
     * 当服务失去绑定的时候调用的方法。当服务突然异常终止的时候
     */
     @Override
     public void onServiceDisconnected(ComponentName name) {

     }
     

     }

  4. 服务成功绑定的时候 会执行onBinde方法，返回中间人

     public class MyBinder extends Binder{
     /**
     * 内部人员帮助我们调用服务的方法。
     */
     public void callMethodInService(){
     methodInService();
     }
     }

  5. 在调用者 activity代码里面通过中间人调用服务的方法。

  6. 解除绑定服务 unbindService(conn)。

绑定服务的生命周期

oncreate()–>onbind()—>onDestory(); 不会调用onstart()方法 和 onstartCommand()方法。

开启服务的第二种方式更标准的写法—抽取接口隐藏私有方法

针对上例：

1. MyBinder为了让activity中可以调用，使用了public修饰符，但是这样带来一个坏处，因为MyBinder是Service的一个内部类，如果把他暴露给外界，外界就会通过MyBinder轻松地调用Service内部的所有方法，万一有些方法是隐秘的呢
2. 那么问题来了，又想让activity使用MyBinder的某个方法，又不想让activity直接拿到MyBinder的引用，该怎么办呢
3. ok，抽取接口IService，定义好准备要被外界调用的方法，在activity里强制转换Ibinder service为该接口IService，即可

代码：

IService

public interface IService {
  public void callMethod();
}

MyBindService的内部类

private class MyBinder extends Binder implements IService {

    /**
     * 中间人帮助我们调用服务的方法。
     * 中间人这里可以做很多事情
     */
    @Override
    public void callMethod() {
        method();
    }

    //私密方法，不想让外界知道
    public void simifangfa() {
    }
}

Activity

private IService binder;
 /**
 * 当服务被成功绑定的时候执行的方法，得到中间人IBinder service。
 */
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
    binder = (IService) service;
    binder.callMethod();
}

开启服务的两种方法的对比

• startService(); 直接开启服务，服务一旦启动跟调用者（开启者没有任何关系）
  
  • 调用者activity退出了，服务还是继续运行活的好好的。
  • 调用者activity，没法访问服务里面的方法。
    
• bindService(); 绑定开启服务，服务和开启者（调用者）有密切的关系。
  
  • 只要activity挂了，服务跟着挂了。
  • 调用者activity，可以调用服务里面的方法。