欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Android中Service的使用方法

程序员文章站 2022-07-15 12:00:11
...

 

目录

  • Service 介绍
  • Service两种启动方式
  • 使用
  • 测试
  • IntentService
  • Activity与Service之间的通信
  • 继承Binder类
  • Messenger
  • AIDL

Service 介绍

A Service is an application component that can perform long-running operations in the background and does not provide a user interface. Another application component can start a service and it will continue to run in the background even if the user switches to another application. Additionally, a component can bind to a service to interact with it and even perform interprocess communication (IPC). For example, a service might handle network transactions, play music, perform file I/O, or interact with a content provider, all from the background.

Service是一个没有用户界面的应用程序组件,可以在后台长时间运行。另外一个应用程序组件可以启动一个Service,它可以在用户切换到其他应用的时候依旧保持在后台运行。另外,一个组件可以绑定到Service上,与它进行通信,甚至是IPC(进程间通信)。

Service两种启动方式

  • startService
  • bindService
    其生命周期官方API介绍:

     

    Android中Service的使用方法

    Paste_Image.png

     

    需要注意的点:
    1.通过startService启动的Service,只有调用了stopService(外部组件调用)或stopSelf(Service内部自己调用),才会停止。
    2.通过startService启动的Service,在Service运行中无法与Service进行交互,即外部组件只能控制其开关,无法进行交互。
    3.通过startService启动的Service,与外部组件之间没有关系,外部组件的生死跟它没有联系。
    3.通过startService启动的Service,启动之后重复启动的话不会触发onCreate方法,但是会重复触发onStartCommand,其实貌似也算是数据交流了吧,不过是单向的。
    4.bindService启动的Service表示将一个Service绑定到一个组件上,其生命周期与该组件的生命周期绑定在一起,比如绑到一个Activity,Activity在Destroy后Service跟着就Destroy了。
    4.注意是不能绑定广播的,因为广播发完了其生命就到头了,常用的是绑Activity,还可以是Service。
    5.bindService启动的Service在使用完之后可以解除绑定,当一个Service上的所有绑定的组件都解绑之后,它就会被销毁。
    6.可以同时使用两种启动方式,此时的生命周期就变的有些复杂了,两种关联到一起,总结来说的话,先startService与先bindService两种方式达到的效果是一样的,即此时unbindService的话,Service并不会结束,而是要等到stopService才会结束(onDestroy);若是此时stopService,也不会结束,而是要等到unbindService时才会结束(由于已经调用过stopService,此时会直接onDestroy)。
    7.onRebind调用时机:

     

    Android中Service的使用方法

    Paste_Image.png


    当旧client与service之间的关联在onUnbind中都结束之后,新client绑定时,
    必须是onUnbind返回true,且服务在解绑之后没有销毁

使用

  • startService
    创建类继承Service,在启动组件中调用:

     Intent intent1 = new Intent(ServiceActivity1.this, MyService1.class);
     startService(intent1);
    

停止方法同上

  • bindService
    1.创建类继承Service,其中默认会有一个onBind方法,返回是一个IBinder类型对象,这个返回值就是与组件之间通信的关键。可以通过自定义内部类继承Binder,在这个类中返回Service,然后在组件中通过返回的IBinder类型对象获取到Service对象从而进行操作;
    2.在组件中新建一个ServiceConnection对象,必须重写两个方法,onServiceConnected(建立连接(bind_service)时调用)、onServiceDisconnected(一般都不调用,除非是意外情况,unbind_service并不调用这个),在onServiceConnected中获取到Service对象进行操作。
    MyService:

     public class MyService1 extends Service {
    
         @Override
         public void onCreate() {
             super.onCreate();
             Log.i("test_out","----->onCreate");
         }
    
         @Override
         public int onStartCommand(Intent intent, int flags, int startId) {
             Log.i("test_out","----->onStartCommand");
             return super.onStartCommand(intent, flags, startId);
         }
    
         @Override
         public void onDestroy() {
             super.onDestroy();
             Log.i("test_out","----->onDestroy");
         }
    
         public class MyBinder extends Binder {
             public MyService1 getService(){
                 return MyService1.this;
             }
         }
    
         private MyBinder mBinder = new MyBinder();
    
         @Override
         public IBinder onBind(Intent intent) {
             Log.i("test_out","----->onBind");
             return mBinder;
         }
    
         @Override
         public boolean onUnbind(Intent intent) {
    
             Log.i("test_out","----->onUnbind");
             return true;
         }
    
         @Override
         public void onRebind(Intent intent) {
             super.onRebind(intent);
             Log.i("test_out","----->onRebind");
         }
    
         public int getCount(){
             return (int) (Math.random() * 10);
         }
    
     }
    

在Activity中建立连接:
ServiceConnection serviceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mService = ((MyService1.MyBinder)service).getService();
textView.setText("" + mService.getCount());
}

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.i("test_out","----->onServiceDisconnected");
        }
    };

启动与停止:

    bindService(intent3, serviceConnection, Service.BIND_AUTO_CREATE);

第一个参数是intent,第二个是上面的serviceConnection,第三个表示绑定方式,Service.BIND_AUTO_CREATE表示绑定时不存在的话就自动创建。
解绑:unbindService(serviceConnection);

测试

startService -> stopService

Android中Service的使用方法

Paste_Image.png


startService -> startService -> startService -> stopService

Android中Service的使用方法

Paste_Image.png


果然重复start会调用onStartCommand,那么就相当于可以发指令。
bindService -> unbindService

Android中Service的使用方法

Paste_Image.png


bindService -> 按下返回键

Android中Service的使用方法

Paste_Image.png


startService -> bindService -> unbindService

Android中Service的使用方法

Paste_Image.png


startService -> bindService -> unbindService -> bindService -> unbindService

Android中Service的使用方法

Paste_Image.png


startService -> bindService -> stopService

Android中Service的使用方法

Paste_Image.png


此时unbindService :

Android中Service的使用方法

Paste_Image.png

 

IntentService

Android封装好的Service,在其中的onHandleIntent(Intent intent)中处理需要在子线程中处理的逻辑,在处理完毕后,会自动onDestroy。

Activity与Service之间的通信

一般来讲,我们将绑定到Service上的组件称为客户端,Service称为服务端,他们之间的通信可以在同一个进程,也可以在不同的进程。
要进行通信,那个前面已经提到,就要在客户端获取到一个IBinder对象,而获取这个对象的方式有三种:
继承Binder类,使用Messenger类,使用AIDL
第一种上面已经用过了,不过这种方式是适用于同进程内通信,因为不同的进程使用的是不同的内存区域。

Messenger

其实现是通过Message以及Handler来进行通信,Handler应该都有所了解,一般使用最多的都是用来解决非UI线程更新UI的问题,Handler机制有待仔细研究一下,后面写一篇。
其实其底层实现也是通过AIDL。
服务端(Service):
基本流程跟上面的继承Binder类的方式差不多,如下:
首先创建一个Service,在其中实现一个Handler,用于接受消息。
然后通过Handler创建一个Messenger实例,在onBind中返回Messager实例的Binder。

public class MyService2 extends Service {

    class ServiceHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            if(msg.what == 1){
                Log.i("test_out","------>receive data from client!");
            }
        }
    }

    final Messenger messager = new Messenger(new ServiceHandler());

    @Override
    public IBinder onBind(Intent intent) {
        Log.i("test_out","----->onBind");
        return messager.getBinder();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.i("test_out","----->onUnbind");
        return true;
    }

}

客户端:
通过serviceConnection中的onServiceConnected获取到服务端传来的Binder对象,实例化Client端的Messenger。
创建Message,通过Messager发送消息。

ServiceConnection serviceConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        mMessager = new Messenger(service);
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
        Log.i("test_out","----->onServiceDisconnected");
    }
};

public void sendToMyService(){
    Message msg = new Message();
    msg.what = 1;
    try {
        mMessager.send(msg);
    } catch (RemoteException e) {
        e.printStackTrace();
    }
}

@Override
protected void onStart() {
    super.onStart();
    Intent intent = new Intent();
    intent.setAction("com.gsq.service2");
    intent.setClassName("com.example.gsq.servicetest", "com.example.gsq.servicetest.service.MyService2");
    bindService(intent, serviceConnection, BIND_AUTO_CREATE);
}

@Override
protected void onStop() {
    super.onStop();
    unbindService(serviceConnection);
}

对了,这里我的客户端是另外一个APK,验证进程间通信,那么就要在Service注册的时候指定其action,在Intent跳转的时候设置完整包名和action,这个在前面学习Intent中有介绍的。

    <service android:name=".service.MyService2"
        android:exported="true"
        android:permission="com.gsq.permission.service2">
        <intent-filter>
            <action android:name="com.gsq.service2" />
            <category android:name="android.intent.category.DEFAULT" />
        </intent-filter>
    </service>

注意,这里写了android:exported之后,AS会提示你:

Exported services (services which either set exported=true or contain an intent-filter and do not specify exported=false) should define a permission that an entity must have in order to launch the service or bind to it. Without this, any application can use this service.

大意就是,最好是加一个权限,android:permission。
自定义权限过程:在被调用的应用中先定义

<permission
    android:name="com.gsq.permission.service2"
    android:protectionLevel="normal">
</permission>

然后使用,android:permission="com.gsq.permission.service2
然后在调用者(客户端)声明:

<uses-permission android:name="com.gsq.permission.service2" />

坑:自定义权限名称一定要是 *.permission.*
好了,这样子Messenger的使用流程就说完了,下面就可以看一下结果了。
启动第二个应用:

Android中Service的使用方法

Paste_Image.png


点击button:

Android中Service的使用方法

Paste_Image.png


OK ! 大功告成!
再点一下:

Android中Service的使用方法

Paste_Image.png


关闭:

Android中Service的使用方法

Paste_Image.png


上面就实现了客户端向服务端发送消息。
下面就来实现一下服务端在受到消息之后给一个response。
流程跟上面类似,要想发送消息就要有一个Messenger,可是我们前面不是分别在服务端创建了一个Messenger了么,然后将这个Messenger返回给客户端,这样客户端就可以通过这个Messenger向服务器端发送消息,那么既然已经通道已经存在了,我们能不能在服务端使用这个Messenger来想客户端发送消息呢?
答案是否定的。因为这个Messenger是在服务端的,而且是通过服务端的handler实例化的,然后通过binder传到客户端,也就是说告诉客户端你就用这个给我发消息就行了,我就能收到,但是服务端并不知道客户端是谁,谁拿到了这个Messenger,只知道处理通过这个Messenger传递来的消息。
那么按照这个分析的话,要想服务端向客户端发送消息方式就显而易见了,就是在客户端实例化一个Messenger,然后传递给服务端,告诉它用这个Messenger给我发消息就行了,那么客户端可以通过binder获取到服务端的Messenger实例,那么服务端怎么获取到客户端的实例呢?这个就很简单了,因为前面通道已经创建了,只需要在客户端向服务端发送消息的时候将客户端自己的Messenger传递过去就行了。而Message类刚好有一个参数replyTo,这个参数就是Messenger类型的,那么我们只需要在客户端建一个handler,然后实例化一个Messenger传递过去就ok了。
分析完毕,下面是实现:
首先是客户端代码:

 

//创建一个处理服务端发来的消息的handler
private class MyHandler extends Handler{
    @Override
    public void handleMessage(Message msg) {
        switch(msg.what){
            case 2:
                Log.i("test_out", "------>receive response from server!");
                break;
            default:
                super.handleMessage(msg);
        }
    }
}

然后在向服务端发送数据的时候给msg指定replyTo:

//在client向服务端发送消息的时候告诉服务端通过这个messenger进行回复
msg.replyTo = new Messenger(new MyHandler());

接下来是服务端代码,收到消息后获取到messenger并发送消息即可:

class ServiceHandler extends Handler{
    @Override
    public void handleMessage(Message msg) {
        if(msg.what == 1){
            Log.i("test_out","------>receive data from client!");
            Messenger messengerFromClient = msg.replyTo;
            Message replyMessage = new Message();
            replyMessage.what = 2;
            try {
                messengerFromClient.send(replyMessage);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }
}

接下来就是测试了:
先启动服务端,按下home,再启动客户端:
此时服务端:

Android中Service的使用方法

Paste_Image.png


然后在客户端点击发送消息按钮:

Android中Service的使用方法

Paste_Image.png


再看一下客户端:

Android中Service的使用方法

Paste_Image.png


这样就完成了双向通信。
小结:要实现双向通信需要首先在服务端创建一个handler,通过这个handler实例化一个Messenger,通过binder将这个Messenger返回给客户端,客户端收到Messenger之后即可向服务端发消息,此时在客户端创建一个handler,并实例化一个Messenger,在向服务端发消息时将这个Messenger传递过去,服务端收到消息的同时也得到了客户端的Messenger,就可以发消息给客户端。

 

Messenger是使用串行的方式来进行通信,数据量比较大时显然就有点吃力了,而且主要是用来传递消息,但是我们还会出现在客户端调用服务端的方法的情况,这种情况下Messenger就无能为力了,这时候就需要AIDL了,而且Messenger底层实现的本质上也是AIDL。

AIDL

由于水平很菜,感觉AIDL太高深了,后面单独写一个。

参考:
http://www.jianshu.com/p/a8e43ad5d7d2
http://blog.csdn.net/luoyanglizi/article/details/51586437
http://blog.csdn.net/luoyanglizi/article/details/51594016
非常感谢这位大神。

 

 

转自https://www.jianshu.com/p/37c8b6901e22

相关标签: Service