22_绑定的方式调用服务的方法

首先看服务的生命周期:

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

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

服务停止的时候 onDestory().

服务只会被停止一次

事例代码:

首页亲建一个MainActivity .java

public class MainActivity extends Activity {

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

    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);
    }
    
    @Override
    protected void onDestroy() {
    	System.out.println("啊啊啊，我是activity，我挂了");
    	super.onDestroy();
    }
    //调用服务里面的方法。不可以自己new服务，调用的服务的方法，必须通过框架得到服务的引用。
    public void call(View view){
    
    }
}

然后再建一个MyService.java文件

public class MyService extends Service {

	@Override
	public IBinder onBind(Intent arg0) {
		return null;
	}
	
	@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();
	}

}

上面的事件代码的工程在 day10--code--> 服务的生命周期

二、服务还有一种开启方式，绑定的方式开启服务。

onCreate() --->onBind();--->onunbind()-->onDestory();
绑定服务不会调用onstart或者onstartcommand方法；

下面的事例代码的位置在day10--.code-->绑定服务

新建一个中间键:

/**
 * 中间人的接口定义
 *
 */
public interface IMiddlePerson {
/**
* 代办暂住证
* @param money
*/
public void callMethodInService(int money);
}

第二,新建一个MyService文件

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{
/**
* 代办暂住证
* @param money 给钱 50块钱以上才给办。
*/
public void callMethodInService(int money){
if(money>=50){
methodInService();
}else{
Toast.makeText(getApplicationContext(), "多准备点钱。", 0).show();
}
}
/**
* 陪领导打麻将
*/
public void playMajiang(){
System.out.println("陪领导打麻将。");
}
}
}

第三，新建一个MainActivity.java文件

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) {

}
    }
}

第二布局文件里面main.xml文件

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity" >


    <Button
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:onClick="bind"
        android:text="绑定服务" />


    <Button
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:onClick="unbind"
        android:text="解除绑定服务" />


    <Button
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:onClick="call"
        android:text="调用服务里面的方法" />


</LinearLayout>

三、两种开启服务方法的区别。

start方式开启服务。 一旦服务开启跟调用者(开启者)就没有任何关系了。
开启者退出了，开启者挂了，服务还在后台长期的运行。
开启者没有办法去调用服务里面的方法。（美国的司法独立）

bind的方式开启服务，绑定服务，调用者挂了，服务也会跟着挂掉。不求同时生，但求同时死。
开启者可以调用服务里面的方法。