Service

Service

什么是Service

• service是一个可以在后台执行、长时间运行而不提供用户界面的应用组件，也可为其他应用提供一些功能接口。服务可由其他应用组件启动，而且即使用户切换到其他应用，服务仍将在后台继续运行。所谓的后台是相对前台而言的，具体就是说不依赖于用户界面。
  service不是进程，不是线程。但service运行于所在进程的主线程，它有独立的生命周期。

Service有哪些应用场景

• 下载文件，播放音乐，购买车票 等等

startService方式启动Service怎么做（启动和停止及生命周期）

  private static final String TAG = "servers";


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

    @Override
    public int onStartCommand(final Intent intent, int flags, int startId) {
                  new Thread(new Runnable() {
                      int content=0;
                       String name=intent.getStringExtra("name");
                      @Override
                      public void run() {
                          while (content<100){
                              try {
                                  Thread.sleep(1000);
                                  content++;
                                  Log.e(TAG, "run:........."+content+name );
                              } catch (InterruptedException e) {
                                  e.printStackTrace();
                              }
                          }

                      }
                  }).start();

        return super.onStartCommand(intent, flags, startId);
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.e(TAG, "onBind: ............." );
        return null;
    }

    @Override

  @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.servicestart:
                Intent intent=new Intent(this,servers.class);
                intent.putExtra("name","张三");
                startService(intent);
                break;
            case  R.id.servicestop:
                Intent intent1=new Intent(this,servers.class);
                stopService(intent1);
                break;
        }

    }

bindService方式启动Service怎么做（绑定和解绑及生命周期）

   int count;
   private MyBinder myBinder=new MyBinder();
   boolean stopFlag;

    private class MyBinder extends Binder{
             public  int getCount(){
                  return count;
             }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        System.out.print("执行onBind方法");
        return null;
    }

    @Override
    public boolean onUnbind(Intent intent) {
         System.out.print("执行onUnbind方法");
        return super.onUnbind(intent);
    }

    @Override
    public void onCreate() {
            System.out.print("执行onCreate方法");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        System.out.print("执行onStartCommand方法");
        return super.onStartCommand(intent, flags, startId);

    }

    @Override
    public void onRebind(Intent intent) {
        super.onRebind(intent);
        System.out.print("rebind");
    }

    @Override
    public void onDestroy() {
      super.onDestroy();
      stopFlag=true;
      System.out.print("执行onDestroy");
    }
       class MyThread extends Thread{
           @Override
           public void run() {
               super.run();
               while (!stopFlag){
                   try {
                       Thread.sleep(1000);
                       System.out.print(Thread.currentThread().getName()+"---"+Thread.currentThread().getId());
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   count++;
                   System.out.print(count);
               }
           }
       }

    Button Myservicestart,Myservicestop;
    Intent intent;
    ServiceConnection conn=new  ServiceConnection(){

        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
             System.out.print("onServiceConnected");
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
          System.out.print("onService");
          //MyserviceTwo myserviceTwo=(Myservice.MyBinder)service.getService();
            //ms.printServiceName();
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_myservices);
        binID();
         Intent intent=new Intent(this,Myservice.class);

    }

    private void binID() {
        Myservicestart=findViewById(R.id.Myservicestart);
        Myservicestop=findViewById(R.id.Myservicestop);
        Myservicestart.setOnClickListener(this);
        Myservicestop.setOnClickListener(this);
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case  R.id.Myservicestart:
                bindService(intent, conn, Service.BIND_AUTO_CREATE);
                break;
            case R.id.Myservicestop:
                unbindService(conn);
                break;
        }
    }

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

IntentService有什么不同

• IntentService是继承Service的，那么它包含了Service的全部特性，当然也包含service的生命周期，那么与service不同的是，IntentService在执行onCreate操作的时候，内部开了一个线程，去你执行你的耗时操作。

IntentService怎么用，注意事项

• IntentService解析及使用规范
  IntentService
  1 创建类继承Service

public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;
    private String mName;
    private boolean mRedelivery;

    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }

    public IntentService(String name) {
        super();
        mName = name;
    }

    public void setIntentRedelivery(boolean enabled) {
        mRedelivery = enabled;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }

    @Override
    @Nullable
    public IBinder onBind(Intent intent) {
        return null;
    }

    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);
}

2 创建Service
- 在Service被创建的时候，使用HandlerThread（继承于 Thread）创建一个多线程并运行起来，使用HandlerThread线程的Looper来创建一个Handler，使得此Handler处理的所有任务都运行在非主线程里。

public void onCreate() {

 public void onCreate() {
        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

3 处理任务

 public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
        -----------------------------------------
    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICK;
    }

    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);

4 销毁Service
- 务执行完毕后会调用stopSelf，在没有任何任务正在执行或即将执行的情况下Service会停止运行.

  public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }

5 注意事项
- Service停止运行时要注意使用mServiceLooper.quit()退出Looper。如果不提供绑定服务默认返回null。

   @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }

    @Override
    @Nullable
    public IBinder onBind(Intent intent) {
        return null;
    }