android（37）（绑定远程服务）

1.绑定服务：
（1）<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>
（2).
/**
 * 中间人的接口定义
 *
 */
public interface IMiddlePerson {
    /**
     * 代办暂住证
     * @param money
     */
    public void callMethodInService(int money);
}
(3)
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("陪领导打麻将。");
        }
    }
}
(4).
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) {

        }
    }
}
2.远程服务：
（1）aidl文件：
 interface IMiddlePerson {
    /**
     * 调用服务里面的方法
     */
     void callMethodInService();
}
文件名为：IMiddlePerson.aidl
（2）远程服务：
public class RemoteService extends Service {//remote：远程

    @Override
    public void onCreate() {
        System.out.println("远程服务被创建了。。。");
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        System.out.println("远程服务被销毁了。");
        super.onDestroy();
    }

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



    //1.创建一个中间人  远程服务继承的是ipc的一个实现类
    private class MiddlePerson extends IMiddlePerson.Stub{
        @Override
        public void callMethodInService() {
            methodInService();
        }

    }
    private void methodInService(){
        System.out.println("我是远程服务的方法，我被调用了。。。。");
    }

}
3.绑定远程服务：
 interface IMiddlePerson {
    /**
     * 调用服务里面的方法
     */
     void callMethodInService();
}
文件名：IMiddlePerson.aidl
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.itheima.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();
    }
}