Android9 Service
service工作原理

service工作原理service是Android平台上的一种组件,用于在后台执行长时间运行的操作或处理来自其他组件的请求。
它可以在应用程序的主线程之外运行,因此不会阻塞用户界面(UI)的操作。
Service运行在相对独立的进程中,因此即使在应用程序被销毁或不可见时,它仍然可以继续运行。
Service可以分为两种类型:启动式和绑定式。
启动式服务通过startService()方法来启动,不与调用者之间建立直接的链接。
它们在后台独立运行,无需依附于调用者的生命周期。
绑定式服务则通过bindService()方法绑定到调用者,与调用者之间建立一对一的链接。
这种服务的生命周期与调用者的生命周期相关联。
Service的工作原理如下:1. 在应用程序中创建一个继承自Service基类的子类,并重写其onCreate()、onStartCommand()和onDestroy()方法(对于绑定式服务,还需重写onBind()和onUnbind())。
2. 在应用程序的清单文件中声明该Service组件,以便系统可以识别并启动它。
可以通过设置属性android:exported为true或false来指定Service是否可以被其他应用程序访问。
3. 在需要启动或绑定Service的地方,调用startService()或bindService()方法。
通过Intent可以传递操作和数据给Service。
4. 如果是启动式服务,调用者与Service之间没有直接的链接,Service会在后台独立运行。
它会在调用startService()方法后立即调用onStartCommand()方法,在这个方法里可以执行耗时的操作。
5. 如果是绑定式服务,调用者与Service建立起一对一的链接。
调用bindService()方法后,会触发Service的onBind()方法,在这个方法里可以返回一个提供给调用者进行交互的Binder对象。
onStartCommand(android service用法)

onStartCommand(Intent intent, int flags, int startId)Service原理这里不介绍,只介绍onStartCommand的返回和Android Reference中的问题。
onStartCommand方法必须具有一个整形的返回值,这个整形的返回值是一个描述性质的数值,用来告诉系统在服务启动完毕后,一旦遇到服务被系统销毁(System kill),系统将如何继续(操作),这些返回值必须是以下一个:START_NOT_STICKY如果系统在onStartCommand返回后被销毁,系统将不会重新创建服务,除非收到一个未处理(pending悬而未决地)的Intent,当不是必须(necessary)并且Android应用能够自行简单地(simply)重启未完成业务(不通过服务),那么这样的设定是最安全的(safest)。
START_STICKY如果系统在onStartCommand返回后被销毁,系统将会重新创建服务并依次调用onCreate和onStartCommand(注意:根据测试Android2.3.3以下版本只会调用onCreate根本不会调用onStartCommand,Android4.0可以办到),重新创建的操作将会作为事件日程序列(schedule)加入到系统事件日程列表中,在延迟一个计算时间(如:5000ms)后重新启动。
但是不会重新将之前的传入的Intent创新传递给、onStartCommand,除非重新收到一个未处理(pending悬而未决地)的Intent,在这种情况下(inwhich case),未处理的心得Intent仍然按照流程被传入和处理,但是前一次操作的Intent将会变null(等同于一次带null intent的启动)。
对于不需要立刻执行命令的服务,如多媒体播放器(或者其他类似(similar)的服务)那么这样的设定是非常适合的,但是服务会无限期的运行,并等待一个适合的工作(个人理解:就是服务等于又重新启动恢复到之前的状态了)。
Service详解

Service详解⼀什么是Service⼀个Service是没有界⾯且能长时间运⾏于后台的应⽤组件.其它应⽤的组件可以启动⼀个服务运⾏于后台,即使⽤户切换到另⼀个应⽤也会继续运⾏.另外,⼀个组件可以绑定到⼀个service来进⾏交互,即使这个交互是进程间通讯也没问题.例如,⼀个aservice可能处理⽹络事物,播放⾳乐,执⾏⽂件I/O,或与⼀个内容提供者交互,所有这些都在后台进⾏.⼀个service本质上可有两种表现形式: 尽管这个⽂档是把这两种service分开讲的,但你的service可以在这两种⽅式下⼯作.—它可以是started(⽆限期运⾏)同时也允许绑定.唯⼀的简单问题是你是否实现了⼀对回调⽅法:onStartCommand()允许组件启动它并且onBind()允许绑定.不论你是应⽤是否启动,或绑定到⼀个服务或两者都做了,任何应⽤组件都可以使⽤service(即使从另⼀个应⽤),跟任何组件都可以使⽤activity⼀样—通过⼀个Intent启动它.然⽽,你可以在manifest⽂件中声明服务为私有,并且阻⽌另外的应⽤访问它.这在讲如何于manifest⽂件中声明service时会详细讲解. 注意:⼀个service是运⾏在它所在进程的主线程中的—service不会创建它⾃⼰的thread也不会运⾏于单独的进程(除⾮你另外指定).这表⽰,如果你的service想做⼀些狂耗CPU的⼯作或阻塞型的操作(⽐如MP3播放或⽹络通讯),你必须在service中创建⼀个新的线程来做那些⼯作.通过使⽤⼀个分离的线程,你将减少"应⽤没有反应"(ANR)错误并且应⽤的主线程可以保持activity对⽤户操作的快速反应.基础你应使⽤⼀个service还是线程? ⼀个service是⼀个在⽤户不与你的应⽤交互时依然可以运⾏于后台的简单组件.所以,只有你需要这样做时才创建⼀个service. 如果你需要执⾏的⼯作不在主线程中,但是只有⽤户在与你的应⽤交互时才进⾏,那么你可能应该创建⼀个新的线程⽽不是⼀个service.例如,如果你想播放⼀些⾳乐,但是只在你的activity运⾏时才播放,你应该在onCreate()中创建⼀个线程,在onStart()运⾏这个线程,然后在onStop()中停⽌它.也可以考虑使⽤AsyncTask或HandlerThread,来代替传统的线程类. 记住,如果你使⽤了service,它默认会固定运⾏于你的应⽤的主线程,所以你应该在其中创建⼀个线程来执⾏耗时或阻塞的操作要创建⼀个service,你必须创建⼀个Service类(或某个已存在的⼦类)的⼦类.在你的实现中,你应覆写⼀些处理有关service⽣命期的关键⽅⾯的回调⽅法并且提供⼀个能让组件绑定到service的机制(如果需要).你应覆写的最重要的回调⽅法是: 如果⼀个组件通过调⽤startService()启动⼀个service(最终导致onStartCommand()被调⽤),之后service会保持运⾏,直到它通过stopSelf()停⽌⾃⼰或另外的组件调⽤stopService()停⽌它. 如果⼀个组件调⽤bindService()来创建service(onStartCommand()不会被调⽤),那么service只是运⾏在绑定期间.⼀旦service从所有的客户端解除绑定,系统就会杀了它. Android系统只在内存很少并且必须为具有⽤户焦点的actvity釋放资源时才会强制停⽌⼀个service.如果service是绑定到具有⽤户焦点的activity上,那么它很难被杀死,并且如果service被声明为运⾏于前台(后⾯将讨论),那么它将永不被杀死,除⾮,如果这个service启动并且长期运⾏,那么系统将会降低它在后台任务超时列表中的位置然后这个将变成⾼度易被杀对象—如果你的service被启动,那么它必须被设计为能优雅地处理被系统重启的操作.如果系统杀死了你的service,它会在资源重新可⽤时⽴马重启它(但是依赖于你在onStartCommand()中的返回值).⼆如何创建⼀个Service在manifest中声明⼀个service 跟activity以及其它组件⼀样,你必须在你的应⽤的manifest⽂件中声明所有的service们. 要声明你的service,添加⼀个<service>元素作为<application>元素的⼉⼦.例如:[java]01. <manifest ... >02. ...03. <application ... >04. <service android:name=".ExampleService" />05. ...06. </application>07. </manifest> 有许多属性你可以包含在<service>元素中,⽐如启动service的权限和service运⾏所在的进程.android:name属性是哇⼀必须的—它指定了service类的名字.⼀旦你发布了你的应⽤,你不应再改变这个名字,因为如果你改了,你可能使⼀些通过明确的intent来引⽤你的service的功能⽆法运⾏. 就像⼀个activity,⼀个service可以定义intent过滤器来使得其它组件使⽤明确的intent调⽤⾃⼰.通过声明intent过滤器,你设备上的任意应⽤中的组件都可以通过给startService()传递匹配的intent来启动你的sevice. 如果你打算只在本应⽤内使⽤⾃⼰的service,那么你不需指定任何intent过滤器.不使⽤intent过滤器,你必须使⽤⼀个明确指定service的类名的intent来启动你的service. 另外,你也可以通过包含android:exported属性,并指定其值为”false”来保证你的service是私有的.即使你的service使⽤了intent过滤器,也会起作⽤.创建⼀个"启动的"Service 针对Android1.6或更早的版本: 如果你创建的应⽤是针对Android1.6或更早版本的,你需要实现onStart()⽽不是onStartCommand()(在Android2.0中,onStart()被废弃代替之以onStartCommand()). 更多关于如何兼容2.0之前版本的知识,请看onStartCommand()⽂档. ⼀个启动的service,在被其它组件调⽤startService()来启动时,会导致service的onStartCommand()⽅法被调⽤. 当⼀个service被启动后,它的⽣命期就不再依赖于启动它的组件并且可以独⽴运⾏于后台,即使启动它的组件死翘翘了.所以,service应该⼯作完成后调⽤stopSelf()⾃⼰停⽌掉,或者其它组件也可以调⽤stopService()停⽌service. ⼀个应⽤组件,⽐如⼀个activity可以通过调⽤startService()启动service同时传递⼀个指定service和service所⽤的数据的Intent,service在⽅法onStartCommand()中接收这个Intent.事物完成后,service停⽌⾃⼰然后被销毁. ⼩⼼:service默认运⾏在声明它的应⽤进程的主线程中.所以,如果你的service执⾏密集运算或阻塞操作并且与跟⽤户交互的activity位于相同的应⽤中,这个service将会拉低activity的性能.要避免影响应⽤的性能,你必须在service中启动⼀个线程. 传统上,有两个类你可以从它派⽣来创建"启动的"service:从IntentService类派⽣ 因为⼤多数"启动的"service不需要同时处理多个请求,可能从IntentService实现你的service是最好的选择.IntentService做了以下⼯作: 以上实现使得你可以仅仅实现onHandleIntent()来做要做的⼯作即可.(当然,你还是要实现⼀个⼩⼩的构造函数).下⾯是⼀个实现IntentService的例⼦:01. public class HelloIntentService extends IntentService {02.03. /**04. * ⼀个构造函数是必须的,并且你必须调⽤⽗类的IntentService(String)以传⼊⼯作线程的名字.05. */06. public HelloIntentService() {07. super("HelloIntentService");08. }09.10. /**11. * IntentService在默认的⼯作线程中调⽤这个⽅法<p> *当这个⽅法返回后,IntentService停⽌服务,如果能停⽌的话.12. */13. @Override14. protected void onHandleIntent(Intent intent) {15. // Normally we would do some work here, like download a file.16. // For our sample, we just sleep for 5 seconds.17. long endTime = System.currentTimeMillis() + 5*1000;18. while (System.currentTimeMillis() < endTime) {19. synchronized (this) {20. try {21. wait(endTime - System.currentTimeMillis());22. } catch (Exception e) {23. }24. }25. }26. }27. }</p> 以上就是你所有需要做的:⼀个构造函数和⼀个onHandleIntent()的实现. 如果你决定重写其它的⽅法,⽐如onCreate(),onStartCommand(),oronDestroy(),要保证调⽤⽗类的对应实现,这样IntentService才能正确地处理⼯作线程的⽣命期.⽐如,onStartCommand()必须返回默认的实现(其中实现了intent被传送到onHandleIntent()的逻辑):[java]01. @Override02. public int onStartCommand(Intent intent, int flags, int startId) {03. Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();04. return super.onStartCommand(intent,flags,startId);05. } 除onHandleIntent()外,唯⼀不需调⽤⽗类实现的⽅法是onBind()(但是你只需在你的service允许绑定时才实现它). 在下⼀节,你将看到同样的service类,从类Service派⽣时是如何实现的.这需要写更多的代码,但是当你需要处理同时发⽣的请求时(⾮序列化)这就是合适的做法了使⽤类IntentService使得你实现⼀个"开始的"service⾮常容易.然⽽,如果你需要你的service以多线程⽅式执⾏(⽽不是使⽤⼯作队列),那么你需要从类Service派⽣来处理每个intent. 相⽐之下,下⾯的例⼦从类Service派⽣并实现了与上⾯使⽤IntentService例⼦完全相同的⼯作.也就是在⼀个线程中序列化的处理每个"开始"请求.01. <span style="font-size:18px;">public class HelloService extends Service {02. private Looper mServiceLooper;03. private ServiceHandler mServiceHandler;04.05. // 处理从线程收到的消息们06. private final class ServiceHandler extends Handler {07. public ServiceHandler(Looper looper) {08. super(looper);09. }10. @Override11. public void handleMessage(Message msg) {12. // 通常我们在这⾥做⼀些⼯作⽐如下载⼀个⽂件13. // 在我们的例⼦中,仅仅是睡5秒钟.14. long endTime = System.currentTimeMillis() + 5*1000;15. while (System.currentTimeMillis() < endTime) {16. synchronized (this) {17. try {18. wait(endTime - System.currentTimeMillis());19. } catch (Exception e) {20. }21. }22. }23. // 使⽤startId停⽌服务,从⽽使我们不会在处理24. // 另⼀个⼯作的中间停⽌service25. stopSelf(msg.arg1);26. }27. }28.29. @Override30. public void onCreate() {31. // 启动运⾏service的线程.注意我创建了⼀个32. // 分离的线程,因为service通常都是在进程的33. // 主线程中运⾏,但我们不想让主线程阻塞.我们还把新线程34. // 搞成后台级的优先级,从⽽减少对UI线程(主线程的影响).35. HandlerThread thread = new HandlerThread("ServiceStartArguments",36. Process.THREAD_PRIORITY_BACKGROUND);37. thread.start();38.39. // Get the HandlerThread's Looper and use it for our Handler40. mServiceLooper = thread.getLooper();41. mServiceHandler = new ServiceHandler(mServiceLooper);42. }43.44. @Override45. public int onStartCommand(Intent intent, int flags, int startId) {46. Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();47.48. // 对于每个开始请求,发送⼀消息来开始⼀次⼯作,并且把49. // start ID也传过去,所以当完成⼀个⼯作时,我们才知道要停⽌哪个请求.50. Message msg = mServiceHandler.obtainMessage();51. msg.arg1 = startId;52. mServiceHandler.sendMessage(msg);53.54. // 如果我们在这⾥返回后被被杀死了,重启之.55. return START_STICKY;56. }57.58. @Override59. public IBinder onBind(Intent intent) {60. // We don't provide binding, so return null61. return null;62. }63.64. @Override65. public void onDestroy() {66. Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();67. }68. }69. </span> 如你所见,要做的⼯作⽐使⽤IntentService时多⼀些. 然⽽,因为你⾃⼰处理每次对onStartCommand()的调⽤,你可以同时执⾏多个请求.这个例⼦并没有那样做,但是如果那是你所需要的,那么你可以为每个请求创建⼀个新的线程并且⽴即运⾏它们(⽽不是等待上⼀个请求完成). 注意⽅法onStartCommand()必须返回⼀个整数.这个整数描述了在系统杀死它的事件中系统如何继续这个服务(如前⾯所述,IntentService的默认实现为你处理这些,当然你也能够去改写它).onStartCommand()也返回值必须是下⾯常量之⼀:开始⼀个Service 你可以从⼀个activity或从其它应⽤的组件通过传递⼀个Intent(指定了要启动的服务)给startService()启动⼀个服务.Android系统然后调⽤service的onStartCommand()⽅法并且把Intent传递给它.(你永远不能直接调⽤onStartCommand().) 例如,⼀个activity可以在调⽤startService()时使⽤⼀个明确的intent开始前⽂的例⼦中的service(HelloSevice):Intentintent = new Intent(this, HelloService.class);startService(intent); startService()⽅法会⽴即返回然后Android系统调⽤service的onStartCommand()⽅法.但是如果service尚没有运⾏,系统会先调⽤onCreate(),然后调⽤onStartCommand(). 如果service没有提供绑定功能,传给startService()的intent是应⽤组件与service之间唯⼀的通讯⽅式.然⽽,如果你希望service回发⼀个结果,那么启动这个service的客户端可以创建⼀个⽤于⼴播(使⽤getBroadcast())的PendingIntent然后放在intent中传给service,service然后就可以使⽤⼴播来回送结果. 不同的启动请求导致对service的onStartCommand()的不同调⽤,但停⽌service的请求只有⼀个(使⽤stopSelf()或stopService()).停⽌⼀个service ⼀个"启动的"service必须管理其⾃⼰的⽣命期.这表⽰,系统不会停⽌或销毁这种service,除⾮内存不够⽤了并且service在onStartCommand()返回后会继续运⾏.所以,service必须调⽤stopSelf()停⽌⾃⼰或由另⼀个组件调⽤stopService()来停⽌它. ⼀旦通过stopSelf()或stopService()发出了停⽌请求,系统就会尽可能快地销毁service. 然⽽,如果你的service同时处理多个对onStartCommand()的请求,那么你不应在处理完⼀个请求之后就停⽌service,因为你可能已经⼜收到了新的启动请求(在第个完成后停⽌将会结束掉第⼆个).要避免这个问题,你可以使⽤stopSelf(int)来保证你的停⽌请求对应于你最近的开始请求.也就是,当你调⽤stopSelf(int)时,你传递开始请求的ID(传递给onStartCommand()的startId)给service,如果service在你调⽤stopSelf(int)之前收到⼀了个新的开始请求,发现ID不同,于是service将不会停⽌. 注意:你的应⽤在完成⼯作后停⽌它所有的service是⾮常重要的.这可以避免浪费系统资源和消耗电量.如果需要,其它的组件可以调⽤stopService()停⽌service.即使你为service启⽤了绑定,你也必须⾃⼰停⽌service,甚⾄它收到了对onStartCommand()的调⽤也这样.创建⼀个绑定的Service ⼀个绑定的service是允许应⽤的组件通过调⽤bindService()来绑定它以创建⼀个能长期存在的连接(并且⼀般不允许组件调⽤startService()来启动它). 当你的activity或其它组件想与service交互或你的应⽤想基于IPC的向其它应⽤提供功能时,你应该创建⼀个绑定的service. 要创建⼀个绑定的service,你必须实现回调⽅法onBind(),还要在其中返回⼀个IBinder,这个IBinder定义了与service通讯的接⼝.其它应⽤组件就可以在之后调⽤bindService()来接收这个接⼝并开始调⽤service的⽅法.service只在有应⽤组件绑定到它时才活着,所以当没有组件绑定到它时,系统就会宰了它(你不需去停⽌⼀个绑定的service,跟⽤onStartCommand()启动的service不⼀样). 要创建⼀个绑定的service,⾸先要做的就是定义客户端如何与service通讯的接⼝.这个接⼝必须是IBinder的⼀个实现,并且必须被回调⽅法onBind()返回.⼀旦客户端接收到IBinder,它就可以开始与service进⾏交互. 多个客户端可以⼀起绑定到⼀个service.当⼀个客户端完成与service的交互,它调⽤unbindService()来解除绑定.⼀旦不再有任何客户端绑定到service,系统就宰了这个service. 有很多⽅法来实现⼀个绑定的service并且这些实现要⽐"开始的"service难懂得多.发送通知给⽤户 ⼀旦开始运⾏,⼀个service可以通过Toast通知或状态栏通来通知⽤户⼀些事件. ⼀个toast通知是⼀个出现在当前窗⼝表⾯上并过⼀会就消失的消息.当⼀个状态栏通知提供⼀个带有消息的图标到状态栏,⽤就可以先定它来执⾏⼀些动作(⽐如启动⼀个activity). 通常,⼀个状态栏通知是当⼀些后台⼯作(⽐如⼀个⽂件下载完成了)完成后通知⽤户可以对它进⾏动作的最佳⽅式.当⽤户选择这个通知时,它可以开始⼀个activity(⽐如可以查看下载的⽂件).在前台运⾏Service ⼀个前台的service是被⽤户强烈关注的从⽽不会在内存低时被系统杀死.前台service必须在状态栏上提供⼀个通知,这个通知被放在"正在进⾏"区域中,这表⽰这个通知不能被解除,除⾮服务停⽌了或者从前台移除了. 例如,⼀个从service播放⾳乐的⾳乐播放器,应被设置为前台运⾏,因为⽤户会明确地注意它的运⾏.在状态栏中的通知可能会显⽰当前的歌曲并且允许⽤户启动⼀个activity来与⾳乐播放器交互.[java]01. Notification notification = new Notification(R.drawable.icon, getText(R.string.ticker_text),02. System.currentTimeMillis());03. Intent notificationIntent = new Intent(this, ExampleActivity.class);04. PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);05. notification.setLatestEventInfo(this, getText(R.string.notification_title),06. getText(R.string.notification_message), pendingIntent);07. startForeground(ONGOING_NOTIFICATION, notification); 要请求你的service运⾏于前台,调⽤startForeground().此⽅法有两个参数:⼀个整数唯⼀的标识⼀个通知,和这个⽤于状态栏的通知,例如: 要从前台移除service,调⽤stopForeground().这个⽅法有boolean型参数,表明是否也从状态栏删除对应的通知.这个⽅法不会停掉service.然⽽,如果你停⽌了正在前台运⾏的service,这个通知也会被删除. 注意:⽅法startForeground()和⽅法stopForeground()是从Android2.0 (API Level 5)引⼊的.为了在早期版本是于前台运⾏你的service,你必须使⽤以前的那个setForeground()⽅法—见startForeground()的API⽂档查看如何提供与旧版本的兼容性.管理Service的⽣命期 ⼀个service的⽣命期⽐⼀个activity要简单得多.然⽽,你依然需要密切关注你的service是如何被创建⼜是如何被销毁的,因为⼀个service可以运⾏于后台⽽⽤户看不到它. service的⽣命期—从它被创建到它被销毁—有两条路可⾛: 这两条路并不是完全分离的.也就是,你是可以绑定到⽤startService()启动的service的.例如,⼀个后台⾳乐service在通过传⼊指明要播放的⾳乐的intent来调⽤startService()后启动.之后,当⽤户想对播放器进⾏⼀些操作或要获取当前歌曲的信息时,⼀个activity可以通过调⽤bindService()绑定到service.在此情况下,stopService()或stopSelf()不会真正的停⽌service,除⾮所有的客户端都取消绑定了.实现⽣命期回调⽅法 就像activity,service也具有⽣命期回调⽅法,⽤它们你可以监视service的状态的变化并且在合适的时机做⼀些⼯作.下⾯的框架代码演⽰了每个⽣命期⽅法的实现:[java]01. public class ExampleService extends Service {02. int mStartMode; // 表明在service被杀后的⾏为03. IBinder mBinder; // 客户端绑定到的接⼝04. boolean mAllowRebind; // 表明onRebind是否应被使⽤05.06. @Override07. public void onCreate() {08. // The service is being created09. }10. @Override11. public int onStartCommand(Intent intent, int flags, int startId) {12. // service 正在启动,在调⽤startService()期间被调⽤13. return mStartMode;14. }15. @Override16. public IBinder onBind(Intent intent) {17. // ⼀个客户端通过bindService()绑定到这个service18. return mBinder;19. }20. @Override21. public boolean onUnbind(Intent intent) {22. // 所有的客户端使⽤unbindService()解除了绑定23. return mAllowRebind;24. }25. @Override26. public void onRebind(Intent intent) {27. // ⼀个客户端在调⽤onUnbind()之后,正使⽤bindService()绑定到service28. }29. @Override30. public void onDestroy() {31. // service不再被使⽤并将被销毁32. }33. }注:不像activity的⽣命期回调⽅法们,你不需要调⽤⽗类的相应实现.图 2.service的⽣命期.左图显⽰了⽤startService()创建的service的⽣命期,右图显⽰了⽤bindService()创建的service的⽣命期.通过实现这些⽅法们,你可以监视service⽣命期的两个嵌套循环:注:尽管⼀个"启动的"service在调⽤stopSelf()或stopService()时结束,但并没有单独的回调对应这些停⽌⽅法(没有类似于onStop()的回调).所以,除⾮service被绑定到⼀个客户端,系统就会在停⽌时销毁service—onDestroy()是唯⼀收到的回调.图 2演⽰了service的典型回调.尽管图⽰分开了通过startService()和bindService()创建的service,但记住任何service,不管它是怎样启动的,都是可能允许绑定的.所以⼀个从onStartCommand()启动的service(客户端调⽤了startService())仍可以接收onBind()调⽤(当客户端调⽤bindService()时).。
android systemservice类理解

android systemservice类理解Android SystemServer类是Android系统中的一个重要组件,负责管理系统中的各种服务和功能模块。
了解SystemServer类的工作原理和功能对于理解Android系统的整体架构非常重要。
本文将深入探讨Android SystemServer类的相关知识,帮助读者更好地理解和掌握Android系统的工作原理。
SystemServer类是Android系统启动过程中的一个关键角色,它在系统启动时被创建并负责启动和管理系统中的各种服务。
SystemServer类的主要作用包括但不限于以下几个方面:1. 启动系统服务:SystemServer类负责启动系统中的各种服务,包括ActivityManagerService、PowerManagerService、PackageManagerService等。
这些系统服务是Android系统正常运行的基础,SystemServer类通过启动这些服务确保系统的正常运行。
2. 管理系统功能模块:SystemServer类还负责管理系统中的各种功能模块,包括输入管理、窗口管理、通信管理等。
它通过调用相应的模块来管理系统的各项功能,确保系统的稳定运行。
3. 处理系统启动流程:SystemServer类在系统启动时被创建并启动,它会依次启动系统中的各个服务和功能模块,完成系统的初始化和准备工作。
系统启动的过程中,SystemServer类扮演着重要的角色。
了解SystemServer类的工作原理和功能有助于我们更好地理解Android系统的整体架构。
在Android系统的启动过程中,SystemServer类起着至关重要的作用,它负责启动系统中的各种服务和功能模块,确保系统的正常运行。
SystemServer类的工作原理可以总结为以下几个步骤:1. 创建SystemServer实例:系统启动时,SystemServer类的实例会被创建并初始化。
android hwc service的处理流程

android hwc service的处理流程Android HWC Service的处理流程概述Android HWC(Hardware Composer)Service是Android系统中负责处理图形合成和显示的重要组件之一。
它负责接收来自应用程序和系统服务的请求,将图形元素合成为最终的图像帧,并通过硬件接口将图像显示到屏幕上。
本文将详细说明Android HWC Service的处理流程。
流程一:接收请求在Android系统中,应用程序和系统服务通过SurfaceFlinger将图形请求发送给HWC Service。
HWC Service会按照请求的先后顺序接收并处理这些请求。
流程二:合成图像HWC Service将接收到的多个图形请求进行合成,生成最终的图像帧。
图像合成过程包括以下几个步骤: - 图层排序:根据每个图层的显示顺序和属性,对所有图层进行排序,确定它们在最终图像中的叠放次序。
- 图层合成:将排序后的图层依次合成到一个缓冲区中。
在合成过程中,HWC Service可能会使用硬件加速功能,例如GPU加速,以提高合成效率。
- 混合模式:根据每个图层的设置,将它们合成到最终图像中,并应用相应的混合模式,例如正常混合、透明混合等。
流程三:交给显示引擎合成完成后,HWC Service将最终的图像帧交给显示引擎,通过硬件接口将图像显示到屏幕上。
流程四:VSync同步为了保证图像显示的流畅性,Android系统采用了VSync(垂直同步)机制。
HWC Service会监听VSync信号,并在信号到来时将当前的图像帧发送到显示引擎,以进行显示。
这样,图像的更新频率将与显示设备的刷新率保持同步,避免出现画面撕裂等问题。
结论通过以上的流程,Android HWC Service可以高效地处理图形合成和显示任务,确保应用程序和系统界面在屏幕上的流畅显示。
了解HWC Service的处理流程对于开发者来说是非常重要的,可以帮助他们优化图形渲染和图层合成的性能,提升用户体验。
android systemservice类理解

android systemservice类理解在Android中,`SystemService`(系统服务)是一种提供系统级功能的组件。
它允许应用程序与系统的核心功能进行交互,而无需了解底层实现细节。
系统服务是一种将设备功能暴露给应用程序的机制,使应用程序能够访问设备硬件、系统资源和其他关键功能。
系统服务是由Android操作系统管理和提供的,应用程序可以通过系统服务与这些功能进行通信。
一些常见的系统服务包括:1. ActivityManager: 管理应用程序的生命周期和任务栈。
2. PackageManager: 管理应用程序的安装、卸载和信息查询。
3. WindowManager: 管理窗口和界面元素。
4. NotificationManager: 管理通知。
5. TelephonyManager: 提供与电话相关的信息和功能。
6. ConnectivityManager: 管理网络连接。
7. LocationManager: 提供地理位置信息。
8. PowerManager: 管理设备的电源状态。
9. AudioManager: 控制音频设置和管理音频。
10. SensorManager: 管理设备上的传感器。
11. Vibrator: 控制设备的振动。
这些系统服务是通过`Context`对象的`getSystemService()`方法获得的。
例如,要获取`AudioManager`:```javaAudioManager audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);```这里的`Context`是Android应用程序的一个关键组件,提供了应用程序的全局信息和对Android环境的访问权限。
系统服务的使用使应用程序能够访问设备功能,而无需实现这些功能的底层逻辑。
这样,Android提供了一种标准的接口,允许应用程序开发者专注于其应用的特定功能,而不必处理底层的硬件和系统细节。
android autoservice 简书

android autoservice 简书
Android AutoService是一个用于Android设备的自动服务框架,它可以帮助开发者快速构建自己的自动服务。
简书是一个轻量级的笔记应用,可以用来记录和分享自己的想法和经验。
在简书上,你可以找到很多关于Android开发、应用开发的教程和经验分享。
其中一些教程会介绍如何使用Android AutoService框架来开发自己的自动服务,以及如何利用简书平台来记录和分享自己的开发经验。
如果你对Android开发有兴趣,并且想要了解更多关于Android AutoService和简书的信息,可以在简书上搜索相关的教程和文章,或者尝试自己动手开发一个简单的自动服务应用,并通过简书记录和分享自己的开发经验。
android 的Activity和Service之间的通信

android 的Activity和Service之间的通信在android中Activity负责前台界面展示,service负责后台的需要长期运行的任务。
Activity和Service之间的通信主要由IBinder负责。
在需要和Service 通信的Activity中实现ServiceConnection接口,并且实现其中的onServiceConnected和onServiceDisconnected方法。
然后在这个Activity中还要通过如下代码绑定服务:Java代码1.Intent intent = new Intent().setClass( this , IHRService.class);2.bindService( intent , this , Context.BIND_AUTO_CREATE );当调用bindService方法后就会回调Activity的onServiceConnected,在这个方法中会向Activity中传递一个IBinder的实例,Acitity需要保存这个实例。
代码如下:Java代码1.public void onServiceConnected( ComponentName inName , IBinderserviceBinder) {2. if ( inName.getShortClassName().endsWith( "IHRService" ) ){3. try {4. this.serviceBinder= serviceBinder;5. mService = ( (IHRService.MyBinder) serviceBinder).getService();6. //mTracker = mService.mConfiguration.mTracker;7. } catch (Exception e) {}8.9. }10.}在Service中需要创建一个实现IBinder的内部类(这个内部类不一定在Service中实现,但必须在Service中创建它)。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
步骤3:
• <string-array name="phoneType"> • <item>未知</item> • <item>GSM</item> • <item>CDMA</item> • </string-array> • </resources>
Activity类的编写
• setContentView(siminfo); • • // 获取系统的TelephoneManager对象 • TelephonyManager manager = • (TelephonyManager)getSystemService(Context.TELEPHONY_SER VICE); • // 获取各种状态名称的数组 • String[] statusNames = • getResources().getStringArray(R.array.statusNames); • // 获取代表SIM卡状态的数组 • String[] simState = getResources().getStringArray(R.array.simState); • // 获取代表电话网络类型的数组 • String[] phoneType = getResources().getStringArray(R.array.phoneType); • // 获取设备编号 • ArrayList<String> statusValues = new ArrayList<String>() ; • statusValues.add(manager.getDeviceId());
步骤3:字符串资源 • • • • • • • • • • • • <item>SIM卡序列号</item> <item>SIM卡状态</item> </string-array> <!-- 声明一个名为simState的字符串数组 --> <string-array name="simState"> <item>状态未知</item> <item>无SIM卡</item> <item>被PIN加锁</item> <item>被PUK加锁</item> <item>被NetWork PIN加锁</item> <item>已准备好</item> </string-array>
创建、配置Service
• 和开发Activity的步骤类似,创建Service需要经过 以下两步:
– (1)编写一个继承自Service的类创建自己的服务,根据 需要重写onCreate()、 onDestroy() 、onBind()、 onStartCommand()方法。如果希望Service组件做某些 事情,一般只要在onCreate()或onStartCommand()方 法中定义相关的业务代码即可。 – (2)在AndroidManifest.xml文件中的<application>节点 里注册service,要添加的节点语法如下,其中关键的 属性“android:name”指的是服务类的名称,如必要, 需带包名。
服务概述
• Android中的Service和windows中的服务类 似。Service是Android四大组件中与Activity 最相似的组件,它们都代表可执行的程序 。不同的是Service是一个应用程序组件, 它没有图形化界面,不可交互的操作,常 用来在后台处理一些耗时比较长的操作。 一旦Service被启动起来之后,它就与 Activity一样具有自己的生命周期。
代码
• // 遍历statusValues集合,将statusNames、statusValues • // 的数据封装到List<Map<String , String>>集合中 • for (int i = 0; i < statusValues.size(); i++) { • HashMap<String, String> map = new HashMap<String, String>(); • map.put("name", statusNames[i]); • map.put("value", statusValues.get(i)); • status.add(map); • } • // 使用SimpleAdapter封装List数据 • SimpleAdapter adapter = new SimpleAdapter(this, status, yout.item, new String[] { "name", "value" }, new int[] { , R.id.value }); • // 为ListView设置Adapter • showView.setAdapter(adapter);
代码示例
• 通过TelephoneManager提供的系列方法获 取手机网络、SIM卡的相关信息,并以 ListView的形式显示在手机屏幕上。
步骤1
• <?xml version="1.0" encoding="utf-8"?> • <LinearLayout xmlns:android="/apk/res/and roid" • android:layout_width="fill_parent" • android:layout_height="fill_parent" • android:background="#F0F0F0" • android:orientation="vertical" > • <ListView • android:id="@+id/showPhoneLV" • android:layout_width="fill_parent" • android:layout_height="wrap_content" /> • </LinearLayout>
系统服务
• Android系统提供了大量的服务给我们使用,通过这些服 务我们可以做很多事情。一般来说我们是通过 getSystemService()方法来获取这些服务的,此方法的基 本语法如下: • 语法: • Object android.app.Activity.getSystemService(String name) • 此方法用来获取参数name所指定的系统级别的服务。这 里的name是指系同级别的服务名称,在Context类中定义 了可用的系统服务名称常量,例如WINDOW_SERVICE 、POWER_SERVICE等。
ቤተ መጻሕፍቲ ባይዱ
步骤3:字符串资源 • <?xml version="1.0" encoding="utf-8"?> • <resources> • <!-- 声明一个名为statusNames的字符串数组 --> • <string-array name="statusNames"> • <item>设备编号</item> • <item>软件版本</item> • <item>网络运营商代号</item> • <item>网络运营商名称</item> • <item>手机制式</item> • <item>设备当前位置</item> • <item>SIM卡的国别</item>
步骤2
• <?xml version="1.0" encoding="utf-8"?> • <LinearLayout xmlns:android="/apk/res/android" • android:layout_width="fill_parent" • android:layout_height="wrap_content" • android:orientation="horizontal" > • <TextView • android:id="@+id/name" • android:layout_width="wrap_content" • android:layout_height="wrap_content" • android:textSize="16dip" • android:width="120px" /> • <TextView • android:id="@+id/value" • android:layout_width="fill_parent" • android:layout_height="wrap_content" • android:paddingLeft="8px"
代码
• // 获取系统平台的版本 • statusValues.add(manager.getDeviceSoftwareVersion() != null ? manager.getDeviceSoftwareVersion() : "未知"); • // 获取网络运营商代号 • statusValues.add(manager.getNetworkOperator()); • // 获取网络运营商名称 • statusValues.add(manager.getNetworkOperatorName()); • // 获取手机网络类型 • statusValues.add(phoneType[manager.getPhoneType()]); • // 获取设备所在位置 • statusValues.add(manager.getCellLocation() != null ? manager.getCellLocation().toString() : "未知位置");