标签： Activity

• 本地服务 Local Service 用于应用程序内部。
  它可以启动并运行，直至有人停止了它或它自己停止。在这种方式下，它以调用Context.startService()启动，而以调用Context.stopService()结束。它可以调用Service.stopSelf() 或 Service.stopSelfResult()来自己停止。不论调用了多少次startService()方法，你只需要调用一次stopService()来停止服务。
  用于实现应用程序自己的一些耗时任务，比如查询升级信息，并不占用应用程序比如Activity所属线程，而是单开线程后台执行，这样用户体验比较好。
• 远程服务 Remote Service 用于android系统内部的应用程序之间。
  它可以通过自己定义并暴露出来的接口进行程序操作。客户端建立一个到服务对象的连接，并通过那个连接来调用服务。连接以调用Context.bindService()方法建立，以调用 Context.unbindService()关闭。多个客户端可以绑定至同一个服务。如果服务此时还没有加载，bindService()会先加载它。
  可被其他应用程序复用，比如天气预报服务，其他应用程序不需要再写这样的服务，调用已有的即可。

1. public class LocalService extends Service {
3. private static final String TAG = “LocalService”;
5. @Override
6. public IBinder onBind(Intent intent) {
7. Log.i(TAG, “onBind”);
8. return null;
9. }
11. @Override
12. public void onCreate() {
13. Log.i(TAG, “onCreate”);
14. super.onCreate();
15. }
17. @Override
18. public void onDestroy() {
19. Log.i(TAG, “onDestroy”);
20. super.onDestroy();
21. }
23. @Override
24. public void onStart(Intent intent, int startId) {
25. Log.i(TAG, “onStart”);
26. super.onStart(intent, startId);
27. }
28. }

Activity:

1. public class ServiceActivity extends Activity {
3. @Override
4. protected void onCreate(Bundle savedInstanceState) {
5. super.onCreate(savedInstanceState);
6. setContentView(R.layout.servicedemo);
8. ((Button) findViewById(R.id.startLocalService)).setOnClickListener(
9. new View.OnClickListener(){
11. @Override
12. public void onClick(View view) {
13. // TODO Auto-generated method stub
14. startService(new Intent(“com.demo.SERVICE_DEMO”));
15. }
16. });
18. ((Button) findViewById(R.id.stopLocalService)).setOnClickListener(
19. new View.OnClickListener(){
21. @Override
22. public void onClick(View view) {
23. // TODO Auto-generated method stub
24. stopService(new Intent(“com.demo.SERVICE_DEMO”));
25. }
26. });
27. }
29. }

在AndroidManifest.xml添加：

1. <service android:name=“.LocalService”>
2. <intent-filter>
3. <action android:name=“com.demo.SERVICE_DEMO” />
4. <category android:name=“android.intent.category.default” />
5. </intent-filter>
6. </service>

1. /**
2. * This is an example of implementing an application service that runs locally
3. * in the same process as the application. The {@link LocalServiceController}
4. * and {@link LocalServiceBinding} classes show how to interact with the
5. * service.
6. *
7. * <p>Notice the use of the {@link NotificationManager} when interesting things
8. * happen in the service. This is generally how background services should
9. * interact with the user, rather than doing something more disruptive such as
10. * calling startActivity().
11. */
12. public class LocalService extends Service {
13. private NotificationManager mNM;
15. /**
16. * Class for clients to access. Because we know this service always
17. * runs in the same process as its clients, we don’t need to deal with
18. * IPC.
19. */
20. public class LocalBinder extends Binder {
21. LocalService getService() {
22. return LocalService.this;
23. }
24. }
26. @Override
27. public void onCreate() {
28. mNM = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
30. // Display a notification about us starting. We put an icon in the status bar.
31. showNotification();
32. }
34. @Override
35. public int onStartCommand(Intent intent, int flags, int startId) {
36. Log.i(“LocalService”, “Received start id “ + startId + “: “ + intent);
37. // We want this service to continue running until it is explicitly
38. // stopped, so return sticky.
39. return START_STICKY;
40. }
42. @Override
43. public void onDestroy() {
44. // Cancel the persistent notification.
45. mNM.cancel(R.string.local_service_started);
47. // Tell the user we stopped.
48. Toast.makeText(this, R.string.local_service_stopped, Toast.LENGTH_SHORT).show();
49. }
51. @Override
52. public IBinder onBind(Intent intent) {
53. return mBinder;
54. }
56. // This is the object that receives interactions from clients. See
57. // RemoteService for a more complete example.
58. private final IBinder mBinder = new LocalBinder();
60. /**
61. * Show a notification while this service is running.
62. */
63. private void showNotification() {
64. // In this sample, we’ll use the same text for the ticker and the expanded notification
65. CharSequence text = getText(R.string.local_service_started);
67. // Set the icon, scrolling text and timestamp
68. Notification notification = new Notification(R.drawable.stat_sample, text,
69. System.currentTimeMillis());
71. // The PendingIntent to launch our activity if the user selects this notification
72. PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
73. new Intent(this, LocalServiceController.class), 0);
75. // Set the info for the views that show in the notification panel.
76. notification.setLatestEventInfo(this, getText(R.string.local_service_label),
77. text, contentIntent);
79. // Send the notification.
80. // We use a layout id because it is a unique number. We use it later to cancel.
81. mNM.notify(R.string.local_service_started, notification);
82. }
83. }

1. /**
2. * <p>Example of binding and unbinding to the {@link LocalService}.
3. * This demonstrates the implementation of a service which the client will
4. * bind to, receiving an object through which it can communicate with the service.</p>
5. */
6. public class LocalServiceBinding extends Activity {
7. private boolean mIsBound;
8. private LocalService mBoundService;
10. @Override
11. protected void onCreate(Bundle savedInstanceState) {
12. super.onCreate(savedInstanceState);
14. setContentView(R.layout.local_service_binding);
16. // Watch for button clicks.
17. Button button = (Button)findViewById(R.id.bind);
18. button.setOnClickListener(mBindListener);
19. button = (Button)findViewById(R.id.unbind);
20. button.setOnClickListener(mUnbindListener);
21. }
23. private ServiceConnection mConnection = new ServiceConnection() {
24. public void onServiceConnected(ComponentName className, IBinder service) {
25. // This is called when the connection with the service has been
26. // established, giving us the service object we can use to
27. // interact with the service. Because we have bound to a explicit
28. // service that we know is running in our own process, we can
29. // cast its IBinder to a concrete class and directly access it.
30. mBoundService = ((LocalService.LocalBinder)service).getService();
32. // Tell the user about this for our demo.
33. Toast.makeText(LocalServiceBinding.this, R.string.local_service_connected,
34. Toast.LENGTH_SHORT).show();
35. }
37. public void onServiceDisconnected(ComponentName className) {
38. // This is called when the connection with the service has been
39. // unexpectedly disconnected — that is, its process crashed.
40. // Because it is running in our same process, we should never
41. // see this happen.
42. mBoundService = null;
43. Toast.makeText(LocalServiceBinding.this, R.string.local_service_disconnected,
44. Toast.LENGTH_SHORT).show();
45. }
46. };
48. private OnClickListener mBindListener = new OnClickListener() {
49. public void onClick(View v) {
50. // Establish a connection with the service. We use an explicit
51. // class name because we want a specific service implementation that
52. // we know will be running in our own process (and thus won’t be
53. // supporting component replacement by other applications).
54. bindService(new Intent(LocalServiceBinding.this,
55. LocalService.class), mConnection, Context.BIND_AUTO_CREATE);
56. mIsBound = true;
57. }
58. };
60. private OnClickListener mUnbindListener = new OnClickListener() {
61. public void onClick(View v) {
62. if (mIsBound) {
63. // Detach our existing connection.
64. unbindService(mConnection);
65. mIsBound = false;
66. }
67. }
68. };
69. }

1. <service android:name=“.app.LocalService” />
3. <activity android:name=“.app.LocalServiceBinding” android:label=“@string/activity_local_service_binding”>
4. <intent-filter>
5. <action android:name=“android.intent.action.MAIN” />
6. <category android:name=“android.intent.category.SAMPLE_CODE” />
7. </intent-filter>
8. </activity>