三、Service 启动方式及示例代码

 1. Service的介绍

          Service是安卓的四大组件之一，也是可执行的程序，有自己的生命周期。与Activity创建、配置类似。和Activity一样都是context派生出来的，onResume、onPause、onStop、onRestart等生命周期的都没有，因为没有界面

2. 两种启动方式

         a.采用sart方式启动

             生命周期：

              onCreate()--->onStartCommand()（onStart()方法已过时） ---> onDestory()

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

                      服务停止的时候调用 onDestory()。服务只会被停止一次。

                      一旦服务开启跟调用者(开启者)就没有任何关系了，开启者退出了，开启者挂了，服务还在后台长期的运行。

                      开启者不能调用服务里面的方法。

         b.采用bind方式开启

                   生命周期：

                          onCreate() --->onBind()--->onunbind()--->onDestory()

                    特点：绑定服务不会调用onstart()或者onstartcommand()方法

                               bind的方式开启服务，绑定服务，调用者挂了，服务也会跟着挂掉。

绑定者可以调用服务里面的方法。

3. 推荐混合开启服务的方式：

       a.步骤： 1）在项目里面添加一个接口，里面写一个对外开发的方法

                     2）在服务内部创建一个内部类，继承IBinder接口（可以返回中间人这个类型）  并实现1）的接口（中间人需要实现接口里面的方法），在提供一个可间接调用服务方法

                     3）在Activity中绑定服务成功（bindServic），得到接口类型的中间人对象

                     4）在服务成功绑定的回调方法onServiceConnected,会传递过来一个IBinder对象

                     5）强制类型转化为自定义几口类型，调用接口里面的方法，就相当于间接的调用服务的业务逻辑方法

                   

b.代码：

IService.java:
	
	package com.itheima.testservice.service;
	
	public interface IService {
		public void callMethodInService();
	}


TestService.java:

	
	package com.itheima.testservice;
	
	import com.itheima.testservice.service.IService;
	
	import android.app.Service;
	import android.content.Intent;
	import android.os.Binder;
	import android.os.IBinder;
	import android.view.View;
	import android.widget.Toast;
	
	public class TestService extends Service {
	
		/**
		 * 应用程序绑定服务对象时会调用这个方法
		 * 绑定服务
		 */
		@Override
		public IBinder onBind(Intent intent) {
			System.out.println("--------onBind-----------");
			//绑定服务时返回中间人对象
			return new MyBinder();
		}
		
		/**
		 * 
		 * 解除绑定的服务时调用这个方法
		 */
		@Override
		public boolean onUnbind(Intent intent) {
			System.out.println("--------onUnbind-----------");
			return super.onUnbind(intent);
		}	
	
		/**
		 * 服务的业务逻辑方法
		 */
		public void methodInService() {
			System.out.println("=======methodInService==================");
			Toast.makeText(this, "tishi", 0).show();
		}
	
		/**
		 * 1、中间人
		 * @author Administrator
		 *
		 */
		private  class MyBinder extends Binder implements IService{
			/**
			 * 2、实现接口中的方法，在这方法里面调用服务的业务逻辑方法
			 */
			@Override
			public void callMethodInService() {
				//调用服务的业务逻辑方法
				methodInService();
			}
		}
	}


MainActivity.java:

	
	package com.itheima.testservice;
	
	import com.itheima.testservice.service.IService;
	import android.app.Activity;
	import android.content.ComponentName;
	import android.content.Intent;
	import android.content.ServiceConnection;
	import android.os.Bundle;
	import android.os.IBinder;
	import android.view.View;
	
	public class MainActivity extends Activity {
	
		private Intent intent;
		private MyConn conn;
		private IService myBinder;
	
		@Override
		protected void onCreate(Bundle savedInstanceState) {
			super.onCreate(savedInstanceState);
			setContentView(R.layout.activity_main);
		}
	        //点击了开启服务
		public void start(View view) {
			intent = new Intent(this, TestService.class);
			startService(intent);
		}
	        //点击了停止服务
		public void stop(View view) {
			stopService(intent);
		}
	        //点击了调用服务里面的方法
		public void call(View view) {
			// 4、在activity中调用中间人的方法，就相当于间接地调用服务的业务逻辑方法：
			myBinder.callMethodInService();
		}
	        //点击了绑定服务
		public void bind(View view) {
			//intent = new Intent(this, TestService.class);
			conn = new MyConn();
			// intent 开启service使用的intent
			// MyConn 应用程序与服务之间建立的连接
			// 开启服务时如果服务对象不存在，就会自动创建一个服务对象
			bindService(intent, conn, BIND_AUTO_CREATE);
		}
	        //点击了解除绑定服务
		public void unbind(View view) {
			// 解除绑定的服务
			unbindService(conn);
		}
	
		private class MyConn implements ServiceConnection {
			/**
			 * 绑定服务成功会调用这个方法 让应用程序与service之间建立一个连接，就是通讯的通道
			 */
			@Override
			public void onServiceConnected(ComponentName name, IBinder service) {
				//3、在activity中绑定服务成功时得到接口类型的对象；
				myBinder = (IService) service;
	
			/**
			 * 服务的连接崩溃的时候调用这方方法
			 */
			@Override
			public void onServiceDisconnected(ComponentName name) {
			}
		}
	}

       c.优点：1）接口的作用：对外暴露功能，隐藏实现细节

                    2）startService ：使用这种方式开启服务，可以让服务长期运行在后台

                     3）bindService：绑定服务，为了调用服务里面的业务逻辑方法

                     4）unbindservice : 解除绑定，为了不再调用服务里面业务方法

                     5）stopService：停止服务，不再使用服务对象

4.应用场景

            天气预报、股票软件，检测网络状态提交数据 

5.利用服务注册广播接收者

      使用代码注册广播接收者的目的：有些操作比较频繁的广播事件，如果使用配置文件来注册，每次在接收广播事件的时候都需要读取配置，这样比较耗时并且占用的资源比较大。如果使用代码注册广播接收者会比较省时和节省资源。

6.远程服务aidl的写法（重点）

        远程服务:在同一个设备安装的另一个应用程序，在这应用程序中有一个服务在运行。

本地服务：服务的类是写在当前应用程序里面的。

在本地的应用程序中调用另一个工程里面的服务的方法。

       aidl:Android Interface Definition Language 安卓的接口定义语言；

       aidl格式的文件都是对外开放的共享文件，可以把它拷贝到其他工程里使用；

       IPC：Inter Process communication进程间的通讯；

步骤：

        1、在远程工程里面添加一个接口,里面写一个方法，对外开放的方法：

2、让中间人实现这个接口，为了让中间人具有接口的角色（类型），中间人需要实现接口里面的方法：

修改IService接口的扩展名为aidl,为了写一个对外开放的共享文件，让中间人继承Stub;

3、在本地应用程序的activity中绑定服务成功时得到接口类型的对象：

在本地工程中创建了一个与远程服务工程一样的包，把aidl文件拷贝到这个包里；

4、在本地应用程序activity中绑定服务成功时得到IService接口类型的中间人对象：

      

远程服务：
	
	package com.itheima.remoteservice;
	
	import android.app.Service;
	import android.content.Intent;
	import android.os.IBinder;
	
	import com.itheima.remoteservice.IService.Stub;
	
	public class TestService extends Service {
	
		@Override
		public IBinder onBind(Intent intent) {
			return new MyBinder();
		}
		
		
		public void methodInService(){
			System.out.println("----------methodInService----------");
		}
		
		
		private class MyBinder extends Stub{
	
			/**
			 * 实现接口中的方法
			 */
			@Override
			public void callMethodInService() {
				//调用了服务的业务逻辑方法
				methodInService();
			}
		}
	
	}

本地应用程序代码：
	
	package com.itheima.localapp;
	
	import android.app.Activity;
	import android.content.ComponentName;
	import android.content.Intent;
	import android.content.ServiceConnection;
	import android.os.Bundle;
	import android.os.IBinder;
	import android.os.RemoteException;
	import android.view.View;
	
	import com.itheima.remoteservice.IService;
	import com.itheima.remoteservice.IService.Stub;
	
	public class MainActivity extends Activity {
	
		private Intent intent;
		private MyConn conn;
		
		private IService myBinder;
	
		@Override
		protected void onCreate(Bundle savedInstanceState) {
			super.onCreate(savedInstanceState);
			setContentView(R.layout.activity_main);
		}
	
		public void start(View view) {
	
			intent = new Intent();
			intent.setAction("com.itheima.remoteservice.REMOTESERVICE");
			startService(intent);
		}
	
		public void bind(View view) {
	
			conn = new MyConn();
			bindService(intent, conn, BIND_AUTO_CREATE);
		}
		
		public void unbind(View view) {
	
			unbindService(conn);
		}
		
		
		public void stop(View view) {
	
			stopService(intent);
		}
		
		public void call(View view){
			try {
			//调用接口的方法，间接地调用服务的业务逻辑方法
				myBinder.callMethodInService();
			} catch (RemoteException e) {
				e.printStackTrace();
			}
		}
		
		private class MyConn implements ServiceConnection{
	
			@Override
			public void onServiceConnected(ComponentName name, IBinder service) {
				//得到IService接口类型的对象
				myBinder = Stub.asInterface(service);
			}
	
			@Override
			public void onServiceDisconnected(ComponentName name) {
				// TODO Auto-generated method stub
			}
		}
	}

拓展：

         1.服务和进程优先级：

              服务：是一个没有界面，可以长期运行在后台的应用程序（没有界面的Activity）

              进程：运行应用程序的载体。当应用程序一起动，Android操作系统就提供一个linux进程，进程是负责未付davilk虚拟机，而我们开发的应用程序试运行在davik虚拟机上的

                    进程特点：应用程序启动时常见了进程

                                    应用程序退出时，进程并没有退出

                                    手工结束进程；当可以用内存空间不足门系统会自动清理没有用到的进程

                     进程优先级：Foreground process（前台进程）>Visible process（可视进程）>Service process  （服务进程）                                          >Background process（后台进程）>Empty process （空进程）

               应用程序：包含了四大组件中任何一个组件的程序