绑定服务并调用服务的方法,解除绑定

public class MyService extends Service {
	/**
	 * 服务绑定成功之后，会返回一个中间人，这个中间人一般属于服务的内部类，
	 * 该内部类可任意调用服务的方法，因此需要创建一个中间人，由这个中间人调
	 * 用服务的方法。
	 */
	@Override
	public IBinder onBind(Intent intent) {
		System.out.println("服务成功绑定onBind");
		return new MiddlePerson();
	}

	@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("服务被销毁onDestroy");
		super.onDestroy();
	}

	@Override
	public boolean onUnbind(Intent intent) {
		System.out.println("服务被解除绑定onUnbind");
		return super.onUnbind(intent);
	}
	/**
	 * 服务里的方法
	 */
	public void methodInService(){
		Toast.makeText(this, "准生证办好了", Toast.LENGTH_SHORT).show();
	}
	/**
	 * IBinder是一个接口，其抽象方法太多，因此考虑继承一个实现了IBinder接口的类
	 * @author Administrator
	 *
	 */
	public class MiddlePerson extends Binder{
		public void callMethodInService(int money){
			if(money>50){
				methodInService();
			}else{
				Toast.makeText(MyService.this, "钱太少,办不了", Toast.LENGTH_SHORT).show();
			}
		}
	}
}

/**
 * 绑定服务的生命周期：onCreate>onBind>onUnbind>onDestroy,
 * 绑定服务不会调用服务的onStartCommand(onstart过时)方法，因此
 * 绑定服务即使创建了服务，但是服务并没有得到开启指令(没有执行onStartCommand方法)
 * 因此服务并未启动，在设置里正在运行的服务里也看不到
 * 另外，与start方式启动服务不同的时，绑定服务当服务的绑定者挂了(任务栈空了，Activity调用了onDestroy了)
 * 时，服务会执行onUnbind>onDestroy
 * @author Administrator
 *
 */
public class MainActivity extends FragmentActivity {

	private MyConn conn=null;
	private MiddlePerson mp;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
	}
	/**
	 * 绑定服务
	 */
	public void bind(View v){
		Intent intent = new Intent(this, MyService.class);
		conn = new MyConn();
		bindService(intent, conn, BIND_AUTO_CREATE);
		System.out.println("执行bindService");
	}
	/**
	 * 解除绑定
	 */
	public void unBind(View v){
		if(conn!=null){
			unbindService(conn);
			System.out.println("执行unbindService");
		}
		
	}
	/**
	 * 调用服务里的方法
	 */
	public void call(View v){
		mp.callMethodInService(80);
	}
	/**
	 * ServiceConnection监听服务的状态
	 * @author Administrator
	 *
	 */
	public class MyConn implements ServiceConnection{
		/**
		 * 当和服务建立连接，也就是找到了服务的中间人IBnder时调用该方法,service就是
		 * 与服务建立连接的中间人
		 */
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			System.out.println("与服务连接成功，得到中间人");
			mp=(MiddlePerson)service;
		}
		/**
		 * 当服务失去连接时调用的方法，例如进程被杀死,服务被异常杀死等
		 * 这里没有演示出来
		 */
		@Override
		public void onServiceDisconnected(ComponentName name) {
			System.out.println("服务失去连接了");
		}
		
	} 
	/*
	public void start(View v){
		Intent intent = new Intent(this,MyService.class);
		startService(intent);
	}
	public void stop(View v){
		Intent intent = new Intent(this,MyService.class);
		stopService(intent);
	}
	*/
}

总结:讨论同一个应用中的情况，因为在Service的外部不可以直接调用Service内部的方法，我们可以在Service的内部定义一个内部类，在这个内部类的内部调用Service中的方法，当Service的外部绑定该Service时，将这个内部类暴露给Service的外部，就实现了通过这个内部类间接访问Service中的方法了。