学习笔记之Service

鉴于Service的知识比较容易忘掉，所以今天就把Service的知识总结一下

服务： 长期后台运行的没有界面的组件。

android应用：什么地方需要用到服务？

天气预报：后台的连接服务器的逻辑，每隔一段时间 获取最新的天气信息
股票显示：后台的连接服务器的逻辑，每隔一段时间 获取最新的股票信息
mp3播放器： 后台长期的播放音乐。

当然在Activity中new Thread（）{}.start(); 子线程没有界面，也是长期后台运行的。但是当Activity被销毁掉时，当内存不够的时候，系统就会认为这是一个空进程，然后会自动回收掉这个进程，导致这个后台运行的线程异常停止掉。

下面说一下android的进程管理的相关知识：

android系统进程管理是按照一定的规则的：
1.应用程序一旦被打开 通常情况下关闭（清空任务栈）后进程不会停止。方面下一次快速启动。
带来内存不足的问题。
2.Android系统有一套 内存清理机制。 按照优先级去回收系统的内存。


进程分为5个等级的优先级：（从高到低）


1.Foreground process 前台进程  用户正在玩的应用程序对应的进程

2.Visible process 可视进程 用户仍然可以看到这个进程的界面。

3.Service process服务进程  应用程序有一个服务组件在后台运行。

4.Background process 后台进程  应用程序没有服务在运行 并且最小化 （activity onstop）

5.Empty process 空进程 没有任何运行的activity， 任务栈空了(例如：当应用程序被按返回键退出时)


所以长期后台运行的组件， 不要在activity开启子线程。
应该是创建服务，在服务里面开启子线程。


服务的目的：
1.长期后台运行。
2.提高进程的优先级，系统不容易回收掉进程，即便回收了，内存充足的时候，把进程重新创建。

当然这里也要提及一下IntentService

IntentService会使用队列来管理请求Intent，每当客户端代码通过Intent请求启动IntentService时，IntentService会将该Intent加队列中，然后开启一条新的worker线程来处理该Intent。对于一步的startService()请求，IntentService会按次序依次处理队列中的Intent，该线程保证同一时刻只处理一个Intent。由于IntentService使用信的woeker线程处理Intent请求，因此IntentService不会阻塞主线程，所以IntentService自己就可以处理耗时任务。

所以可以启动IntentService多次，而每一个耗时操作会以工作队列的方式在IntentService的onHandleIntent回调方法中执行，并且，每次只会执行一个工作线程，执行完第一个再执行第二个，以此类推。而且，所有请求都在一个单线程中，不会阻塞应用程序的主线程（UI Thread），同一时间只处理一个请求。那么，用IntentService有什么好处呢？首先，我们省去了在Service中手动开线程的麻烦，第二，当操作完成时，我们不用手动停止Service。

IntentService的原理：  

IntentService在处理事务时，还是采用的Handler方式，创建一个名叫 ServiceHandler 的内部Handler，并把它直接绑定到 HandlerThread所对应的子线程。  ServiceHandler把处理 一个intent所对应的事务都封装到叫做 onHandleInten t的虚函数；因此我们直接实现 虚函数 onHandleIntent ，再在里面根据Intent的不同进行不同的事务处理就可以了。

另外， IntentService默认实现了Onbind（）方法，返回值为null。

　　使用IntentService需要两个步骤：

　　 1 、写构造函数

　　 2 、 实现 虚函数 onHandleIntent ，并在里面根据Intent的不同进行不同的事务处理就可以了。

下面归纳一下IntentService具有如下特征：

一·IntentService会创建单独的worker线程来处理所有的Intent请求

二·IntentService会创建单独的worker线程来处理onHandleIntent()方法实现的代码，因此开发者无需处理多线程的问题

三·当所有请求完成后，IntentService会自动停止，因此开发者无须调用stopSelf()方法来停止该Service

四·为Service的onBind()方法提供了默认实现，默认实现的onBind()方法返回null

五·为Service的onStartCommand()方法提供了默认实现，该实现会将请求Intent添加到队列中

所以继承IntentService只需要重写onHandleIntent()就行了。然后在这个方法里面进行耗时操作。

  下面介绍一个Service的四种用法：

第一种：本地服务（普通的启动服务）

public void start(View view){
    	Intent intent = new Intent(this,MyService.class);
    	//通知框架开启服务。
    	startService(intent);
    }
    public void stop(View view){
    	Intent intent = new Intent(this,MyService.class);
    	stopService(intent);
    }

第二种：本地服务(调用本地服务)

   第一步：先定义一个service的接口类IMiddlePerson

/**
 * 定义一个接口，这样不仅可以让内部类的信息不公开，而且还可以给外部调用这个方法
 * 中间人的接口定义
 *
 */
public interface IMiddlePerson {
	/**
	 * 代办暂住证
	 * @param money
	 */
	public void callMethodInService(int money);
}

第二步：定义一个service类

public class MyService extends Service {

	//2.实现服务成功绑定的代码 ，返回一个中间人。
	@Override
	public IBinder onBind(Intent arg0) { 
		System.out.println("服务被成功绑定了。。。。");
		return new MiddlePerson();
	}
	
	@Override
	public boolean onUnbind(Intent intent) {
		System.out.println("onunbind");
		return super.onUnbind(intent);
	}
	
	@Override
	public void onCreate() {
		System.out.println("oncreate");
		super.onCreate();
	}
	
	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		System.out.println("onstartcommand");
		return super.onStartCommand(intent, flags, startId);
	}
	
	@Override
	public void onDestroy() {
		System.out.println("ondestory");
		super.onDestroy();
	}
	
	
	
	
	/**
	 * 这是服务里面的一个方法
	 */
	public void methodInService(){
		Toast.makeText(this, "哈哈，服务给你办好了暂住证。", 0).show();
	}
	
	//1.第一步服务要暴露方法 必须要有一个中间人
	private class MiddlePerson extends Binder implements IMiddlePerson{//继承Binder是因为 onBind（）方法返回的是一个IBinder类型，
                                                                       //而Binder是IBinder接口的实例
		/**
		 * 代办暂住证
		 * @param money 给钱 50块钱以上才给办。
		 */
		public void callMethodInService(int money){
			if(money>=50){
				methodInService();
			}else{
				Toast.makeText(getApplicationContext(), "多准备点钱。", 0).show();
			}
			System.out.println("我是从接口实现的方法，特点是调用我这个方法不会暴露这个类的其他信息");
		}
		/**
		 * 陪领导打麻将
		 */
		public void playMajiang(){
			System.out.println("陪领导打麻将。");
			System.out.println("外部不能调用我这个方法，原因是因为我是私有类的成员" +
					"，所以想实现调用service的方法，就要通过实现接口的方式去实现，例如上面的sendmessage（）");
		}
	}
}

第三步：调用

public class MainActivity extends Activity {
	private MyConn conn ;
	private IMiddlePerson mp;

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

    //绑定服务
    public void bind(View view){
    	//3.activity采用绑定的方式去开启服务。
    	Intent intent = new Intent(this,MyService.class);
    	conn = new MyConn();
    	bindService(intent, conn, BIND_AUTO_CREATE);
    	
    }
    //解除绑定服务
    public void unbind(View view){
    	unbindService(conn);
    }
    
    @Override
    protected void onDestroy() {
    	System.out.println("啊啊啊，我是activity，我挂了");
    	super.onDestroy();
    }
    //调用服务里面的方法。
    public void call(View view){
    	//5.通过中间人调用服务里面的方法。
    	mp.callMethodInService(55);
    }
    
    private class MyConn implements ServiceConnection{
    	//4. 当服务被连接的时候调用 服务别成功 绑定的时候调用
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			System.out.println("在activity里面成功得到了中间人");
			mp = (IMiddlePerson) service;
		}
		//当服务失去连接的时候调用（一般进程挂了，服务被异常杀死）
		@Override
		public void onServiceDisconnected(ComponentName name) {
			
		}
    }
}

绑定本地服务调用方法的步骤：
1.在服务的内部创建一个内部类 提供一个方法，可以间接调用服务的方法
private class MiddlePerson extends Binder implements IMiddlePerson{}
2.实现服务的onbind方法，返回的就是中间人 MiddlePerson
3.在activity 绑定服务。bindService();
4.在服务成功绑定的时候 会执行一个方法 onServiceConnected 传递过来一个 IBinder对象
5.强制类型转化 调用接口里面的方法。

//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

第三种：远程服务-----调用者和服务在不同的工程代码里面。

每一个应用程序都是运行在自己独立的进程里面的。
进程操作系统分配内存空间的一个单位。进程的数据都是独立的。独立的内存空间。

aidl：android interface definition language  安卓接口定义语言
aidl文件都是公有的，没有访问权限修饰符
IPC： inter process communication 进程间通讯

所以下面通过aidl进行进程间的通信

和上面一样，只不过要将之前的接口类改一下后缀名为.aidl，然后把所以public，private和protected删掉，因为aidl本来就是公有的，修改后如下

package com.itheima.remoteservice;


 interface IMiddlePerson {
/**
* 调用服务里面的方法
*/
void callMethodInService();
}

然后在service中的调用就变成了下面这样

	private void methodInService(){
		System.out.println("我是远程服务的方法，我被调用了。。。。");
	}
	
	//1.创建一个中间人  远程服务继承的是ipc的一个实现类<pre name="code" class="html"> 

private class MiddlePerson extends IMiddlePerson.Stub{@Overridepublic void callMethodInService() {methodInService();}}

当然我们需要在AndroidManifest中进行配置

<service android:name="com.cenzr.remoteservice.RemoteService">
            <intent-filter >
                <action android:name="com.<span style="font-family: Arial, Helvetica, sans-serif;">cenzr</span>.remoteservice"/>
            </intent-filter>
        </service>

我们现在另外新建一个项目，然后把刚刚定义好的aidl连同包和aidl文件一起拷过来

          

接着我们就可以调用我们远程服务service中的方法了

            

public class MainActivity extends Activity {
	private MyConn conn;
	private IMiddlePerson iMp;

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

	/**
	 * 绑定远程服务
	 * @param view
	 */
	public void bind(View view){
		Intent intent = new Intent();
		intent.setAction("com.cenzr.remoteservice");
		conn = new MyConn();
		bindService(intent, conn, BIND_AUTO_CREATE);
	}
	
	private class MyConn implements ServiceConnection{
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			iMp = IMiddlePerson.Stub.asInterface(service);
		}
 
		@Override
		public void onServiceDisconnected(ComponentName name) {
			
		}
	}
	
	public void call(View view){
		try {
			iMp.callMethodInService();
		} catch (RemoteException e) {
			e.printStackTrace();
		}
	}
	@Override
	protected void onDestroy() {
		unbindService(conn);
		super.onDestroy();
	}
}

绑定远程服务调用方法的步骤：
1.在服务的内部创建一个内部类 提供一个方法，可以间接调用服务的方法
2.把暴露的接口文件的扩展名改为aidl文件 去掉访问修饰符 public
private class MiddlePerson extends IMiddlePerson.Stub{}  IPC的子类
3.实现服务的onbind方法，返回的就是中间人 IMiddlePerson
4.在activity 绑定服务。bindService();
5.在服务成功绑定的时候 会执行一个方法 onServiceConnected 传递过来一个 IBinder对象
6.IMiddlePerson.Stub.asInterface(binder) 调用接口里面的方法。

//---------------------------------------------------------------------------------------------------------------------------------------------------------------------

第四种用法：混合使用

当你想service一直在后台运行又想调用里面的方法的时候就可以才去这样的方式

public class MainActivity extends Activity {
	private ISafePay iSafePay;
	private MyConn conn;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		Intent intent = new Intent();
		intent.setAction("com.cenzr.alipay");
		startService(intent);
//		保证服务长期后台运行。
	
	}
	
	public void start(View view){
		Intent intent = new Intent();
		intent.setAction("com.<span style="font-family: Arial, Helvetica, sans-serif;"><span style="font-size:10px;">cenzr</span></span>.alipay");
		startService(intent);
	}
	
	public void stop(View view){
		Intent intent = new Intent();
		intent.setAction("com.cenzr.alipay");
		stopService(intent);
	}
	public void bind(View view){
		Intent intent = new Intent();
		intent.setAction("com.cenzr.alipay");
		conn = new MyConn();
		bindService(intent, conn, BIND_AUTO_CREATE);//异步的操作
	}
	public void unbind(View view){
		unbindService(conn);
	}
	
	
	
	public void click(View view){
		Intent intent = new Intent();
		intent.setAction("com.cenzr.alipay");
		conn = new MyConn();
		bindService(intent, conn, BIND_AUTO_CREATE);//异步的操作
		//绑定服务调用服务的方法。
		
	}
	
	private class MyConn implements ServiceConnection{
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			iSafePay = ISafePay.Stub.asInterface(service);
			try {
				boolean result = iSafePay.callPay(System.currentTimeMillis(), "123", 3.52f);
				if(result){
					Toast.makeText(getApplicationContext(), "支付成功，获取大炮弹", 0).show();
				}else{
					Toast.makeText(getApplicationContext(), "支付失败，请重试", 0).show();
				}
//				unbindService(conn);
//				conn = null;
			} catch (RemoteException e) {
				e.printStackTrace();
			}
		}

		@Override
		public void onServiceDisconnected(ComponentName name) {
			
		}
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

以下是各种方式的生命周期

一、采用start的方式开启服务 
生命周期如下：
                         onStart()过时了
开启服务： onCreate()--> onStartCommand()  ---> onDestory();

如果服务已经开启，不会重复的执行onCreate()， 而是会调用onStart()和 onStartCommand();

服务停止的时候 onDestory().

服务只会被停止一次


二、服务还有一种开启方式，绑定的方式开启服务。
onCreate() --->onBind();--->onunbind()-->onDestory();
绑定服务不会调用onstart或者onstartcommand方法；



混合调用的服务的生命周期：
服务长期后台运行，又想调用服务的方法：
1.start方式开启服务（保证服务长期后台运行）
2.bind方式绑定服务（保证调用服务的方法）
3.unbind解除绑定服务
4.stopService停止服务。