您的位置：360文档中心› 如何让Android service变成前台应用

如何让Android service变成前台应用

合集下载

Service详解

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. // 在我们的例⼦中，仅仅是睡５秒钟．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()时)．。

AndroidService两种启动方式详解（总结版）

AndroidService两种启动方式详解（总结版）

AndroidService两种启动方式详解（总结版）Service生命周期.png第一种方式：通过StartService启动Service通过startService启动后，service会一直无限期运行下去，只有外部调用了stopService()或stopSelf()方法时，该Service才会停止运行并销毁。

要创建一个这样的Service，你需要让该类继承Service类，然后重写以下方法：•onCreate()•1.如果service没被创建过，调用startService()后会执行onCreate()回调；onStartCommand回调。

第二种方式：通过bindService启动ServicebindService启动服务特点：1.bindService启动的服务和调用者之间是典型的client-server 模式。

调用者是client，service则是server端。

service只有一个，但绑定到service上面的client可以有一个或很多个。

这里所提到的client指的是组件，比如某个Activity。

2.client可以通过IBinder接口获取Service实例，从而实现在client端直接调用Service中的方法以实现灵活交互，这在通过startService方法启动中是无法实现的。

3.bindService启动服务的生命周期与其绑定的client息息相关。

当client销毁时，client会自动与Service解除绑定。

当然，client 也可以明确调用Context的unbindService()方法与Service解除绑定。

当没有任何client与Service绑定时，Service会自行销毁。

bindService代码实例交互界面设计如下：ActivityA界面布局.pngActivityB界面布局.pngActivityA还在绑定连接中，所以不会执行Service的解绑方法。

androidforegroundservicestartnotallowedexception

androidforegroundservicestartnotallowedexception

androidforegroundservicestartnotallowedexception 当我们在开发Android应用程序时使用前台服务时，可能会遇到“androidforegroundservicestartnotallowedexception”错误。

这个错误通常是由于Android系统的限制导致的，它会阻止应用程序启动前台服务。

然而，有一些方法可以解决这个错误，如下所示：1. 避免在后台运行过多的服务和活动。

当您的应用程序同时运行多个服务和活动时，Android系统可能会拒绝启动前台服务。

尝试将它们合并为一个服务或活动，以减少系统负载。

2. 请求必要的权限。

在您的AndroidManifest.xml文件中，必须声明您的应用程序需要的所有权限。

如果您的应用程序没有所需的权限，则可能无法启动前台服务。

3. 使用startForeground()方法。

在启动前台服务之前，您可以使用startForeground()方法将服务设置为前台状态。

这将提醒Android系统将其视为重要服务并允许其在后台运行。

4. 优化您的代码。

您的代码可能会影响应用程序的性能和稳定性。

尝试优化您的代码，以确保它不会导致系统负载过高。

5. 更新您的Android SDK。

一些早期版本的Android SDK可能存在一些限制，这些限制可能导致无法启动前台服务。

确保您的Android SDK已更新到最新版本。

通过遵循上述建议，您可以解决“androidforegroundservicestartnotallowedexception”错误，并确保您的应用程序能够启动前台服务。

startforegroundservice notification

startforegroundservice notification

startforegroundservice notification什么是前台服务（Foreground Service）？前台服务是一种在Android 系统中运行的服务，其优先级与用户当前正在交互的应用程序相同。

尽管Android 系统在低内存情况下会尝试关闭后台服务以释放资源，但前台服务不会受到这种影响。

当应用程序需要执行某些不能被打断的长时间运行任务时，前台服务可以被用来确保任务顺利执行而不被系统关闭。

为了提醒用户服务正在运行，前台服务通常在系统状态栏中显示一个通知。

前台服务的使用场景前台服务在许多应用场景中十分有用，尤其是那些需要进行长时间运行的任务时。

下面是几个常见的场景：1. 音乐播放器：当用户在使用音乐播放器时，为了确保播放器持续运行并且不被系统关闭，可以将播放器以前台服务的形式运行。

这样即使用户切换到其他应用程序，播放器仍然会继续播放音乐，并且在系统状态栏显示一个通知，提醒用户音乐正在播放。

2. 导航应用：导航应用通常需要持续运行以提供实时导航指示。

通过将导航应用以前台服务的形式运行，并在系统状态栏显示导航指示，用户可以在使用其他应用程序时仍然能够看到导航指引。

3. 下载管理器：当用户在进行大文件下载时，使用前台服务可以确保下载过程正常进行。

下载管理器可以在系统状态栏显示一个通知，提醒用户下载正在进行。

如何创建前台服务？创建前台服务的步骤如下：1. 创建服务类：首先，需要创建一个继承自Service 的类。

这个类将负责运行你想要在前台执行的任务。

2. 实现前台服务方法：在服务类中，需要重写onStartCommand 方法。

在该方法中，你需要创建一个通知，然后调用startForeground 方法将服务设为前台服务。

通知将在系统状态栏上显示，并提醒用户服务正在运行。

3. 定义前台服务权限：在AndroidManifest.xml 文件中，需要为前台服务声明权限。

这一步是必需的，以便应用程序可以使用前台服务。

Android四大组件——Service后台服务、前台服务、IntentService、跨进程服务、无障碍服务、系统服务

Android四大组件——Service后台服务、前台服务、IntentService、跨进程服务、无障碍服务、系统服务

Android四大组件——Service后台服务、前台服务、IntentService、跨进程服务、无障碍服务、系统服务Service简介Service是Android中实现程序后台运行的解决方案，它非常适用于去执行那些不需要和用户交互而且还要求长期运行的任务。

Service默认并不会运行在子线程中，它也不运行在一个独立的进程中，它同样执行在UI线程中，因此，不要在Service中执行耗时的操作，除非你在Service中创建了子线程来完成耗时操作Service的运行不依赖于任何用户界面，即使程序被切换到后台或者用户打开另一个应用程序，Service仍然能够保持正常运行，这也正是Service的使用场景。

当某个应用程序进程被杀掉时，所有依赖于该进程的Service也会停止运行后台服务后台服务可交互性主要是体现在不同的启动服务方式，startService()和bindService()。

bindService()可以返回一个代理对象，可调用Service中的方法和获取返回结果等操作，而startService()不行不可交互的后台服务不可交互的后台服务即是普通的Service，Service的生命周期很简单，分别为onCreate、onStartCommand、onDestroy这三个。

当我们startService()的时候，首次创建Service会回调onCreate()方法，然后回调onStartCommand()方法，再次startService()的时候，就只会执行一次onStartCommand()。

服务一旦开启后，我们就需要通过stopService()方法或者stopSelf()方法，就能把服务关闭，这时就会回调onDestroy()一、创建服务类创建一个服务非常简单，只要继承Service，并实现onBind()方法public class BackGroupService extends Service {/*** 綁定服务时调用** @param intent* @return*/@Nullable@Overridepublic IBinder onBind(Intent intent) {Log.e("Service", "onBind");return null;}/*** 服务创建时调用*/@Overridepublic void onCreate() {Log.e("Service", "onCreate");super.onCreate();}/*** 执行startService时调用** @param intent* @param flags* @param startId* @return*/@Overridepublic int onStartCommand(Intent intent, int flags, int startId) { Log.e("Service", "onStartCommand");//这里执行耗时操作new Thread() {@Overridepublic void run() {while (true){try {Log.e("Service", "doSomething");Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}}}.start();return super.onStartCommand(intent, flags, startId);}/*** 服务被销毁时调用*/@Overridepublic void onDestroy() {Log.e("Service", "onDestroy");super.onDestroy();}}二、配置服务Service也是四大组件之一，所以必须在manifests中配置<service android:name=".Service.BackGroupService"/>三、启动服务和停止服务我们通过两个按钮分别演示启动服务和停止服务，通过startService()开启服务，通过stopService()停止服务public class MainActivity extends AppCompatActivity {Button bt_open, bt_close;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_main);bt_open = (Button) findViewById(R.id.open);bt_close = (Button) findViewById(R.id.close);final Intent intent = new Intent(this, BackGroupService.class);bt_open.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {//启动服务startService(intent);}});bt_close.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {//停止服务stopService(intent);}});}}当你开启服务后，还有一种方法可以关闭服务，在设置中，通过应用->找到自己应用->停止四、运行代码运行程序后，我们点击开始服务，然后一段时间后关闭服务。

如何进行Android应用的后台和前台切换测试

如何进行Android应用的后台和前台切换测试

如何进行Android应用的后台和前台切换测试Android 应用的后台和前台切换测试是一个重要的测试环节，可以帮助开发人员和测试人员评估应用在切换状态下的性能和稳定性。

本文将介绍如何进行 Android 应用的后台和前台切换测试，并提供一些测试技巧和注意事项。

一、测试前准备在开始进行后台和前台切换测试之前，需要确保以下几点准备工作已完成：1. 创建测试环境：使用 Android Studio 或其他开发工具创建一个测试工程，将要测试的应用安装到测试环境中。

2. 确认测试设备：选择适合的 Android 设备进行测试，可以使用真机或虚拟机进行测试。

3. 打开开发者选项：确保在测试设备上已打开开发者选项，以便在测试中使用一些必要的功能和调试工具。

二、后台和前台切换测试场景Android 应用的后台和前台切换测试可以包括以下几个场景：1. 按 Home 键将应用置于后台：通过按下设备的 Home 键，将应用置于后台运行状态，然后再将应用切换到前台。

2. 打开其他应用将应用置于后台：在应用运行中，打开其他应用，将应用置于后台，然后再将应用切换到前台。

3. 模拟低内存情况下的后台和前台切换：通过模拟系统内存紧张的情况，强制将应用置于后台并触发系统回收内存，然后再将应用切换到前台。

三、测试步骤1. 启动应用：在测试设备上启动应用，并确保应用正常运行。

2. 按 Home 键将应用置于后台：按下设备的 Home 键，将应用置于后台。

3. 切换到前台：从设备的任务管理器或最近使用的应用列表中选择应用，将应用切换到前台。

4. 检查应用状态：确认应用能够恢复到之前的状态，包括当前界面、用户输入等。

5. 打开其他应用将应用置于后台：在应用运行中，打开其他应用，并确保应用被置于后台。

6. 切换到前台：从任务管理器或最近使用的应用列表中选择应用，将应用切换到前台。

7. 检查应用状态：确认应用能够正确恢复到之前的状态。

8. 模拟低内存情况下的后台和前台切换：使用开发者工具或第三方应用模拟低内存情况，将应用置于后台并触发系统内存回收。

android startforegroundservice详解

android startforegroundservice详解

android startforegroundservice详解Android StartForegroundService详解在Android开发中，我们经常需要在后台进行一些长时间运行的任务，如音乐播放器、下载管理器等。

在较新的Android版本中，为了提高系统性能并避免应用被系统杀死，Google引入了startForegroundService方法来启动在前台运行的服务。

本文将以"android startForegroundService详解"为主题，一步一步回答该主题。

第一步：什么是startForegroundService方法？startForegroundService方法是一个用于在Android系统中启动前台服务的方法。

在较新的Android版本中，如果我们使用startService方法启动一个服务，而该服务需要在后台执行长时间运行的任务，系统会认为该应用在后台运行过程中影响到了系统的正常性能，从而可能会将该应用杀死。

为了避免这种情况发生，我们可以使用startForegroundService 方法来启动一个前台服务，使得系统将该服务视为是用户正在进行互动的重要任务，提高其在系统中的优先级，从而减少被系统杀死的可能性。

第二步：使用startForegroundService的步骤是什么？使用startForegroundService方法启动前台服务的步骤如下：1. 在AndroidManifest.xml文件中为服务设置一个唯一的action。

xml<serviceandroid:name=".MyForegroundService"android:enabled="true"android:exported="true"><intent-filter><actionandroid:name="com.example.ACTION_FOREGROUND_SERVICE" /></intent-filter></service>2. 创建一个继承自Service的前台服务类。

android前台stopservice 原理

android前台stopservice 原理

android前台stopservice 原理
当调用`stopService()`方法停止一个服务时，Android系统会执行以下操作：
1. 检查服务是否有正在运行的客户端（即通过`startService()`方法启动的服务）。

如果没有正在运行的客户端，那么系统会尝试停止该服务。

2. 调用服务的`onDestroy()`方法，以便服务可以进行清理工作并释放可能持有的资源。

需要注意的是，如果通过`bindService()`方法绑定了服务，那么即使调用`stopService()`停止了服务，服务仍然会继续运行，直到所有绑定的客户端都解除了绑定。

此外，如果服务在调用`startForeground()`方法将自己提升为前台服务，那么调用`stopService()`是不会停止服务的。

要停止前台服务，可以调用`stopForeground()`方法，并在适当的时候调用`stopSelf()`或者`stopSelfResult()`方法停止服务。

android service的用法

android service的用法

在Android开发中，Service是一种用于在后台执行长时间运行操作的组件，而不提供用户界面的应用程序组件。

以下是使用Android Service的一些基本用法：1.定义Service类：创建一个继承自Service的类，并重写其中的一些方法来执行所需的操作。

例如，可以在Service中执行网络请求、文件读写等操作。

2.注册Service：在AndroidManifest.xml文件中注册Service，以便系统可以找到并启动它。

例如：php复制代码<service android:name=".MyService" />3.启动Service：在Activity或其他组件中，使用Context的startService()方法来启动Service。

例如：java复制代码Intent intent = new Intent(this, MyService.class);startService(intent);4.绑定Service：如果需要在Service和Activity之间进行通信，可以使用bindService()方法来绑定Service。

通过回调接口，可以在Service和Activity之间传递数据或执行操作。

5.处理生命周期：由于Service在后台运行，不受Activity的生命周期限制，因此需要处理其自身的生命周期。

在Service中重写onStartCommand()或onBind()方法来执行所需的操作，并在不再需要时调用stopSelf()方法来停止Service。

6.通知用户：如果需要在Service执行某些操作时通知用户，可以使用NotificationManager来发送通知。

例如，可以在Service中发送一个通知，告知用户数据已成功下载或上传。

需要注意的是，使用Service需要谨慎处理资源的释放和生命周期的管理，以避免内存泄漏和资源浪费。

Android实现Service在前台运行服务

Android实现Service在前台运行服务

Android实现Service在前台运⾏服务前⾔在做⼿机⾳乐播放器的时候，让我⾮常苦恼的⼀件事就是⼿机有清理内存的软件，⽐如百度，360等等，⼀点击清理⾳乐就停⽌播放了，去后台查看发现Service已经被停⽌并重新启动了，这显然不是我想要的，我希望⾳乐能够在后台播放，并且⾃⼰能控制什么时候退出，不想让系统给我清理了，就像酷狗⼀直在通知栏显⽰那样，于是我就知道了在前台运⾏的服务。

实现我们先看⼀下结果图：这是运⾏在通知栏的界⾯，这样就是让服务在前台运⾏，再清理的时候就不会导致服务被关闭了。

好了，我们直接上代码，因为要开启服务，所以我们必须先要有⼀个Service的⼦类，然后在onCreate⾥⾯实现它。

MyService.javapublic class MyService extends Service {public static final String TAG = "MyService";@Overridepublic void onCreate() {super.onCreate();Notification notification = new Notification(R.drawable.ic_launcher,"有通知到来", System.currentTimeMillis());Intent notificationIntent = new Intent(this, MainActivity.class);PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,notificationIntent, 0);notification.setLatestEventInfo(this, "幻听", "许嵩",pendingIntent);startForeground(1, notification);}@Overridepublic int onStartCommand(Intent intent, int flags, int startId) {return super.onStartCommand(intent, flags, startId);}@Overridepublic void onDestroy() {super.onDestroy();}@Overridepublic IBinder onBind(Intent intent) {return null;}}可以看到，在onCreate⽅法⾥⾯我们得到Notification的⼀个对象，然后调⽤startForeground(1, notification);⽅法来实现在前台运⾏。

Android设置应用为默认桌面应用

Android设置应用为默认桌面应用

Android设置应⽤为默认桌⾯应⽤⽬录需求：要设置⼀应⽤为桌⾯应⽤，且重启开机时不弹出选择弹窗，直接默认⾮原系统应⽤。

实现⽅法：实现⽅法⼀共两种：1. 读取当前有多少应⽤是桌⾯应⽤，在开机启动时，匹配所需应⽤为默认应⽤。

2. 直接把所需应⽤设置为系统桌⾯应⽤。

前⼀种⽅法，可以实现系统内多个桌⾯应⽤切换，当不想⽤第三⽅应⽤时，可以从设置中切换回原⽣桌⾯应⽤。

第⼆种⽅法就⽐较绝，相当于直接把第三⽅应⽤当作系统桌⾯应⽤，但是若该应⽤出BUG时，桌⾯就不能启动，因为桌⾯就是该应⽤。

第⼀种⽅法实现⾮常繁琐，第⼆种⽅法实现较为简单，所以本⽅法采⽤第⼆种⽅法。

具体实现步骤：1、APK源码中设置应⽤为桌⾯应⽤只需APK的AndroidMainfest.xml中修改如下即可：<intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="UNCHER" /><category android:name="android.intent.category.HOME" /><category android:name="android.intent.category.DEFAULT" /></intent-filter>修改后即可实现如下效果：但是，以上修改在每次开机时还会弹出此框，所以需要对Android源码加以修改。

2、Android源码中设置应⽤为系统预装应⽤在T:\Code\RK3399PRO_HDMI_ANDROID8\vendor\rockchip\common\apps⽂件夹下建⽴⼀⽂件夹，名称为EV_WebViewTest,在该⽂件夹下放⼊APK⽂件，重命名为EV_WebViewTest.apk，并建⽴⼀个Android.mk⽂件，⽂件内容如下：# EV_WebViewTestLOCAL_PATH := $(call my-dir)include $(CLEAR_VARS)LOCAL_MODULE := EV_WebViewTestLOCAL_MODULE_CLASS := APPSLOCAL_MODULE_TAGS := optionalLOCAL_BUILT_MODULE_STEM := package.apkLOCAL_MODULE_SUFFIX := $(COMMON_ANDROID_PACKAGE_SUFFIX)#LOCAL_PRIVILEGED_MODULE :=LOCAL_CERTIFICATE := PRESIGNEDLOCAL_SRC_FILES := $(LOCAL_MODULE).apk#LOCAL_REQUIRED_MODULES :=#LOCAL_PREBUILT_JNI_LIBS :=include $(BUILD_PREBUILT)并在T:\Code\RK3399PRO_HDMI_ANDROID8\vendor\rockchip\common\apps\apps.mk的⽂件内添加以下代码：PRODUCT_PACKAGES += \EV_WebViewTest这样编译完固件烧录后，就会在系统内多了⼀个预装APK，其名称不⼀定是EV_WebViewTest，以APK项⽬设置为准。

startforegroundservice 5秒

startforegroundservice 5秒

startForegroundService() 是 Android 开发中用于将一个服务（Service）设置为前台运行的方法。

这通常用于那些可能需要长时间运行的服务，以便用户知道它们正在运行，并且在屏幕关闭或设备锁定时也不会被杀死。

当调用 startForegroundService() 方法时，通常需要传递一个 Notification 对象作为参数。

这个对象用于在设备的通知栏显示一条通知，告知用户该服务正在运行。

关于“5秒”的问题，我不确定您具体指的是什么。

如果您是在说服务应该在启动后5秒开始前台运行，那么您可能需要使用一个延时（例如，使用 Handler 或 Thread.sleep()），在启动服务后等待一段时间，然后调用 startForeground() 方法来开始前台运行。

这里是一个简单的示例代码片段，展示如何在服务启动后5秒开始前台运行：javapublic class MyService extends Service {private final int FOREGROUND_ID = 12345;@Overridepublic void onCreate() {super.onCreate();// 延迟5秒后开始前台运行new Handler().postDelayed(new Runnable() {@Overridepublic void run() {startForeground(FOREGROUND_ID, new Notification());}}, 5000); // 5000毫秒 = 5秒}// 其他服务逻辑...}在这个示例中，startForeground() 方法会在服务启动后的5秒内被调用，使得服务开始前台运行。

您需要根据自己的需求来调整代码。

Android应用程序转到后台并回到前台判断方法

Android应用程序转到后台并回到前台判断方法

Android应⽤程序转到后台并回到前台判断⽅法我们知道，当我们按返回或Home键退出应⽤程序的界⾯时，应⽤程序会在后台被挂起。

这么设计的好处是，由于应⽤被系统缓存在内存中，那么在⽤户打开启动应⽤时就可以通过调⽤缓存，快速启动应⽤。

当然，由于当今内存和处理器能⼒的限制，系统会⾃动关闭⼀些进程。

那么我如何判断这个应⽤程序在前台还是后台，应⽤从后台回到前台了？看到⼀般都是runningProcess或者runningTasks来判断应⽤在前台还是后台事实上，Android在SDK 14的时候提供了⼀个Callback。

ActivityLifecycleCallbacks，你可以通过这个Callback拿到App所有Activity的⽣命周期回调。

public class Application extends android.app.Application {private int activityCount;//activity的count数private boolean isForeground;//是否在前台@Override public void onCreate() {super.onCreate();registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {@Overridepublic void onActivityCreated(Activity activity, Bundle savedInstanceState) {}@Override public void onActivityStarted(Activity activity) {activityCount++;} @Overridepublic void onActivityResumed(Activity activity) {} @Overridepublic void onActivityPaused(Activity activity) {} @Overridepublic void onActivityStopped(Activity activity) {activityCount--; if(0==activityCount){isForeground=false; }} @Overridepublic void onActivitySaveInstanceState(Activity activity, Bundle outState) {} @Overridepublic void onActivityDestroyed(Activity activity) {} }); } }这个Callback写在Application⾥的，你可以在Application初始化的时候来注册。

Android窗口管理服务WindowManagerService切换Activity窗口(App Transition)的过程分析

Android窗口管理服务WindowManagerService切换Activity窗口(App Transition)的过程分析

Android窗口管理服务WindowManagerService切换Activity 窗口（App Transition）的过程分析在Android系统中，同一时刻只有一个Activity组件是处于激活状态的，因此，当ActivityManagerService服务激活了一个新的Activity组件时，它就需要通知WindowManagerService服务将该Activity组件的窗口显示出来，这会涉及到将焦点和屏幕等资源从前一个激活的Activity组件切换到后一个激活的Activity组件的过程，本文就详细分析这个过程。

Activity窗口的切换操作是在新激活的Activity组件的启动过程进行的。

具体来说，就是在前一个激活的Activity组件进入到Paused状态并且新激活的Activity组件进之到Resumed 状态之后，将前一个激活的Activity组件的窗口设置为不可见，以及将新激活的Activity组件的窗口设置为可见。

整个切换过程是需要在ActivityManagerService服务和WindowManagerService服务的协作之下进行的，如图1所示。

WindowManagerService服务在执行Activity窗口的切换操作的时候，会给参与切换操作的Activity组件的设置一个动画，以便可以向用户展现一个Activity组件切换效果，从而提高用户体验。

事实上，一个Activity窗口在由不可见状态切换到可见状态的过程中，除了会被设置一个Activity组件切换动画之外，还有被设置一个窗口进入动画，此外，如果该Activity 窗口是附加在另外一个窗口之上的，并且这个被附加的窗口正在显示一个动画，那么这个动画也同时会被设置给到该Activity窗口的显示过程中去。

本文主要是关注Activity窗口的切换操作，在接下来的一篇文章中分析窗口的动画框架时，我们再详细分析上述三种动画是如何作用在窗口的显示过程中的。

startforegroundserviceasuser -回复

startforegroundserviceasuser -回复

startforegroundserviceasuser -回复什么是startForegroundServiceAsUser？startForegroundServiceAsUser是一个Android系统的方法，用于在后台启动一个前台服务。

它使应用程序能够在后台执行一些长时间运行的任务，并在通知栏中显示一个持久的通知。

为什么需要startForegroundServiceAsUser？在Android系统中，后台服务是受到限制的，即在后台运行的服务有一定的时间限制。

如果一个服务在后台运行超过一定时间，而没有在前台显示一个持久的通知，则系统可能会终止该服务。

这是为了避免过度耗电和资源浪费。

而startForegroundServiceAsUser方法的作用就是可以将服务提升为前台服务，并显示一个持久的通知，以允许服务在后台长时间运行而不被系统终止。

如何使用startForegroundServiceAsUser？使用startForegroundServiceAsUser方法启动一个前台服务，需要以下几个步骤：1. 在AndroidManifest.xml文件中为服务注册一个合适的权限。

这可以通过在<manifest>标签内添加<uses-permission>标签来实现。

2. 创建一个服务类，继承自Service类，并实现onCreate()、onStartCommand()和onDestroy()等必要的回调方法。

在onStartCommand()方法中，可以进行一些初始化操作，并返回一个合适的启动模式。

在onDestroy()方法中，可以进行一些释放资源的操作。

3. 在服务的onCreate()或onStartCommand()方法中，使用startForegroundServiceAsUser()方法启动前台服务。

该方法需要传入一个通知的ID和一个Notification对象作为参数。

鸿蒙OS 前台Service

鸿蒙OS 前台Service

一般情况下，Service都是在后台运行的，后台Service的优先级都是比较低的，当资源不足时，系统有可能回收正在运行的后台Service。

在一些场景下（如播放音乐），用户希望应用能够一直保持运行，此时就需要使用前台Service。

前台Service会始终保持正在运行的图标在系统状态栏显示。

使用前台Service并不复杂，开发者只需在Service创建的方法里，调用keepBackgroundRunning()将Service与通知绑定。

调用keepBackgroundRunning()方法前需要在配置文件中声明ohos.permission.KEEP_BACKGROUND_RUNNING权限，同时还需要在配置文件中添加对应的backgroundModes参数。

在onStop()方法中调用cancelBackgroundRunning()方法可停止前台Service。

使用前台Service的onStart()代码示例如下：1.// 创建通知，其中1005为notificationId2.NotificationRequest request = new NotificationRequest(1005);3.NotificationRequest.NotificationNormalContent content = newNotificationRequest.NotificationNormalContent();4.content.setTitle("title").setText("text");5.NotificationRequest.NotificationContent notificationContent = newNotificationRequest.NotificationContent(content);6.request.setContent(notificationContent);7.8.9.// 绑定通知，1005为创建通知时传入的notificationId10.k eepBackgroundRunning(1005, request);在配置文件中，“module > abilities”字段下对当前Service做如下配置：1.{2. "name": ".ServiceAbility",3. "type": "service",4. "visible": true,5. "backgroundModes": ["dataTransfer", "location"]6.}。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Android的前台Service
Service几乎都是在后台运行的，一直以来它都是默默地做着辛苦的工作。

但是Service的系统优先级还是比较低的，当系统出现内存不足情况时，就有可能会回收掉正在后台运行的Service。

如果你希望Service可以一直保持运行状态，而不会由于系统内存不足的原因导致被回收，就可以考虑使用前台Service。

前台Service和普通Service最大的区别就在于，它会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。

当然有时候你也可能不仅仅是为了防止Service被回收才使用前台Service，有些项目由于特殊的需求会要求必须使用前台Service，比如说墨迹天气，它的Service在后台更新天气数据的同时，还会在系统状态栏一直显示当前天气的信息，如下图所示：
那么我们就来看一下如何才能创建一个前台Service吧，其实并不复杂，如下所示：
这里只是修改了Service中onCreate()方法的代码。

可以看到，我们首先创建了一个Notification对象，然后调用了它的setLatestEventInfo()方法来为通知初始化布局和数据，并在这里设置了点击通知后就打开MainActivity。

然后调用startForeground()方法就可以让MyService变成一个前台Service，并会将通知的图片显示出来。

现在重新运行一下程序， Service就会以前台Service的模式启动了，并且在系统状态栏会弹出一个通栏图标，下拉状态栏后可以看到通知的详细内容，如下图所示：
亲爱的小伙伴们你们学会了么？没学会可以关注南京宝云的官方微信，与技术大牛在线交流哦~。

相关文档
最新文档