将高级service开发简单化

最新推荐文章于 2023-03-05 16:20:46 发布

一代小强

最新推荐文章于 2023-03-05 16:20:46 发布

阅读量542

点赞数 1

分类专栏： android 文章标签： service android开发

本文链接：https://blog.csdn.net/to_perfect/article/details/76222944

版权

android 专栏收录该内容

27 篇文章 4 订阅

订阅专栏

作为Android四大组件之一，各位大咖已经将service的外衣扒得体无完肤了，但是为什么还要来炒冷饭呢？这是十大未解之谜之一。我不管，看完本篇博文，你将学会以下内容（敲黑板！！！！）且看：

摘要

service即服务，隐形的，不可见的。为什么Google会把service作为四大组件之一呢？看看我国的四大产业架构，再看看Android的架构，你就会明白，服务业是必不可少的一大产业，它与人们的生活息息相关。没有服务，你找谁做饭（别说有女票，有女票也得自己做

），你怎么出行？（好吧，身为程序员，我编不下去了~~），总之，service是灰常重要滴！！！！！有了service你可以边玩游戏边听歌，还能下载电影，不瞎扯，上干（gou）粮！！

一、service 的生命周期

service的生命周期很简单，就那么几个常用的：onCreate、onStartCommand,onBind、onUnbind、onDestroy，是不是很简单？在oncreate方法里面完成任务的初始化工作，在onBind获取整个service的实例（稍后讲解），在unBind方法将service解除绑定，在onDestroy方法里面将资源回收，完美！（额外再说一下，oncreate方法只在service没启动的时候走,onstartCommand是每一次startService都会调用，onBind只会在没有绑定的时候调用，同理onUnBind也只会调用一次，再次调用会报没有注册service的错， OnDestroy也只会走一次），如图，其中MyService是我们的service，ServiceView是一个activity

如果是直接绑定一个service，其生命周期为onCreate(),onBind(),unBind(),onDestroy()，与直接启动service还是有点区别的，直接绑定一个service，默认不走onStartCommand()方法的，并且在解除绑定时候，service直接被destroy掉，不需要我们额外的stopService。

至于service能不能执行耗时操作，我就上一张图好了，显然service与宿主activity是同一个thread

二、service的启动

启动service与启动一个activity是一样一样的只要两行（其实一行就就可以启动）代码：

        Intent serviceInt = new Intent(this, MyService.class);
        startService(serviceInt);

关闭service只要一行代码，不能再少了，除非砸手机

        stopService(serviceInt);

当然，上面的做法是不负责任的表现，就像女票一样，追到手了不能不管他呀！你还需要管理他的事务，与他沟通，说白了就是要与service成为同一条船上的蚂蚱。于是就有下面的操作：

        Intent serviceInt = new Intent(this, MyService.class);
        bindService(serviceInt, connet, Service.BIND_AUTO_CREATE);

将当前activity与service绑定在一起，他们就在一起了。该bindService方法中第一个参数就是一个Intent，与上面一致，第二个是一个ServiceConnection接口，我们通过该接口获取service的实例，第三个就是启动的标志，我们常说的，某某某在此立下flag，启动不了service誓不罢休。当service启动成功了，就会回调我们传进去的接口，来看看怎么实现这个接口

    private MyService myService;
    private ServiceConnection connet = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            myService = ((MyService.LocalBinder) service).getService();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    };

现在大家能想象MyService长什么样么？估计泥萌猜出来了，对，就是这样

public class MyService extends Service {
    private final IBinder mBinder = new LocalBinder();

    @Override
    public void onCreate() {
        super.onCreate();
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
    @Override
        public void onDestroy() {
        super.onDestroy();
 
    }

    public class LocalBinder extends Binder {
       public MyService getService() {
           Log.i(TAG, "getService: ");
            return MyService.this;
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

   
    @Override
    public boolean onUnbind(Intent intent) {
        return super.onUnbind(intent);
    }

    @Override
    public void sendBroadcast(Intent intent) {
        super.sendBroadcast(intent);

    }

    @Override
    public boolean stopService(Intent name) {
        return super.stopService(name);
    }
}

我们重写了onBind方法并返回Binder的子类LocalBinder，我们可以在activity通过这个子类来获取service的实例，然后我们想让service干嘛就干嘛了~~比如让它自取灭亡

            myService.stopService(serviceInt);

就看你怎么玩了~~

三、activity与service通信之一（Binder）

获取binder如上，不再赘述，上面我们通过重写Binder获取service的实例，然后activity就可以通过该实例与service进行通信了，那么，service怎么与activity通信呢？很简单，就按照常见的手法——接口，我们就定义一个接口获得service启动后的生命周期，定义如下

public interface ServiceLiftCycle {
    void onCreate();
    void onStartCommand();
    void onBind();
    void unBind();
    void onDestory();
    void onStopService();
}

修改一下service

public class MyService extends Service {

    private final IBinder mBinder = new LocalBinder();
    public ServiceLiftCycle myServiceLiftCycle ;
    public void setServiceLiftCycle(ServiceLiftCycle listener){
        this.myServiceLiftCycle = listener;
    }
 
    @Override
    public void onCreate() {
        super.onCreate();
        if(myServiceLiftCycle != null)
            myServiceLiftCycle.onCreate();
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (myServiceLiftCycle != null)
            myServiceLiftCycle.onStartCommand();
        return super.onStartCommand(intent, flags, startId);

    }

    @Override
        public void onDestroy() {
        super.onDestroy();
        if (myServiceLiftCycle != null)
            myServiceLiftCycle.onDestory();
    }

    public class LocalBinder extends Binder {
       public MyService getService() {
            return MyService.this;
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }


    @Override
    public boolean onUnbind(Intent intent) {
        if (myServiceLiftCycle != null)
            myServiceLiftCycle.unBind();
        return super.onUnbind(intent);
    }

    @Override
    public void sendBroadcast(Intent intent) {
        super.sendBroadcast(intent);
    }

    @Override
    public boolean stopService(Intent name) {
        if (myServiceLiftCycle != null)
            myServiceLiftCycle.onStopService();
        return super.stopService(name);
    }
}

实现ServiceLiftCycle 接口

    private class MyServiceLiftCycle implements ServiceLiftCycle {

        @Override
        public void onCreate() {
            Log.i(TAG, "onCreate:-------------- ");
        }

        @Override
        public void onStartCommand() {
            Log.i(TAG, "onStartCommand: --------------");
        }

        @Override
        public void onBind() {
            Log.i(TAG, "onBind: --------------");
        }

        @Override
        public void unBind() {
            Log.i(TAG, "unBind: --------------");
        }

        @Override
        public void onDestory() {
            Log.i(TAG, "onDestory: --------------");
        }

        @Override
        public void onStopService() {
            Log.i(TAG, "onStopService: --------------");
        }
    }

ServiceConnection修改如下

    private MyService myService;
    private ServiceConnection connet = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            myService = ((MyService.LocalBinder) service).getService();
            myService.setServiceLiftCycle(new MyServiceLiftCycle());
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            unbind = true;
        }
    };

这样就可以在activity里面监听到service的生命周期了，当然，是activity与service绑定后的了，毕竟在绑定前myServiceLiftCycle为null的，这里只是提供一个思路，怎么玩就看各位看官了，总之，binder加上接口就可以实现一般业务的需求。什么？对binder不了解？没事，广播总有了解吧？四大组件之二！！！

四、activity与service的通信之二（broadcast）

身为四大猛将之一，大家对这个包租婆（高音喇叭）应该有了解。如有不了解的，请出去左拐，看看其他大神的巨作~~我们重新创建一个service

public class BroadCastService extends Service{
    private String TAG = "BroadCastService";
    public static final String  SERVICE_INTENTFILTER = "com.android.broadcastService.intentFilter.";

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i(TAG, "onCreate: ");
        IntentFilter filter  = new IntentFilter ();
        filter.addAction(SERVICE_INTENTFILTER);
        registerReceiver(MyReceiver ,filter);
    }
    boolean isSend = false;
    BroadcastReceiver  MyReceiver =  new  BroadcastReceiver(){

        @Override
        public void onReceive(Context context, Intent intent) {
                Log.i(TAG, "onReceive: 我收到来自activity那个傻蛋的消息了");
                Intent intent1 = new Intent(ACTIIVTY_INTENTFILTER);
                sendBroadcast(intent1);
                Log.i(TAG, "onReceive: 我转发消息给activity了");
        }
    };
    @Override
    public void onDestroy() {
        super.onDestroy();
        unregisterReceiver(MyReceiver);
    }
    
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

}

在activity加如下代码

    public static final String  ACTIIVTY_INTENTFILTER = "com.android.broadcastActivity.intentFilter.";

    public void service(View view) {
        Log.i(TAG, "service: ");
       Intent serviceInt = new Intent(this, BroadCastService.class);
        startService(serviceInt);
        IntentFilter filter  = new IntentFilter ();
        filter.addAction(ACTIIVTY_INTENTFILTER);
        registerReceiver(receiver ,filter);

    }
    activityReceiver receiver = new activityReceiver();

   class activityReceiver extends  BroadcastReceiver{

        @Override
        public void onReceive(Context context, Intent intent) {
            Log.i(TAG, "onReceive: 我收到service发来的消息了");
        }
    };

    public void send(View view) {
        Intent intent1 = new Intent(SERVICE_INTENTFILTER);
        sendBroadcast(intent1);
        Log.i(TAG, "service: 我发消息给service了");
}

结果如下

五、activity与service的通信之三（messenger）

有些时候需要在service中执行繁重的任务，如果直接在应用所在的进程创建，容易导致crash，这时候我们为service创建新的进程，在配置文件上修改如下：

       <service android:name=".service.MessengerService"
            android:process=":MessengerService"/>

这个时候activity与service之间的通信再用第一种方式显然不行，毕竟跨进程了。用上面的广播可以实现跨进程通信，但有些时候并不希望其他应用也能截获广播，这时候可以考虑使用messenger来实现activity与service的通信问题

我们创建新的service对象：

public class MessengerService extends Service{
    private String TAG = "MessengerService ";
    public int mValue = 0;

    public static final int MSG_REGISTER_CLIENT = 1;

    public static final int MSG_UNREGISTER_CLIENT = 2;

    public static final int MSG_SET_VALUE = 3;

    public ArrayList<Messenger> mClients = new ArrayList<Messenger>();

    class mServiceHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_REGISTER_CLIENT:
                    Log.i(TAG, "handleMessage: 我收到了  MSG_REGISTER_CLIENT");
                    mClients.add(msg.replyTo);
                    break;
                case MSG_UNREGISTER_CLIENT:
                    mClients.remove(msg.replyTo);
                    break;
                case MSG_SET_VALUE:
                    Log.i(TAG, "handleMessage: 我收到了  MSG_SET_VALUE ");
                    mValue = msg.arg1;
                    for (int i=mClients.size()-1; i>=0; i--) {
                        try {
                            mClients.get(i).send(Message.obtain(null,
                                    MSG_SET_VALUE, mValue, 0));
                        } catch (RemoteException e) {
                            mClients.remove(i);
                        }
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    final Messenger mServiceMessenger = new Messenger(new mServiceHandler());


    @Override
    public void onCreate() {
        super.onCreate();
    }
    @Override
    public void onStart(Intent intent, int startId) {
        super.onStart(intent, startId);
    }


    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }



    @Override
    public void onDestroy() {
        super.onDestroy();
        Toast.makeText(this, R.string.cancel  , Toast.LENGTH_SHORT).show();

    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mServiceMessenger.getBinder();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        return super.onUnbind(intent);
    }
}

修改activity的内容

    boolean mIsBound = false;
    Messenger mServiceMes = null;
        class mClientHandler extends Handler {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case MessengerService.MSG_SET_VALUE:
                        Log.i(TAG, "handleMessage: 我收到来自遥远的service端的消息了");
                        break;
                    default:
                        super.handleMessage(msg);
                }
            }
        }
    final Messenger mClientMessenger = new Messenger(new mClientHandler());

    private ServiceConnection mMesConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className,
                                       IBinder service) {
            mIsBound =  true;
            Messenger  mServiceMes = new Messenger(service);//获取MessengerService 里面的Messenger
            try {
                Message msg = Message.obtain(null,
                        MessengerService.MSG_REGISTER_CLIENT);
                msg.replyTo = mClientMessenger;
                mServiceMes.send(msg);
                 msg = Message.obtain(null,
                        MessengerService.MSG_SET_VALUE, this.hashCode(), 0);
                mServiceMes.send(msg);
            } catch (RemoteException e) {
            }
            Toast.makeText(ServiceView.this, "远程service已经连接上",
                    Toast.LENGTH_SHORT).show();
        }

        public void onServiceDisconnected(ComponentName className) {
            Log.i(TAG, "onServiceDisconnected: MessengerService");
            mServiceMes = null;
            Toast.makeText(ServiceView.this, "断开连接",
                    Toast.LENGTH_SHORT).show();
        }
    };

    public void bindMesService(View view){
        bindService(new Intent(ServiceView.this,
                MessengerService.class), mMesConnection, Context.BIND_AUTO_CREATE);
    }

MessengerService端收到的消息

actiivty端收到的消息

这里面涉及到三个知识：messenger，message，handler。messenger充当信息员，负责实现跨进程通信，即把message从本地进程携带到远程进程，message就是一个信封，里面包含了通信的信息，handler就是收信人，读取从messenger邮寄过来的message

先说client端（activity端）

在接口ServiceConnection的onServiceConnected方法里面我们拿到了远程的IBinder对象（准确的说IBinder是一个接口，将所有跨进程通信类都抽象出来了），我们通过IBinder对象获取到远程service端的messenger
这样。我们就可以通过这个messenger对象向远程service 发消息了。首先，我们在client端拿到messenger

   public void onServiceConnected(ComponentName className,
                                       IBinder service) {
            Messenger  mServiceMes = new Messenger(service);//获取MessengerService 里面的Messenger
            
}

然后构建一个message对象，让mServiceMes 对象将message发送给service端

    Message msg = Message.obtain(null,
                        MessengerService.MSG_REGISTER_CLIENT);
                mServiceMes.send(msg);

各位看官不免会有疑问，系统怎么知道mServiceMes发送message到哪里呢？且慢，喝口茶。

接着来

把刚刚的问题放一边。
在service端，我们先创建一个handler，即收件人，与我们平常创建的handler大同小异

    class mServiceHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_REGISTER_CLIENT:
                    Log.i(TAG, "handleMessage: 我收到了  MSG_REGISTER_CLIENT");
                    mClients.add(msg.replyTo);
                    break;
            }
        }
    }

然后我们通过这个handler来唯一创建一个mServiceMessenger ，表明该mServiceMessenger发送的所有消息，都会由该handler来处理，这下问题明了了

    final Messenger mServiceMessenger = new Messenger(new mServiceHandler());

接着，我们重写service端的Onbind方法，把mMessenger的IBinder返回给client端

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mServcieMessenger.getBinder();
    }

通过上面的代码，我们就可以很顺利的拿到了service端的mMessengermServiceMessenger ，这样，我们在client端就可以通过messengermServiceMes 来给service端发消息了。

说完client端，我们再来看看service端是怎么获取到client端的messenger

细心的看官也许已经发现了，且看
同样，我们首先在client端创建一个handler对象

    class mClientHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MessengerService.MSG_SET_VALUE:
                    Log.i(TAG, "handleMessage: 我收到来自遥远的service端的消息了");
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

与service端一样，通过handler创建唯一的messenger

    final Messenger mClientMessenger = new Messenger(new mClientHandler());

这样，只要是mClientMessenger 发消息，我们的mClientHandler都可以处理（也只有他能处理），问题来了，我们在绑定service端的时候可以通过ServiceConnection回调里面的方法来获取一个Ibinder ,从而获取service端的messenger，那么service端是怎么获取client端的messenger的呢？
我们注意到下面两行代码

     Message msg = Message.obtain(null,
                        MessengerService.MSG_REGISTER_CLIENT);
                msg.replyTo = mClientMessenger;

这里，我们把在client端创建的mClientMessenger作为一个回复，返回给service端，就可以通过service端的mServiceHandler对象来拿到这个mClientMessenger，这里，我们用到ArrayList来保存client端的messenger，因为service可能对应多个client端

    public ArrayList<Messenger> mClients = new ArrayList<Messenger>();

    class mServiceHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_REGISTER_CLIENT:
                    Log.i(TAG, "handleMessage: 我收到了  MSG_REGISTER_CLIENT");
                    mClients.add(msg.replyTo);
                    break;
            }
        }
    }

这样，service端也就顺利的拿到了client端的mClientMessenger对象，这样就意味着我们也可以在service端对client端发消息了

                    mClients.get(i).send(Message.obtain(null,
                                    MSG_SET_VALUE, mValue, 0));

需要解除绑定，只需要调用该方法

            unbindService(mMesConnection);

如果service端用list维护着多个messenger，client端还需要通知service解除messenger

     Message msg = Message.obtain(null,
                            MessengerService.MSG_UNREGISTER_CLIENT);
                    msg.replyTo = mClientMessenger;
                    mServiceMes.send(msg);

service端将messenger解除即可

     case MSG_UNREGISTER_CLIENT:
                    mClients.remove(msg.replyTo);
                    break;

至此，已经顺利打通了client端与service端的跨进程通信问题，框架已经打好，至于怎么玩出花样，且看下回分解

一代小强

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录