Android中Service 使用详解（LocalService + RemoteService）

2022-04-07 16:08:08

Service 简介：

Service分为本地服务（LocalService）和远程服务（RemoteService）：

1、本地服务依附在主进程上而不是独立的进程，这样在一定程度上节约了资源，另外Local服务因为是在同一进程因此不需要IPC，也不需要AIDL。相应bindService会方便很多。主进程被Kill后，服务便会终止。

2、远程服务为独立的进程，对应进程名格式为所在包名加上你指定的android:process字符串。由于是独立的进程，因此在Activity所在进程被Kill的时候，该服务依然在运行，不受其他进程影响，有利于为多个进程提供服务具有较高的灵活性。该服务是独立的进程，会占用一定资源，并且使用AIDL进行IPC稍微麻烦一点。

按使用方式可以分为以下三种：

1、startService 启动的服务：主要用于启动一个服务执行后台任务，不进行通信。停止服务使用stopService；

2、bindService 启动的服务：该方法启动的服务可以进行通信。停止服务使用unbindService；

3、startService 同时也 bindService 启动的服务：停止服务应同时使用stepService与unbindService

Service的生命周期

onCreate　--　onStart　--　onDestroy　--　onBind

1). 被启动的服务的生命周期：如果一个Service被某个Activity 调用 Context.startService 方法启动，那么不管是否有Activity使用bindService绑定或unbindService解除绑定到该Service，该Service都在后台运行。如果一个Service被startService 方法多次启动，那么onCreate方法只会调用一次，onStart将会被调用多次（对应调用startService的次数），并且系统只会创建Service的一个实例（因此你应该知道只需要一次stopService调用）。该Service将会一直在后台运行，而不管对应程序的Activity是否在运行，直到被调用stopService，或自身的stopSelf方法。当然如果系统资源不足，android系统也可能结束服务。

2). 被绑定的服务的生命周期：如果一个Service被某个Activity 调用 Context.bindService 方法绑定启动，不管调用 bindService 调用几次，onCreate方法都只会调用一次，同时onStart方法始终不会被调用。当连接建立之后，Service将会一直运行，除非调用Context.unbindService 断开连接或者之前调用bindService 的 Context 不存在了（如Activity被finish的时候），系统将会自动停止Service，对应onDestroy将被调用。

3). 被启动又被绑定的服务的生命周期：如果一个Service又被启动又被绑定，则该Service将会一直在后台运行。并且不管如何调用，onCreate始终只会调用一次，对应startService调用多少次，Service的onStart便会调用多少次。调用unbindService将不会停止Service，而必须调用 stopService 或 Service的 stopSelf 来停止服务。

4). 当服务被停止时清除服务：当一个Service被终止（1、调用stopService；2、调用stopSelf；3、不再有绑定的连接（没有被启动））时，onDestroy方法将会被调用，在这里你应当做一些清除工作，如停止在Service中创建并运行的线程。

特别注意：

1、你应当知道在调用 bindService 绑定到Service的时候，你就应当保证在某处调用 unbindService 解除绑定（尽管 Activity 被 finish 的时候绑定会自　　　　　　动解除，并且Service会自动停止）；

2、你应当注意 使用 startService 启动服务之后，一定要使用 stopService停止服务，不管你是否使用bindService；

3、同时使用 startService 与 bindService 要注意到，Service 的终止，需要unbindService与stopService同时调用，才能终止 Service，不管 startService 与 bindService 的调用顺序，如果先调用 unbindService 此时服务不会自动终止，再调用 stopService 之后服务才会停止，如果先调用 stopService 此时服务也不会终止，而再调用 unbindService 或者 之前调用 bindService 的 Context 不存在了（如Activity 被 finish 的时候）之后服务才会自动停止；

4、当在旋转手机屏幕的时候，当手机屏幕在“横”“竖”变换时，此时如果你的 Activity 如果会自动旋转的话，旋转其实是 Activity 的重新创建，因此旋转之前的使用 bindService 建立的连接便会断开（Context 不存在了），对应服务的生命周期与上述相同。

5、在 sdk 2.0 及其以后的版本中，对应的 onStart 已经被否决变为了 onStartCommand，不过之前的 onStart 任然有效。这意味着，如果你开发的应用程序用的 sdk 为 2.0 及其以后的版本，那么你应当使用 onStartCommand 而不是 onStart。

Android中Thread和Service的区别zz - petercao - 博客园
http://www.cnblogs.com/bluestorm/p/5704264.html

LocalService代码示例：

首先，因为要再Manifest文件里对服务进行注册，所以就先来Manifest的代码吧~

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3. package="com.test.localservice" android:versionCode="1"
  4. android:versionName="1.0">
  5. <uses-sdk android:minSdkVersion="8" />
  6. <application android:icon="@drawable/icon" android:label="@string/app_name">
  7. <activity android:name=".LocalServiceTestActivity"
  8. android:label="@string/app_name">
  9. <intent-filter>
  10. <action android:name="android.intent.action.MAIN" />
  11. <category android:name="android.intent.category.LAUNCHER" />
  12. </intent-filter>
  13. </activity>
  14. <service android:name=".MyService">
  15. <intent-filter>
  16. <action android:name="com.test.SERVICE_TEST" />
  17. <category android:name="android.intent.category.default" />
  18. </intent-filter>
  19. </service>
  20. </application>
  21. </manifest>

然后然后，是服务实现类~

  1. package com.test.service;
  2. import android.app.Service;
  3. import android.content.Intent;
  4. import android.os.Binder;
  5. import android.os.IBinder;
  6. import android.util.Log;
  7. public class MyService extends Service {
  8. public class LocalBinder extends Binder {
  9. String stringToSend = "I'm the test String";
  10. MyService getService() {
  11. Log.i("TAG", "getService ---> " + MyService.this);
  12. return MyService.this;
  13. }
  14. }
  15. private final IBinder mBinder = new LocalBinder();
  16. @Override
  17. public IBinder onBind(Intent intent) {
  18. Log.i("TAG", "onBind~~~~~~~~~~~~");
  19. return mBinder;
  20. }
  21. @Override
  22. public void onCreate() {
  23. super.onCreate();
  24. Log.i("TAG", "onCreate~~~~~~~~~~");
  25. }
  26. @Override
  27. public void onDestroy() {
  28. super.onDestroy();
  29. Log.i("TAG", "onDestroy~~~~~~~~~~~");
  30. }
  31. @Override
  32. public void onStart(Intent intent, int startId) {
  33. super.onStart(intent, startId);
  34. Log.i("TAG", "onStart~~~~~~");
  35. }
  36. @Override
  37. public int onStartCommand(Intent intent, int flags, int startId) {
  38. Log.i("TAG", "onStartCommand~~~~~~~~~~~~");
  39. return super.onStartCommand(intent, flags, startId);
  40. }
  41. @Override
  42. public boolean onUnbind(Intent intent) {
  43. Log.i("TAG", "onUnbind~~~~~~~~~~~~~~~~");
  44. return super.onUnbind(intent);
  45. }
  46. }

再来，就是我们的Activity的测试类啦~

    1. <pre name="code" class="java">package com.test.service;
    2. import android.app.Activity;
    3. import android.content.ComponentName;
    4. import android.content.Context;
    5. import android.content.Intent;
    6. import android.content.ServiceConnection;
    7. import android.media.MediaPlayer;
    8. import android.os.Bundle;
    9. import android.os.IBinder;
    10. import android.util.Log;
    11. import android.view.View;
    12. import android.view.View.OnClickListener;
    13. import android.widget.Button;
    14. public class ServiceTestActivity extends Activity {
    15. private Button startButton, bindButton;
    16. private Button stopButton, unbindButton;
    17. private ServiceConnection sc;
    18. private MediaPlayer mediaPlayer = null;
    19. private MyService myService;
    20. @Override
    21. public void onCreate(Bundle savedInstanceState) {
    22. super.onCreate(savedInstanceState);
    23. setContentView(R.layout.main);
    24. startButton = (Button) findViewById(R.id.startbutton_id);
    25. stopButton = (Button) findViewById(R.id.stopbutton_id);
    26. bindButton = (Button) findViewById(R.id.bindbutton_id);
    27. unbindButton = (Button) findViewById(R.id.unbindbutton_id);
    28. sc = new ServiceConnection() {
    29. @Override
    30. public void onServiceConnected(ComponentName name, IBinder service) {
    31. myService = ((MyService.LocalBinder) service).getService();
    32. String recStr = ((MyService.LocalBinder) service).stringToSend;
    33. Log.i("TAG","The String is : " + recStr);
    34. Log.i("TAG", "onServiceConnected : myService ---> " + myService);
    35. }
    36. @Override
    37. public void onServiceDisconnected(ComponentName name) {
    38. sc = null;
    39. Log.i("TAG", "onServiceDisconnected : ServiceConnection --->"
    40. + sc);
    41. }
    42. };
    43. startButton.setOnClickListener(new OnClickListener() {
    44. @Override
    45. public void onClick(View v) {
    46. Intent intent = new Intent(ServiceTestActivity.this,
    47. MyService.class);
    48. startService(intent);
    49. Log.i("TAG", "Start button clicked");
    50. }
    51. });
    52. stopButton.setOnClickListener(new OnClickListener() {
    53. @Override
    54. public void onClick(View v) {
    55. Intent intent = new Intent();
    56. intent.setAction("com.test.SERVICE_TEST");
    57. stopService(intent);
    58. Log.i("TAG", "Stop Button clicked");
    59. }
    60. });
    61. bindButton.setOnClickListener(new OnClickListener() {
    62. @Override
    63. public void onClick(View v) {
    64. Intent intent = new Intent();
    65. intent.setAction("com.test.SERVICE_TEST");
    66. bindService(intent, sc, Context.BIND_AUTO_CREATE);
    67. Log.i("TAG", "Bind button clicked");
    68. }
    69. });
    70. unbindButton.setOnClickListener(new OnClickListener() {
    71. @Override
    72. public void onClick(View v) {
    73. unbindService(sc);
    74. Log.i("TAG", "Unbind Button clicked");
    75. }
    76. });
    77. }
    78. }
上一篇：Kubernetes K8S之Service服务详解与示例


下一篇：Android中的动画详解系列【4】——Activity之间切换动画