Android Service与Activity通信方式 And Service不被杀死

1.Service是Android四大组件之一，下面对Service进行一个简单的介绍，什么生命周期一些基础那些就直接跳过了

　Service的启动方式有两种：1.直接启动(startService) 2.绑定启动(bindService)。

　1)具体在什么情况下用直接启动还是用绑定启动呢？

　　如果你只是想要启动一个后台服务长期进行某项任务那么使用 startService 便可以了。如果你想要与正在运行的 Service 取得联系，那么有两种方法，一种是使用 broadcast ，另外是使用 bindService ，前者的缺点是如果交流较为频繁，容易造成性能上的问题，并且 BroadcastReceiver 本身执行代码的时间是很短的（也许执行到一半，后面的代码便不会执行），而后者则没有这些问题，因此我们肯定选择bindService（这个时候你便同时在使用 startService 和 bindService 了，这在 Activity 中更新 Service 的某些运行状态是相当有用的）。另外如果你的服务只是公开一个远程接口，供连接上的客服端（android 的 Service 是C/S架构）远程调用执行方法。这个时候你可以不让服务一开始就运行，而只用 bindService ，这样在第一次 bindService 的时候才会创建服务的实例运行它，这会节约很多系统资源，特别是如果你的服务是Remote Service，那么该效果会越明显（当然在 Service 创建的时候会花去一定时间，你应当注意到这点）。

2.Activity和Service通信方式一

　　1)采用IBinder来进行通信，IBinder是Android专门用来进程通讯的。

　　这里实现一个简单的效果，在Service中完成一个加法计算，计算完成后，将值返还给Activity进行打印。( 别忘了对Service在AndroidManifest.xml进行注册)

　　Service:(这里应该将MyBinder中的方法全部定义在接口里面，来继承接口实现)

public class MyService extends Service {

    @Override
    public IBinder onBind(Intent intent) {
        // intent获取从Activity传来的数据
        // 别忘了要返回定义binder实例， 如果返回就不能建立连接
        return new MyBinder();
    }

    public class MyBinder extends Binder {

        // 加法
        public int add(int a, int b) {
            return a + b;
        }

        public MyService getService() {
            return MyService.this;
        }

    }

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }

}

　　Activity:

public class MainActivity extends Activity {

    private MyService.MyBinder binder;
    ServiceConnection connection;

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

        connection = new ServiceConnection() {

            @Override
            public void onServiceDisconnected(ComponentName name) {

            }

            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                // 获取被绑定service中的binder
                binder = (MyService.MyBinder) service;

                System.out.println("从service返回来的数据->" + binder.add(5, 3));

            }
        };

        Intent intent = new Intent("android.intent.mysecondservice");
        bindService(intent, connection, BIND_AUTO_CREATE);

    }

}

最后打印出的结果：

　　

　　2)在Service中开启一个线程模拟网络下载，将下载量在MainActivity中动态的打印出来(这里的IAddCount 接口是为后面去掉Activity中的线程，这里占时没有用的)

　　Service：

public class MyService extends Service {
    private int count;
    private ServiceBinder binder;
    private boolean isGoOn = true;
    private IAddCount addCount;

    public interface IAddCount {
        public void showCount(int count);

    }

    @Override
    public IBinder onBind(Intent intent) {
        System.out.println("从activity传过来的数据是-->>"
                + intent.getStringExtra("data"));

        return binder;
    }

    public void setIAddCount(IAddCount addCount) {
        this.addCount = addCount;
    }

    public class ServiceBinder extends Binder {

        public int getCount() {
            return count;
        }

        public MyService getService() {
            return MyService.this;
        }

    }

    @Override
    public void onCreate() {
        super.onCreate();
        System.out.println("MyService---onCreate()");
        binder = new ServiceBinder();

        new Thread(new Runnable() {

            @Override
            public void run() {

                while (isGoOn) {
                    try {
                        Thread.sleep(1000);
                        count++;
                        if (count == 5) {
                            isGoOn = false;
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }

            }
        }).start();

    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        System.out.println("MyService---onDestroy");

    }

}

　　MainActivity：

　　

public class MainActivity extends Activity {

    private MyService.MyBinder binder;
    ServiceConnection connection;

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

        connection = new ServiceConnection() {

            @Override
            public void onServiceDisconnected(ComponentName name) {

            }

            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                // 获取被绑定service中的binder
                binder = (MyService.MyBinder) service;

                System.out.println("从service返回来的数据->" + binder.add(5, 3));

            }
        };

        Intent intent = new Intent("android.intent.mysecondservice");
        bindService(intent, connection, BIND_AUTO_CREATE);

    }

}

打印出的结果是：

　　　

3)这里在获取Service的数据的时候，是在Activity中开了一个线程与Service中的线程去对应，然后动态的去提取数据的，其实可以采用接口回调的方法来实现，不用去在开线程的

　　Service：

public class MyService extends Service {
    private int count;
    private ServiceBinder binder;
    private boolean isGoOn = true;
    private IAddCount addCount;

    public interface IAddCount {
        public void showCount(int count);

    }

    @Override
    public IBinder onBind(Intent intent) {
        System.out.println("从activity传过来的数据是-->>"
                + intent.getStringExtra("data"));

        return binder;
    }

    public void setIAddCount(IAddCount addCount) {
        this.addCount = addCount;
    }

    public class ServiceBinder extends Binder {

        public int getCount() {
            return count;
        }

        public MyService getService() {
            return MyService.this;
        }

    }

    @Override
    public void onCreate() {
        super.onCreate();
        System.out.println("MyService---onCreate()");
        binder = new ServiceBinder();

        new Thread(new Runnable() {

            @Override
            public void run() {

                while (isGoOn) {
                    try {
                        Thread.sleep(1000);
                        count++;
                        if (count == 5) {
                            isGoOn = false;
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }

            }
        }).start();

    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        System.out.println("MyService---onDestroy");

    }

}

 

　　MainActivity：

　　

public class SecondActivity extends Activity implements OnClickListener {

    private Button btn;
    private int count;
    MyService.ServiceBinder binder;
    private boolean isBack = true;
    private MyService myService;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        btn = (Button) findViewById(R.id.btn222);
        btn.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {

        switch (v.getId()) {
        case R.id.btn222:

            Intent intent = new Intent("android.intent.myservice");
            intent.putExtra("data", "我是从activity传过来的数据");
            ServiceConnection sercon = new ServiceConnection() {

                @Override
                public void onServiceDisconnected(ComponentName name) {

                }

                @Override
                public void onServiceConnected(ComponentName name,
                        IBinder service) {
                    binder = (MyService.ServiceBinder) service;
                    myService = binder.getService();
                    // 实例化接口
                    myService.setIAddCount(new IAddCount() {
                        // ************************************//
                        // 接口回调
                        @Override
                        public void showCount(int count) {
                            System.out.println("接口回调返回的数据是-->>" + count);
                        }
                    });
                }
            };
            bindService(intent, sercon, BIND_AUTO_CREATE);
            System.out.println("输出的数据是-->>" + count);

            // new Thread() {
            // @Override
            // public void run() {
            // try {
            // while (isBack) {
            // Thread.sleep(1000);
            // count = binder.getCount();
            // if (count == 5) {
            // isBack = false;
            // }
            //
            // Message msg = myHandler.obtainMessage();
            // msg.arg1 = count;
            // myHandler.sendMessage(msg);
            // }
            //
            // } catch (InterruptedException e) {
            // e.printStackTrace();
            // }
            //
            // }
            //
            // }.start();

            break;
        }

    }

    Handler myHandler = new Handler() {
        public void handleMessage(android.os.Message msg) {

            System.out.println("在activity中获取到的数据是->" + msg.arg1);

        };

    };

}

运行后的效果和上图一样的

　　4)通过broadcast(广播)的形式

　　　在Activity中动态注册一个广播接收器,然后service将数据广播给Activity中的接收器即可

　　

public class MainActivity extends Activity {  
    private ProgressBar mProgressBar;  
    private Intent mIntent;  
    private MsgReceiver msgReceiver;  
      
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
          
        //动态注册广播接收器  
        msgReceiver = new MsgReceiver();  
        IntentFilter intentFilter = new IntentFilter();  
        intentFilter.addAction("com.example.communication.RECEIVER");  
        registerReceiver(msgReceiver, intentFilter);  
          
          
        mProgressBar = (ProgressBar) findViewById(R.id.progressBar1);  
        Button mButton = (Button) findViewById(R.id.button1);  
        mButton.setOnClickListener(new OnClickListener() {  
              
            @Override  
            public void onClick(View v) {  
                //启动服务  
                mIntent = new Intent("com.example.communication.MSG_ACTION");  
                startService(mIntent);  
            }  
        });  
          
    }  
  
      
    @Override  
    protected void onDestroy() {  
        //停止服务  
        stopService(mIntent);  
        //注销广播  
        unregisterReceiver(msgReceiver);  
        super.onDestroy();  
    }  
  
  
    /** 
     * 广播接收器 
     * @author len 
     * 
     */  
    public class MsgReceiver extends BroadcastReceiver{  
  
        @Override  
        public void onReceive(Context context, Intent intent) {  
            //拿到进度，更新UI  
            int progress = intent.getIntExtra("progress", 0);  
            mProgressBar.setProgress(progress);  
        }  
          
    }  
  
}  

 

　　Service　：

　　

public class MsgService extends Service {  
    /** 
     * 进度条的最大值 
     */  
    public static final int MAX_PROGRESS = 100;  
    /** 
     * 进度条的进度值 
     */  
    private int progress = 0;  
      
    private Intent intent = new Intent("com.example.communication.RECEIVER");  
      
  
    /** 
     * 模拟下载任务，每秒钟更新一次 
     */  
    public void startDownLoad(){  
        new Thread(new Runnable() {  
              
            @Override  
            public void run() {  
                while(progress < MAX_PROGRESS){  
                    progress += 5;  
                      
                    //发送Action为com.example.communication.RECEIVER的广播  
                    intent.putExtra("progress", progress);  
                    sendBroadcast(intent);  
                      
                    try {  
                        Thread.sleep(1000);  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                      
                }  
            }  
        }).start();  
    }  
  
      
  
    @Override  
    public int onStartCommand(Intent intent, int flags, int startId) {  
        startDownLoad();  
        return super.onStartCommand(intent, flags, startId);  
    }  
  
  
  
    @Override  
    public IBinder onBind(Intent intent) {  
        return null;  
    }  

 

 

Activity调用 bindService (Intent service, ServiceConnection conn, int flags)方法，得到Service对象的一个引用，这样Activity可以直接调用到Service中的方法，如果要主动通知Activity，我 们可以利用回调方法

 Service向Activity发送消息，可以使用广播，当然Activity要注册相应的接收器。比如Service要向多个Activity发送同样的消息的话，用这种方法就更好

　　

参考地址：http://blog.csdn.net/xiaanming/article/details/9750689

　　　　http://blog.csdn.net/zhouyongyang621/article/details/5861495

 

关于怎样让服务不被杀死

  这个倒是有点流氓软件的意思，但有些特定情况还是需要服务能保持开启不被杀死，当然这样做我还是在程序里添加了关闭服务的按钮，也就是开启了就杀不死，除非在软件里关闭。

服务不被杀死分3种来讨论
1.系统根据资源分配情况杀死服务
2.用户通过settings->Apps->Running->Stop方式杀死服务
3.用户通过settings->Apps->Downloaded->Force Stop方式杀死服务

第一种情况：
  用户不干预，完全靠系统来控制，办法有很多。比如onStartCommand()方法的返回值设为START_STICKY，服务就会在资源紧张的时候被杀掉，然后在资源足够的时候再恢复。当然也可设置为前台服务，使其有高的优先级，在资源紧张的时候也不会被杀掉。

第二种情况：
  用户干预，主动杀掉运行中的服务。这个过程杀死服务会通过服务的生命周期，也就是会调用onDestory()方法，这时候一个方案就是在onDestory()中发送广播开启自己。这样杀死服务后会立即启动。如下：

@Override
public void onCreate() {
    // TODO Auto-generated method stub
    super.onCreate();

    mBR = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            // TODO Auto-generated method stub
            Intent a = new Intent(ServiceA.this, ServiceA.class);
            startService(a);
        }
    };
    mIF = new IntentFilter();
    mIF.addAction("listener");
    registerReceiver(mBR, mIF);
}

@Override
public void onDestroy() {
    // TODO Auto-generated method stub
    super.onDestroy();

    Intent intent = new Intent();
    intent.setAction("listener");
    sendBroadcast(intent);

    unregisterReceiver(mBR);
}

当然，从理论上来讲这个方案是可行的，实验一下也可以。但有些情况下，发送的广播在消息队列中排的靠后，就有可能服务还没接收到广播就销毁了(这是 我对实验结果的猜想，具体执行步骤暂时还不了解)。所以为了能让这个机制完美运行，可以开启两个服务，相互监听，相互启动。服务A监听B的广播来启动B， 服务B监听A的广播来启动A。经过实验，这个方案可行，并且用360杀掉后几秒后服务也还是能自启的。到这里再说一句，如果不是某些功能需要的服务，不建 议这么做，会降低用户体验。

第三种情况：
  强制关闭就没有办法。这个好像是从包的level去关的，并不走完整的生命周期。所以在服务里加代码是无法被调用的。处理这个情况的唯一方法是屏蔽掉force stop和uninstall按钮，让其不可用。方法自己去找吧。当然有些手机自带的清理功能就是从这个地方清理的，比如华为的清理。所以第三种情况我也没有什么更好的办法了。