浅谈Android中Service的注册方式及使用

2023-09-15 01:30:05 61

Service通常总是称之为“后台服务”，其中“后台”一词是相对于前台而言的，具体是指其本身的运行并不依赖于用户可视的UI界面，因此，从实际业务需求上来理解，Service的适用场景应该具备以下条件：

1.并不依赖于用户可视的UI界面（当然，这一条其实也不是绝对的，如前台Service就是与Notification界面结合使用的）；

2.具有较长时间的运行特性。

1.ServiceAndroidManifest.xml声明

一般而言，从Service的启动方式上，可以将Service分为StartedService和BoundService。无论哪种具体的Service启动类型，都是通过继承Service基类自定义而来。在使用Service时，要想系统能够找到此自定义Service，无论哪种类型，都需要在AndroidManifest.xml中声明，语法格式如下：

...

其中，android:exported属性上一篇博文中对此已进行详尽描述，android:name对应Service类名，android:permission是权限声明，android:process设置具体的进程名称。需要注意的是Service能否单独使用一个进程与其启动方式有关，本后下面会给出具体说明。其他的属性此处与其他组件基本相同，不再过多描述。

注：如果自定义Service没有在AndroidManifest.xml中声明，当具体使用时，不会像Activity那样直接崩溃报错，对于显式Intent启动的Service，此时也会给出waring信息“IllegalArgumentException:Servicenotregistered”，有时候不容易发现忘了声明而一时定位不到问题。

2.StartedService

StartedService相对比较简单，通过context.startService(IntentserviceIntent)启动Service，context.stopService(IntentserviceIntent)停止此Service。当然，在Service内部，也可以通过stopSelf(...)方式停止其本身。

1)StartedService自定义

下面代码片段显示的是一个最基本的StartedService的自定义方式：

publicclassMyServiceextendsService{
publicstaticfinalStringTAG="MyService";
@Override
publicIBinderonBind(Intentintent){
returnnull;
}
@Override
publicvoidonCreate(){
super.onCreate();
Log.w(TAG,"inonCreate");
}
@Override
publicintonStartCommand(Intentintent,intflags,intstartId){
Log.w(TAG,"inonStartCommand");
Log.w(TAG,"MyService:"+this);
Stringname=intent.getStringExtra("name");
Log.w(TAG,"name:"+name);
returnSTART_STICKY;
}
@Override
publicvoidonDestroy(){
super.onDestroy();
Log.w(TAG,"inonDestroy");
}
}

其中，onBind(...)函数是Service基类中的唯一抽象方法，子类都必须重写实现，此函数的返回值是针对BoundService类型的Service才有用的，在StartedService类型中，此函数直接返回null即可。onCreate(...)、onStartCommand(...)和onDestroy()都是StartedService相应生命周期阶段的回调函数。

2)StartedService使用

publicclassMainActivityextendsActivity{
publicstaticfinalStringTAG="MainActivity";
privateButtonstartServiceBtn;
privateButtonstopServideBtn;
privateButtongoBtn;
privateIntentserviceIntent;
@Override
protectedvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
startServiceBtn=(Button)findViewById(R.id.start_service);
stopServideBtn=(Button)findViewById(R.id.stop_service);
goBtn=(Button)findViewById(R.id.go);
startServiceBtn.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
serviceIntent=newIntent(MainActivity.this,MyService.class);
startService(serviceIntent);
}
});
stopServideBtn.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
stopService(serviceIntent);
}
});
goBtn.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
Intentintent=newIntent(MainActivity.this,BActivity.class);
startActivity(intent);
}
});
}
@Override
protectedvoidonDestroy(){
super.onDestroy();
Log.w(TAG,"inonDestroy");
}
}

如上代码片段，

当Client调用startService(IntentserviceIntent)后，如果MyService是第一次启动，首先会执行onCreate()回调，然后再执行onStartCommand(Intentintent,intflags,intstartId)，当Client再次调用startService(IntentserviceIntent)，将只执行onStartCommand(Intentintent,intflags,intstartId)，因为此时Service已经创建了，无需执行onCreate()回调。无论多少次的startService，只需要一次stopService()即可将此Service终止，执行onDestroy()函数（其实很好理解，因为onDestroy()与onCreate()回调是相对的）。

下面重点关注下onStartCommand(Intentintent,intflags,intstartId)方法。

其中参数flags默认情况下是0，对应的常量名为START_STICKY_COMPATIBILITY。startId是一个唯一的整型，用于表示此次Client执行startService(...)的请求请求标识，在多次startService(...)的情况下，呈现0,1,2....递增。另外，此函数具有一个int型的返回值，具体的可选值及含义如下：

START_NOT_STICKY：当Service因为内存不足而被系统kill后，接下来未来的某个时间内，即使系统内存足够可用，系统也不会尝试重新创建此Service。除非程序中Client明确再次调用startService(...)启动此Service。

START_STICKY：当Service因为内存不足而被系统kill后，接下来未来的某个时间内，当系统内存足够可用的情况下，系统将会尝试重新创建此Service，一旦创建成功后将回调onStartCommand(...)方法，但其中的Intent将是null，pendingintent除外。

START_REDELIVER_INTENT：与START_STICKY唯一不同的是，回调onStartCommand(...)方法时，其中的Intent将是非空，将是最后一次调用startService(...)中的intent。

START_STICKY_COMPATIBILITY：compatibilityversionof{@link#START_STICKY}thatdoesnotguaranteethat{@link#onStartCommand}willbecalledagainafterbeingkilled。此值一般不会使用，所以注意前面三种情形就好。

以上的描述中，”当Service因为内存不足而被系统kill后“一定要非常注意，因为此函数的返回值设定只是针对此种情况才有意义的，换言之，当认为的kill掉Service进程，此函数返回值无论怎么设定，接下来未来的某个时间内，即使系统内存足够可用，Service也不会重启。

小米手机针对此处做了变更：

另外，需要注意的是，小米手机针对此处做了一定的修改。在“自启动管理”中有一个自启动应用列表，默认情况下，只有少应用（如微信、QQ、YY、360等）默认是可以自启动的，其他应用默认都是禁止的。用户可以手动添加自启动应用，添加后的应用中如果StartedServiceonStartCommand(...)回调返回值是START_STICKY或START_REDELIVER_INTENT，当用户在小米手机上长按Home键结束App后，接下来未来的某个时间内，当系统内存足够可用时，Service依然可以按照上述规定重启。当然，如果用户在设置>>应用>>强制kill掉App进程，此时Service是不会重启的。

注：以上实验结论基于小米2S亲测。

3)StartedService生命周期及进程相关

1.onCreate(Client首次startService(..))>>onStartCommand>>onStartCommand-optional...>>onDestroy(Client调用stopService(..))

注：onStartCommand(..)可以多次被调用，onDestroy()与onCreate()想匹配，当用户强制kill掉进程时，onDestroy()是不会执行的。

2.对于同一类型的Service，Service实例一次永远只存在一个，而不管Client是否是相同的组件，也不管Client是否处于相同的进程中。

3.Service通过startService(..)启动Service后，此时Service的生命周期与Client本身的什么周期是没有任何关系的，只有Client调用stopService(..)或Service本身调用stopSelf(..)才能停止此Service。当然，当用户强制kill掉Service进程或系统因内存不足也可能kill掉此Service。

4.ClientA通过startService(..)启动Service后,可以在其他Client（如ClientB、ClientC）通过调用stopService(..)结束此Service。

5.Client调用stopService(..)时，如果当前Service没有启动，也不会出现任何报错或问题，也就是说，stopService(..)无需做当前Service是否有效的判断。

6.startService(IntentserviceIntent)，其中的intent既可以是显式Intent，也可以是隐式Intent，当Client与Service同处于一个App时，一般推荐使用显示Intent。当处于不同App时，只能使用隐式Intent。

当Service需要运行在单独的进程中，AndroidManifest.xml声明时需要通过android:process指明此进程名称，当此Service需要对其他App开放时，android:exported属性值需要设置为true(当然，在有intent-filter时默认值就是true)。

4)StartedServiceClient与Service通信相关

当Client调用startService(IntentserviceIntent)启动Service时，Client可以将参数通过Intent直接传递给Service。Service执行过程中，如果需要将参数传递给Client，一般可以通过借助于发送广播的方式（此时，Client需要注册此广播）。

3.BoundService

相对于StartedService，BoundService具有更多的知识点。BoundService的主要特性在于Service的生命周期是依附于Client的生命周期的，当Client不存在时，BoundService将执行onDestroy，同时通过Service中的Binder对象可以较为方便进行Client-Service通信。BoundService一般使用过程如下：

1.自定义Service继承基类Service，并重写onBind(Intentintent)方法，此方法中需要返回具体的Binder对象；

2.Client通过实现ServiceConnection接口来自定义ServiceConnection，并通过bindService(Intentservice,ServiceConnectionsc,intflags)方法将Service绑定到此Client上；

3.自定义的ServiceConnection中实现onServiceConnected(ComponentNamename,IBinderbinder)方法，获取Service端Binder实例；

4.通过获取的Binder实例进行Service端其他公共方法的调用，以完成Client-Service通信；

5.当Client在恰当的生命周期（如onDestroy等）时，此时需要解绑之前已经绑定的Service，通过调用函数unbindService(ServiceConnectionsc)。

在BoundService具体使用过程中，根据onBind(Intentintent)方法放回的Binder对象的定义方式不同，又可以将其分为以下三种方式，且每种方式具有不同的特点和适用场景：

1）.ExtendingtheBinderclass

这是BoundService中最常见的一种使用方式，也是BoundService中最简单的一种。

局限：Clinet与Service必须同属于同一个进程，不能实现进程间通信（IPC）。否则则会出现类似于“android.os.BinderProxycannotbecasttoxxx”错误。

下面通过代码片段看下具体的使用：

publicclassMyBindServiceextendsService{
publicstaticfinalStringTAG="MyBindService";
privateMyBindermBinder=newMyBinder();
publicclassMyBinderextendsBinder{
MyBindServicegetService(){
returnMyBindService.this;
}
}
@Override
publicvoidonCreate(){
super.onCreate();
Log.w(TAG,"inonCreate");
}
@Override
publicIBinderonBind(Intentintent){
Log.w(TAG,"inonBind");
returnmBinder;
}
@Override
publicbooleanonUnbind(Intentintent){
Log.w(TAG,"inonUnbind");
returnsuper.onUnbind(intent);
}
@Override
publicvoidonDestroy(){
super.onDestroy();
Log.w(TAG,"inonDestroy");
}
}

publicclassBActivityextendsActivity{
publicstaticfinalStringTAG="BActivity";
privateButtonbindServiceBtn;
privateButtonunbindServiceBtn;
privateButtonstartIntentService;
privateIntentserviceIntent;
privateServiceConnectionsc=newMyServiceConnection();
privateMyBindermBinder;
privateMyBindServicemBindService;
privatebooleanmBound;
privateclassMyServiceConnectionimplementsServiceConnection{
@Override
publicvoidonServiceConnected(ComponentNamename,IBinderbinder){
Log.w(TAG,"inMyServiceConnectiononServiceConnected");
mBinder=(MyBinder)binder;
mBindService=mBinder.getService();
mBound=true;
}
@Override
publicvoidonServiceDisconnected(ComponentNamename){
//Thisiscalledwhentheconnectionwiththeservicehasbeen
//unexpectedlydisconnected--thatis,itsprocesscrashed.
Log.w(TAG,"inMyServiceConnectiononServiceDisconnected");
mBound=false;
}
}
@Override
protectedvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.b);
bindServiceBtn=(Button)findViewById(R.id.bind_service);
unbindServiceBtn=(Button)findViewById(R.id.unbind_service);
startIntentService=(Button)findViewById(R.id.start_intentservice);
bindServiceBtn.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
Intentintent=newIntent(BActivity.this,MyBindService.class);
bindService(intent,sc,Context.BIND_AUTO_CREATE);
}
});
unbindServiceBtn.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
excuteUnbindService();
}
});
startIntentService.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
Intentintent=newIntent(BActivity.this,MyIntentService.class);
startService(intent);
}
});
}
privatevoidexcuteUnbindService(){
if(mBound){
unbindService(sc);
mBound=false;
}
}
@Override
protectedvoidonDestroy(){
super.onDestroy();
Log.w(TAG,"inonDestroy");
excuteUnbindService();
}
}

首次点击bindServiceBtn进行bindService(..)时，依次回调顺序如下：

MyBindService(13457):inonCreate
MyBindService(13457):inonBind
BActivity(13457):inMyServiceConnectiononServiceConnected

再次点击bindServiceBtn按钮时，发现没有任何输出，说明MyBindService没有进行任何回调。

点击unbindServiceBtn进行unbindService(..)时，回调顺序为：

MyBindService(13457):inonUnbind
MyBindService(13457):inonDestroy

注：在四大基本组件中，需要注意的的是BroadcastReceiver不能作为BoundService的Client，因为BroadcastReceiver的生命周期很短，当执行完onReceive(..)回调时，BroadcastReceiver生命周期完结。而BoundService又与Client本身的生命周期相关，因此，Android中不允许BroadcastReceiver去bindService(..)，当有此类需求时，可以考虑通过startService(..)替代。

2）UsingaMessenger

Messenger，在此可以理解成”信使“，通过Messenger方式返回Binder对象可以不用考虑Clinet-Service是否属于同一个进程的问题，并且，可以实现Client-Service之间的双向通信。极大方便了此类业务需求的实现。

局限：不支持严格意义上的多线程并发处理，实际上是以队列去处理

下面直接看下具体的使用：

publicclassMyMessengerServiceextendsService{
publicstaticfinalStringTAG="MyMessengerService";
publicstaticfinalintMSG_FROM_CLIENT_TO_SERVER=1;
publicstaticfinalintMSG_FROM_SERVER_TO_CLIENT=2;
privateMessengermClientMessenger;
privateMessengermServerMessenger=newMessenger(newServerHandler());
@Override
publicIBinderonBind(Intentintent){
Log.w(TAG,"inonBind");
returnmServerMessenger.getBinder();
}
classServerHandlerextendsHandler{
@Override
publicvoidhandleMessage(Messagemsg){
Log.w(TAG,"threadname:"+Thread.currentThread().getName());
switch(msg.what){
caseMSG_FROM_CLIENT_TO_SERVER:
Log.w(TAG,"receivemsgfromclient");
mClientMessenger=msg.replyTo;
//service发送消息给client
MessagetoClientMsg=Message.obtain(null,MSG_FROM_SERVER_TO_CLIENT);
try{
Log.w(TAG,"serverbeginsendmsgtoclient");
mClientMessenger.send(toClientMsg);
}catch(RemoteExceptione){
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
}
}
}
@Override
publicbooleanonUnbind(Intentintent){
Log.w(TAG,"inonUnbind");
returnsuper.onUnbind(intent);
}
@Override
publicvoidonDestroy(){
Log.w(TAG,"inonDestroy");
super.onDestroy();
}
}

publicclassCActivityextendsActivity{
publicstaticfinalStringTAG="CActivity";
privateButtonbindServiceBtn;
privateButtonunbindServiceBtn;
privateButtonsendMsgToServerBtn;
privateServiceConnectionsc=newMyServiceConnection();
privatebooleanmBound;
privateMessengermServerMessenger;
privateHandlermClientHandler=newMyClientHandler();
privateMessengermClientMessenger=newMessenger(mClientHandler);
privateclassMyClientHandlerextendsHandler{
@Override
publicvoidhandleMessage(Messagemsg){
if(msg.what==MyMessengerService.MSG_FROM_SERVER_TO_CLIENT){
Log.w(TAG,"reveivemsgfromserver");
}
}
}
privateclassMyServiceConnectionimplementsServiceConnection{
@Override
publicvoidonServiceConnected(ComponentNamename,IBinderbinder){
Log.w(TAG,"inMyServiceConnectiononServiceConnected");
mServerMessenger=newMessenger(binder);
mBound=true;
}
@Override
publicvoidonServiceDisconnected(ComponentNamename){
//Thisiscalledwhentheconnectionwiththeservicehasbeen
//unexpectedlydisconnected--thatis,itsprocesscrashed.
Log.w(TAG,"inMyServiceConnectiononServiceDisconnected");
mBound=false;
}
}
@Override
protectedvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.c);
bindServiceBtn=(Button)findViewById(R.id.bind_service);
unbindServiceBtn=(Button)findViewById(R.id.unbind_service);
sendMsgToServerBtn=(Button)findViewById(R.id.send_msg_to_server);
bindServiceBtn.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
Intentintent=newIntent(CActivity.this,MyMessengerService.class);
bindService(intent,sc,Context.BIND_AUTO_CREATE);
}
});
unbindServiceBtn.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
excuteUnbindService();
}
});
sendMsgToServerBtn.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
sayHello();
}
});
newHandler().postDelayed(newRunnable(){
@Override
publicvoidrun(){
Intentintent=newIntent(CActivity.this,MyAlarmBroadcastReceiver.class);
sendBroadcast(intent);
}
},3*1000);
}
publicvoidsayHello(){
if(!mBound)
return;
//Createandsendamessagetotheservice,usingasupported'what'value
Messagemsg=Message.obtain(null,MyMessengerService.MSG_FROM_CLIENT_TO_SERVER,0,0);
//通过replyTo把client端的Messenger(信使)传递给service
msg.replyTo=mClientMessenger;
try{
mServerMessenger.send(msg);
}catch(RemoteExceptione){
e.printStackTrace();
}
}
privatevoidexcuteUnbindService(){
if(mBound){
unbindService(sc);
mBound=false;
}
}
@Override
protectedvoidonDestroy(){
super.onDestroy();
Log.w(TAG,"inonDestroy");
excuteUnbindService();
}
}

其中，需要注意的几点是：

1.MyMessengerService自定中，通过newMessenger(newServerHandler())创建Messenger对象，在onBind(..)回调中，通过调用Messenger对象的getBinder()方法，将Binder返回；

2.Client在ServiceConnection的onServiceConnected(..)的回调中，通过newMessenger(binder)获取到Service传递过来的mServerMessenger；

3.接下来，就可以通过mServerMessenger.send(msg)方法向Service发送message，Service中的Messenger构造器中的Handler即可接收到此信息，在handleMessage(..)回调中处理；

4.至此只是完成了从Client发送消息到Service，同样的道理，想实现Service发送消息到Client，可以在客户端定义一个Handler，并得到相应的Messenger，在Clinet发送消息给Service时，通过msg.replyTo=mClientMessenger方式将Client信使传递给Service；

5.Service接收到Client信使后，获取此信使，并通过mClientMessenger.send(toClientMsg)方式将Service消息发送给Client。

至此，完成了Client-Service之间的双向通信流程。

3）.AIDL（AndroidInterfaceDefinitionLanguage）

一般情况下，Messenger这种方式都是可以满足需求的，当然，通过自定义AIDL方式相对更加灵活。

这种方式需要自己在项目中自定义xxx.aidl文件，然后系统会自动在gen目录下生成相应的接口类文件，接下来整个的流程与Messenger方式差别不大，网上也有不少实例，在此不再具体给出。

注：无论哪种方式的BoundService，在进行unbind(..)操作时，都需要注意当前Service是否处于已经绑定状态，否则可能会因为当前Service已经解绑后继续执行unbind(..)会导致崩溃。这点与StartedService区别很大（如前文所述：stopService(..)无需做当前Service是否有效的判断）。

4.LocalServiceVSRemoteService

LocalService：不少人又称之为”本地服务“，是指Client-Service同处于一个进程；

RemoteService：又称之为”远程服务“，一般是指Service处于单独的一个进程中。

其他使用上上文中基本上都有所述。

5.Service特性

1.Service本身都是运行在其所在进程的主线程（如果Service与Clinet同属于一个进程，则是运行于UI线程），但Service一般都是需要进行”长期“操作，所以经常写法是在自定义Service中处理”长期“操作时需要新建线程，以免阻塞UI线程或导致ANR；

2.Service一旦创建，需要停止时都需要显示调用相应的方法（StartedService需要调用stopService(..)或Service本身调用stopSelf(..)，BoundService需要调用unbindService(..)），否则对于StartedService将处于一直运行状态，对于BoundService，当Client生命周期结束时也将因此问题。也就是说，Service执行完毕后，必须人为的去停止它。

6.IntentService

IntentService是系统提供给我们的一个已经继承自Service类的特殊类，IntentService特殊性是相对于Service本身的特性而言的：

1.默认直接实现了onBind(..)方法，直接返回null，并定义了抽象方法onHandlerIntent(..)，用户自定义子类时，需要实现此方法；

2.onHandlerIntent(..)主要就是用来处于相应的”长期“任务的，并且已经自动在新的线程中，用户无语自定义新线程；

3.当”长期“任务执行完毕后（也就是onHandlerIntent(..)执行完毕后），此IntentService将自动结束，无需人为调用方法使其结束；

4.IntentService处于任务时，也是按照队列的方式一个个去处理，而非真正意义上的多线程并发方式。

下面是一个基本的继承自IntentService的自定义Service：

publicclassMyIntentServiceextendsIntentService{
publicstaticfinalStringTAG="MyIntentService";
publicMyIntentService(){
super(TAG);
}
publicMyIntentService(Stringname){
super(name);
}
@Override
protectedvoidonHandleIntent(Intentintent){
Log.w(TAG,"inonHandleIntent");
Log.w(TAG,"threadname:"+Thread.currentThread().getName());
}
}

7.前台Service

Android中Service接口中还提供了一个称之为”前台Service“的概念。通过Service.startForeground(intid,Notificationnotification)方法可以将此Service设置为前台Service。在UI显示上，notification将是一个处于onGoing状态的通知，使得前台Service拥有更高的进程优先级，并且Service可以直接notification通信。

下面是一个简单的前台Service使用实例：

publicclassMyServiceextendsService{
publicstaticfinalStringTAG="MyService";
@Override
publicIBinderonBind(Intentintent){
returnnull;
}
@Override
publicvoidonCreate(){
super.onCreate();
Log.w(TAG,"inonCreate");
}
@Override
publicintonStartCommand(Intentintent,intflags,intstartId){
Log.w(TAG,"inonStartCommand");
Log.w(TAG,"MyService:"+this);
Stringname=intent.getStringExtra("name");
Log.w(TAG,"name:"+name);

Notificationnotification=newNotification(R.drawable.ic_launcher,"test",System.currentTimeMillis());
IntentnotificationIntent=newIntent(this,DActivity.class);
PendingIntentpendingIntent=PendingIntent.getActivity(this,0,notificationIntesnt,0);
notification.setLatestEventInfo(this,"title","content",pendingIntent);
startForeground(1,notification);

returnSTART_REDELIVER_INTENT;
}
@Override
publicvoidonDestroy(){
super.onDestroy();
Log.w(TAG,"inonDestroy");
}
}

以上这篇浅谈Android中Service的注册方式及使用就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持毛票票。

浅谈Android中Service的注册方式及使用

热门推荐

随机推荐