一、service的应用场景，以及和Thread的区别

1.service定义

用来：后台处理耗时逻辑，长时间任务 ，退出后台 仍能长时间运行（service保活）

service是一个一种可以在后台执行长时间运行操作而没有用户界面的应用组件。
可以由 activity 或 broadcast 来启动，运行在主线程

2.和Thread 的区别

service 运行在主线程 ， Thread 子线程，相对独立
不能耗时操作 ，会报错 ANR异常

二、开启service的两种方式以及区别

1.startService

无期限的运行

用法

public class FirstService extends Service {
    /**
     * 绑定服务时才会调用
     * 必须要实现的方法
     *
     * @param intent
     * @return
     */
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    /**
     * 首次创建服务时，系统将调用此方法来执行一次性设置程序（在调用 onStartCommand() 或 onBind() 之前）。
     * 如果服务已在运行，则不会调用此方法。该方法只被调用一次
     */
    @Override
    public void onCreate() {
        System.out.println("onCreate invoke");
        super.onCreate();
    }

    /**
     * 每次通过startService()方法启动Service时都会被回调。

   可通过 stopSelf 或  stopService 来结束自身，
     *
     * @param intent
     * @param flags
     * @param startId
     * @return     返回值是 int类型  
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        System.out.println("onStartCommand invoke");
        return super.onStartCommand(intent, flags, startId);
    }

    /**
     * 服务销毁时的回调
     */
    @Override
    public void onDestroy() {
        System.out.println("onDestroy invoke");
        super.onDestroy();
    }
}

2.bindService

需要实现 onBind()方法
和activity 进行数据交互 ，进程中通信
多个activity 可以绑定 一个 service 需要全部解绑后 会自动销毁

image.png

需要注意 onStartCommand的返回值
START_STICKY 当setvice 因内存不足被收回，系统有内存空余时，会尝试重新启动service

源码

public class ServiceActivity extends BaseActivity implements View.OnClickListener, ServiceConnection {

    private Button startService;
    private Button stopService;

    private Button bindService;
    private Button unbindService;


    private MyService.DownloadBinder downloadBinder;

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

        initView();

        initEvent();
    }

    private void initView() {
        startService = (Button) findViewById(R.id.start_Service);
        stopService = (Button) findViewById(R.id.stop_service);
        startService.setOnClickListener(this);
        stopService.setOnClickListener(this);

        bindService = (Button) findViewById(R.id.bind_service);
        unbindService = (Button) findViewById(R.id.unbind_service);
        bindService.setOnClickListener(this);
        unbindService.setOnClickListener(this);

    
    }

    private void initEvent() {
    }

    @Override
    public void onClick(View v) {

        switch (v.getId()) {
            case R.id.start_Service:
                Intent startIntent = new Intent(this, MyService.class);
                startService(startIntent); // 启动服务
                break;
            case R.id.stop_service:
                Intent stopIntent = new Intent(this, MyService.class);
                stopService(stopIntent); // 停止服务

                /*那服务有没有什么办法让自已停止下来呢？
                只需要在MyService 的任何一个位置调用stopSelf()方法就能让这个服务停止下*/
                break;

            case R.id.bind_service:
                Intent bindIntent = new Intent(this, MyService.class);
                bindService(bindIntent, this, BIND_AUTO_CREATE); // 绑定服务
                break;
            case R.id.unbind_service:
                unbindService(this); // 解绑服务
                break;

   
            default:
                break;
        }

    }



    /**
     * 与服务端交互的 接口方法 ，绑定服务的时候被回调,在这个方法获绑定Service 传递过来的IBinder对象
     *
     * 通过这个 IBinder 对象 实现 与service 之间的交互
     *
     * @param service  service中 的 IBinder
     */
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {

        downloadBinder = (MyService.DownloadBinder) service;
        //获取 MyService 对象实例 ,可以调用其公共方法
        MyService serVice = downloadBinder.getSerVice();

        downloadBinder.startDownload();  //调用bundle中方法
        downloadBinder.getProgress();

    }

    /**
     * 当取消 绑定的时候 会被回调
     *
     * 比如内存不足 回收时 ，会被回调
     */
    @Override
    public void onServiceDisconnected(ComponentName name) {

    }
}

public class MyService extends Service {


    private  Thread  thread;
    private  int count =0;
    private boolean quit = false;


    private DownloadBinder mBinder = new DownloadBinder();

    class DownloadBinder extends Binder {
        //声明一个 方法 提供给 客户端
        MyService getSerVice(){
            //返回当前对象LocalService  这样我们就可以在客户端调用了
            return MyService.this;
        }

        public void startDownload() {  //开始下载的方法
            Log.d("MyService", "startDownload executed");
        }
        public int getProgress() {   //查看下载的方法
            Log.d("MyService", "getProgress executed");
            return 0;
        }
    }


    /**
     * 公路方法 供绑定的activity 调用
     */
    public int  getCount(){
        return count;
    }


    /**
     * 绑定服务时才会调用
     * 必须要实现的方法

     * @param intent
     * @return
     */
    @Override
    public IBinder onBind(Intent intent) {
       return mBinder;
    }

    /**
     * 首次创建服务时，系统将调用此方法来执行一次性设置程序（在调用 onStartCommand() 或 onBind() 之前）。
     * 如果服务已在运行，则不会调用此方法。该方法只被调用一次
     */
    @Override
    public void onCreate() {
        super.onCreate();

         thread = new Thread(new Runnable() {
           @Override
           public void run() {

               while(!quit){
                   try {
                       Thread.sleep(1000);
                   }catch (InterruptedException e){
                        e.printStackTrace();
                   }
                   count++;
               }
           }
       });

        thread.start();

    }


    /**
     * 每次通过startService()方法启动Service时都会被回调。
     *
     * @param intent
     * @param flags
     * @param startId
     * @return   注意返回值  当返回值为 START_STICKY 表示 内存足够时会自动重启
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }


    /**
     * 服务销毁时的回调
     */
    @Override
    public void onDestroy() {
        super.onDestroy();
    }
}