Service相关

1.启动服务：

1.1 启动服务的方法：

1.创建一个类继承Service，只有onBind方法是必须重写的；

public class MyService extends Service {

	@Override
    public void onCreate() {
        super.onCreate();
    }
    
	@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
    
 	@Override
    public void onDestroy() {
        super.onDestroy();
    }
    
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

2.在Manifest文件中声明该Service：

 <service android:name=".MyService"
            android:enabled="true"							
            android:exported="true"							允许除了当前程序之外的其他程序访问这个服务
            android:icon="@drawable/background_blue"
            android:label="string"
            android:process="string"						运行的进程
            android:permission="string">					
 </service>

3.启动/关闭服务：

	Intent intnet = new Intent(this,MyService.class);
	startService(intnet);

	stopService(intnet);

1.2 启动服务的生命周期：

在正常的开启关闭服务情况下生命周期为：onCreat->onStartCommand->onDestory；
连续多次开启同一个服务只有第一次会执行onCreat,以后只会执行onStartCommand；

启动的服务即使客户端被销毁也不影响Service继续运行

1.3 onStartCommand方法的返回值：

1.START_STICKY：
当前服务终止后，系统会尝试重建Service，但之前的Intent不会保留（意思是重启时onStartCommand的Intent参数为null）
2.START_NOT_STICKY：
当前服务终止后，系统不会尝试重建Service
3.START_REDELIVER_INTENT：
当前服务终止后，系统会尝试重建Service，并保留之前的Intent；
4.START_STICKY_COMPATIBILITY：
START_STICKY的兼容版本，但不保证服务被终止后一定能重启。

2.绑定服务：

2.1 绑定服务的方法：

1.需要创建一个Binder对象对外提供服务的接口：

class MyBinder extends Binder {
	public void function1() {
	}
	public void function2() {
	}
}

2.在onBinder中返回这个Binder对象，

public class MyService extends Service {
	private MyBinder mBinder = new MyBinder();
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }
}

3.创建一个ServiceConnection对象作为绑定/解绑时候的回调

	 MyBinder mBinder;
	 ServiceConnection connection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                mBinder= (MyService)service;				//这里的service就是onBind方法给返回的binder对象
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
				//当服务意外中断时会执行这个方法，正常取消绑定不会执行
            }
        };

4.绑定/解绑Service：

	Intent intent = new Intent(this, MyService.class);
	bindService(intent,connection,BIND_AUTO_CREATE);

	unbindService(connection);

2.2 绑定服务的生命周期：

bindService时Service的onCreate和onBind方法会执行，但onStartCommand方法不会执行；
unbindService时Service的onDestory方法会执行；

绑定的服务在客户端被销毁后也停止运行

2.3 通过Messenger绑定服务：

Service端：

public class MyService extends Service {
	Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Messenger client = msg.replyTo;
            ...                  
      		//这里在Service端处理Client发来的消息
      		client.send(replyMsg);
        }
    };
    private Messenger messenger = new Messenger(mHandler);

    @Override
    public IBinder onBind(Intent intent) {
          return messenger.getBinder();
    }
}

Client端：

public class mActivity extends Activity {
	private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
      		//这里在Clinet端处理Service发来的消息
        }
    };
    //Client端用这个Messenger发送消息
    private Messenger clientMessenger= new Messenger(mHandler);
    
	private Messenger serviceMessenger = null;
 	private ServiceConnection connection = new ServiceConnection() {
          @Override
          public void onServiceConnected(ComponentName name, IBinder service) {
                mService = new Messenger(iBinder);	
          }

          @Override
          public void onServiceDisconnected(ComponentName name) {
				//当服务意外中断时会执行这个方法，正常取消绑定不会执行
           }
    };
	
	private void sendMsg(){
		  Message message = Message.obtain();
		  msg.replyTo = clientMessenger;
		    ....
		  mService.send(msg)
	}
}

3.前台服务：

只要在Service中调用startForeground方法即可启动前台进程：

public class MyService extends Service {

	@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
     	NotificationCompat.Builder builder=new NotificationCompat.Builder(this);
     	//设置Notification属性，略
    	Notification notification = builder.Builder(this);
    	//第一个参数int是Notification的ID，有多个Notification的话ID不同就可以
    	startForeground(1,notification);		
        return super.onStartCommand(intent, flags, startId);
    }

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

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

4.IntentService

IntentService继承自Service，任务完成后自动停止，不在主线程处理任务，可用于执行耗时任务。由于它是一个Service，它的优先级比线程要高，不易被系统杀死；

源码：

public class IntentService extends Service {
	private Handler mServiceHandler;
	
	public void onCreate() {
		HandlerThread thread = new HandlerThread();
		thread.start();
		mServiceLooper = thread.getLooper();
		//继承了Handler，任务实际都是通过它调用onHandleIntent去处理
		mServiceHandler = new ServiceHandler(mServiceLooper);
	}
	
	//onStartCommand()会调用onStart()这个方法
	//intent中包含了外部传递给Service执行任务需要的参数
	public void onStart(Intent intent,int startId) {
		Message msg = mServiceHandler.obtainMessage();
		msg.arg1 = startId;
		msg.obj = intent;
		//发送的消息都会传递给ThreadHandler处理
		//ThreadHandler处理任务时就会调用onHandleIntent()方法
		mServiceHandler.sendMessage();
	}
	
	protected abstract void onHandleIntent();
}

使用：
继承IntentService ：

public class MyIntentService extends IntentService {
	public MyIntentService() {
	}
	@override
	protected void onHandlerIntent(Intent intent){
		//处理耗时任务
	}
}

像普通Service一样启动：

	Intent intent = new Intent(this,MyIntentService.class);
	//...向intent中传入参数
	startService(intent);