Service使用总结 与sdk部分翻译

 

 

1. Service SDK翻译

自己的翻译 英语不好 硬着头皮翻译了些：

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服务 是一种能够在后台执行长时间任务 但不提供UI的应用组件

其他的应用组件可开始一个Service服务，是它在后台继续运行 甚至是进程间通信IPC

比如 一个Service可以处理网络传输，音乐播放，文件读写操作，或是使用content provider，这些都是后台运行的

 

 

 

Service

This is the base class for all services. When you extend this class, it's important that you create a new thread in which to do all the service's work, because the service uses your application's main thread, by default, which could slow the performance of any activity your application is running.、

 

IntentService

This is a subclass of Service that uses a worker thread to handle all start requests, one at a time. This is the best option if you don't require that your service handle multiple requests simultaneously. All you need to do is implement onHandleIntent(), which receives the intent for each start request so you can do the background work.

 

Service

这是所有Service的父类，当你继承它时，一定要建立新的线程去执行Service的任务，因为这个service将会使用你应用的主线程，默认时他会拖慢你应用中正在运行的所有activity。

IntentService

这是一个Service的子类，它使用一个工作线程来一次一个的处理所有开始的请求。这是最好的选择，如果你不要求您的服务同时处理多个请求。你所要做的只是实现onHandleIntent()方法，用来接收处理每个intent请求，这些都是后台运行的。

 

 

Because most started services don't need to handle multiple requests simultaneously (which can actually be a dangerous multi-threading scenario), it's probably best if you implement your service using the IntentService class.

因为大部分开始的服务不需要同时处理多个请求（实际上这是一个危险的多线程的情况）。所以使用IntentService类实现服务可能是最好的方式了。

 

 

 

后面是摘自他人的 ，觉得不错转在这里，多多学习

 

2. Service的调用 
（1）Context.startService()：Service会经历onCreate -> onStart（如果Service还没有运行，则android先调用onCreate()然后调用onStart()；如果Service已经运行，则只调用onStart()，所以一个Service的onStart方法可能会重复调用多次 ）；stopService的时候直接onDestroy，如果是调用者自己直接退出而没有调用stopService的话，Service会一直在后台运行。该Service的调用者再启动起来后可以通过stopService关闭Service。 注意，多次调用Context.startservice()不会嵌套（即使会有相应的onStart()方法被调用），所以无论同一个服务被启动了多少次，一旦调用Context.stopService()或者stopSelf()，他都会被停止。补充说明：传递给startService()的Intent对象会传递给onStart()方法。调用顺序为：onCreate --> onStart(可多次调用) --> onDestroy。 
（2）Context.bindService()：Service会经历onCreate() -> onBind()，onBind将返回给客户端一个IBind接口实例，IBind允许客户端回调服务的方法，比如得到Service运行的状态或其他操作。这个时候把调用者（Context，例如Activity）会和Service绑定在一起，Context退出了，Srevice就会调用onUnbind -> onDestroyed相应退出，所谓绑定在一起就共存亡了 。
补充说明：传递给bindService()的Intent对象会传递给onBind()，传递给unbindService()的Intent对象会传递给onUnbind()方法。 调用顺序为：onCreate --> onBind(只一次，不可多次绑定) --> onUnbind --> onDestory。
（3）注意事项：在Service每一次的开启关闭过程中，只有onStart可被多次调用(通过多次startService调用)，其他onCreate，onBind，onUnbind，onDestory在一个生命周期中只能被调用一次。还有一点，目前我没有遇到过需要startService和bindService交互使用的情况（我认为不会有这种需求），所以不必去考虑交互的问题，待遇到时再考虑不迟。
（4）BroadcastReceiver只能通过startService启动Service ，因为广播本身生命周期很短，bind的话没有意义：Method bindService can not be called from an BroadcastReceiver component. A pattern you can use to communicate from an BroadcastReceiver to a Service is to call startService(Intent) with the arguments containing the command to be sent, with the service calling its stopSelf(int) method when done executing that command. See the API demo App/Service/Service Start Arguments Controller for an illustration of this. It is okay, however, to use this method from an BroadcastReceiver that has been registered with registerReceiver(BroadcastReceiver, IntentFilter), since the lifetime of this BroadcastReceiver is tied to another object (the one that registered it).

 

3. 示例代码

（1）调用者Activity

public class TServiceHolder extends Activity {
    private boolean isBound;
    private TService tService;
    private int statusCode;

    private ServiceConnection conn = new ServiceConnection() {
        // Called when a connection to the Service has been established, with the IBinder of the communication channel to the Service.
        public void onServiceConnected(ComponentName name, IBinder service) {
             tService = ( (TService.LocalBinder) service ).getService();
             statusCode = ( (TService.LocalBinder) service ).getStatusCode();
             Toast.makeText(TServiceHolder.this, "Service Connected", Toast.LENGTH_SHORT).show();
         }

        //无法被触发，原因未能找到
        public void onServiceDisconnected(ComponentName name) {
             tService = null;
             Toast.makeText(TServiceHolder.this, "Service DisConnected", Toast.LENGTH_SHORT).show();
         }
     };
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
         setContentView(R.layout.main);
         initButtons();
     }

    private void initButtons() {
         Button startButton = (Button) findViewById(R.id.startService);
         Button bindButton = (Button) findViewById(R.id.bindService);
         Button unbindButton = (Button) findViewById(R.id.unbindService);
         Button stopButton = (Button) findViewById(R.id.stopService);

         startButton.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
                 Intent i = new Intent(TServiceHolder.this, TService.class);
                 TServiceHolder.this.startService(i);
             }
         });
         bindButton.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
                 Intent i = new Intent(TServiceHolder.this, TService.class);
                 TServiceHolder.this.bindService(i, conn, Context.BIND_AUTO_CREATE);
                 isBound = true;
             }
         });
         unbindButton.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
                if (isBound) {
                     TServiceHolder.this.unbindService(conn);
                     isBound = false;
                 }
             }
         });
         stopButton.setOnClickListener(new Button.OnClickListener() {
            public void onClick(View v) {
                 Intent i = new Intent(TServiceHolder.this, TService.class);
                 TServiceHolder.this.stopService(i);
             }
         });
     }

}

（2）Service

public class TService extends android.app.Service {
    private final String TAG = "Service";
    private final int NOTIFICATION_ID = 1;
    private NotificationManager nManager;

    private LocalBinder localBinder = new LocalBinder();
    private int statusCode;

    public void onCreate() {
         Log.i(TAG, "Service.onCreate");
         nManager = (NotificationManager) getSystemService(android.content.Context.NOTIFICATION_SERVICE);
         showNotification();
     }
    private void showNotification() {
         Notification n = new Notification(R.drawable.face_1, "Service启动", System.currentTimeMillis());
         PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, TServiceHolder.class), 0);
         n.setLatestEventInfo(this, "任务标题", "任务内容", contentIntent);
         nManager.notify(NOTIFICATION_ID, n); // 任务栏启动
     }
    public void onStart(Intent intent, int startId) {
         Log.i(TAG, "Service.onStart");
     }
    public IBinder onBind(Intent intent) {
         Log.i(TAG, "Service.onBind");
        /*
          * 调用者和Service间是依靠IBinder对象进行通信的，Service的onBind()返回的IBinder对象传递给调用者中ServiceConnection对象的onServiceConnected()方法（以参数形式接收）；
          * TService的调用者就可以利用这个IBinder获得TService对象，进而对TService进行操作控制；
          * TService的调用者也可以利用这个IBinder获得其他信息，比如TService的状态statusCode。
          */
        return localBinder;
     }
    /*
      * 当应用程序bind一个Service后，该应用程序和Service之间就能进行互相通信，通常，这种通信的完成依靠于我们定义的一些接口，例如下面的LocalBinder。
      */
    class LocalBinder extends Binder {
        public TService getService() {
            return TService.this; // Service本身
         }
        public int getStatusCode() {
            return statusCode;
         }
     }
    public void onRebind(Intent i) {
         Log.i(TAG, "Service.onRebind");
     }
    public boolean onUnbind(Intent i) {
         Log.i(TAG, "Service.onUnbind");
        return false;
     }
    public void onDestroy() {
         nManager.cancel(NOTIFICATION_ID); // 任务栏关闭
         Log.i(TAG, "Service.onDestroy");
     }
}

4. 与远程Service通信（进程间Service通信）

如何两个进程间的Service需要进行通信，则需要把对象序列化后进行互相发送。
Android提供了一个 AIDL (Android接口定义语言)工具来处理序列化和通信。这种情况下Service需要以aidl文件的方式提供服务接口，AIDL工具将生成一个相应的java接口，并且在生成的服务接口中包含一个功能调用的stub服务桩类。Service的实现类需要去继承这个 stub服务桩类。Service的onBind方法会返回实现类的对象，之后你就可以使用它了，参见下例：
先创建一个IMyRemoteService.aidl文件，内容如下:

package com.wissen.testApp;

interface IMyRemoteService {
    int getStatusCode();
}

如果你正在使用eclipse的 Android插件，则它会根据这个aidl文件生成一个Java接口类。生成的接口类中会有一个内部类Stub类，你要做的事就是去继承该Stub类：

package com.wissen.testApp;

class RemoteService implements Service {
    int statusCode;
   
    @Override
    public IBinder onBind(Intent arg0) {
        return myRemoteServiceStub;
    }

    private IMyRemoteService.Stub myRemoteServiceStub = new IMyRemoteService.Stub() {
        public int getStatusCode() throws RemoteException {
            return 0;
        }
    };
   
    …
}

当客户端应用连接到这个Service时，onServiceConnected方法将被调用，客户端就可以获得IBinder对象。参看下面的客户端onServiceConnected方法：

…
ServiceConnection conn = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        IMyRemoteService myRemoteService = IMyRemoteService.Stub.asInterface(service);
        try {
            statusCode = myRemoteService.getStatusCode();
       } catch(RemoteException e) {
           // handle exception
       }
        Log.i(”INFO”, “Service bound “);
    }
   
    …
};