一、概念：
Service（服务）是Android中四大组件之一。是一个没有用户界面的在后台运行执行耗时操作的应用组件。其他应用组件能够启动Service，并且当用户切换到另外的应用场景，Service将持续在后台运行。另外，一个组件能够绑定到一个service与之交互（IPC机制），例如，一个service可能会处理网络操作，播放音乐，操作文件I/O或者与内容提供者（content provider）交互，所有这些活动都是在后台进行。
运行种类分类：
| 类别 | 区别 | 优点 | 缺点 | 应用 |
| 本地服务（Local） | 该服务依附在主进程上 | 服务依附在主进程上而不是独立的进程，这样在一定程度上节约了资源，另外Local服务因为是在同一进程因此不需要IPC，也不需要AIDL。相应bindService会方便很多 | 主进程被kill后，服务便会终止 | 非常常见的应用如：HTC音乐播放服务，天天动听音乐播放服务 |
| 远程服务（Remote） | 该服务是独立的进程 | 服务为独立的进程，对应进程名格式为所在包名加上你指定的android:process字符串。由于是独立的进程，因此在Activity所在进程被kill的时候，该服务依然在运行，不受其他进程影响，有利于为多个进程提供服务具有较高的灵活性 | 该服务是独立的进程，会占用一定资源，并且使用AIDL进行IPC，稍微麻烦一点 | 一些提供系统服务的Service，这种Service是常驻的 |
其实remote服务还是很少见的，并且一般都是系统服务
运行类型分类：
| 类别 | 区别 | 应用 |
| 前台服务 | 会在通知一栏显示ONGOING的Notification | 当服务被终止的时候，通知一栏Notification也会消失，这样对于用户有一定的通知作用。常见的如音乐播放服务 |
| 后台服务 | 默认的服务即为后台服务，即不会在通知一栏显示ONGOING的Notification | 当服务被终止的时候，用户是看不到效果的。某些不需要运行或终止提示的服务，如天气更新，日期同步，邮件同步等 |
前台服务会调用startForeground（Android2.0以前的版本为setForeground）使服务成为前台
启动方式分类
| 类别 | 区别 |
| startService启动 | 主要用于启动一个服务执行后台任务，不进行通信，停止服务使用stopService |
| bindService启动 | 该方法启动的服务要进行通信。停止服务使用unbindService |
| startService同时也gindService启动 | 停止服务同时使用stopService与unbindService |
二、生命周期：
首先看下周期运行图
1：Context.startService()启动的流程
启动的时候：Context.startService() ---> onCreate() ---> onStartCommand()（android2.0以前版本为onStart()）
销毁的时候：ontext.stopService() ---> onDestroy()
如果Service没运行，则此时会先调用onCreate()方法，然后再调用onStartCommand();
如果Service已经在运行，则只调用onStartCommand()
2：Context.bindService()启动的流程
启动的时候：Context.bindService() ---> onCreate() ---> onBind()
销毁的时候：onUnibind() ---> onDestroy()
onBind()将会給客户端返回一个IBind接口的实例，此时客户端可以去调用服务的方法，不过此时Activity与Service算是绑定在一起了，即bindService不存在（如Activity被finish()的时候)，那么此时的Service也会退出
3：退出条件（注意）
startService(一直运行，不管对应程序的Activity是否在运行)：
A、调用stopService
B、调用自身的stopSelf方法
C、当系统资源不足，可能被Android系统结束掉
bindService：
A、调用Context.unbindService断开连接（建议）
B、调用bindService的Context不存在了（如Activity被finish的时候、屏幕旋转时，Activity重新创建，之前的Context不存在了），系统会自动停止Service，对应onDestroy将被调用
startService与bindService：
A、同时满足上面两个退出条件，与顺序无关
服务退出后，onDestroy方法将会被调用，在这里应该做一些清除工作，如停止在Service中创建并运行的线程等
三、使用方法：
1：使用startService启动服务
不管Local还是Remote，启动与停止方法都是一样。在Androidmanifest.xml中注册service；
下面给出Service中的代码框架：
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
public class ExampleService extends Service {
/**
* Service的虚方法，不得不实现
* 返回null，
*/
@Override
public IBinder onBind(Intent intent) {
// TODO Auto-generated method stub
return null;
}
public void onCreate() {
super.onCreate();
}
public int onStartCommand (Intent intent, int flags, int startId) {
return super.onStartCommand(intent, flags, startId);
}
public void onDestroy () {
super.onDestroy();
}
} 启动：startService(new Intent(this, ExampleService.class));
启动：stopService(new Intent(this, ExampleService.class));
2：使用bindService启动服务
A、Local服务绑定：首先在Service中实现Service的抽象方法断断onBind，并返回一个实现IBinder接口的对象
下面为Service的代码：
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
public class LocalService extends Service {
/**
* 直接继承Binder而不是IBinder，因为Binder实现了IBnder接口，这样可以少做很多工作
*/
public class ExampleBinder extends Binder {
public LocalService getService() {
return LocalService.this;
}
public int addTest (int a, int b) {
return a + b;
}
}
public ExampleBinder eBinder = null;
@Override
public IBinder onBind(Intent intent) {
// TODO Auto-generated method stub
return eBinder;
}
public void onCreate() {
super.onCreate();
eBinder = new ExampleBinder();
}
} 上面方法主要在于onBind(Intent)返回了一个实现了IBinder接口的对象，这个对象将用于Activity与Local Service通信。
下面为Activity中的代码：
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
public class MainActivity extends Activity {
private ServiceConnection sc = null;
private boolean isBind = false;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
sc = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// TODO Auto-generated method stub
LocalService.ExampleBinder mBinder = (LocalService.ExampleBinder) service;
Log.d("test", "5 + 8 = " + mBinder.addTest(5, 8));
}
@Override
public void onServiceDisconnected(ComponentName arg0) {
// TODO Auto-generated method stub
}
};
findViewById(R.id.bt_bind).setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
// TODO Auto-generated method stub
bindService(new Intent(MainActivity.this, LocalService.class), sc, Context.BIND_AUTO_CREATE);
isBind = true;
}
});
findViewById(R.id.bt_unbind).setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
// TODO Auto-generated method stub
if(isBind) {
unbindService(sc);
isBind = false;
}
}
});
}
} 通过ServiceConnection接口来取得建立连接与连接意外丢失的回调。Service.onBind如果返回null，则调用bindService会启动Service，但不会连接上Service,因此ServiceConnection.onServiceConnected不会被调用，但仍然需要使用unbindService函数断开它
B、Remote服务绑定：Remote服务绑定由于服务是在另外一个进程，因此需要用到Android的IPC机制。
在AndroidManifest.xml中
<service android:enabled="true" android:name=".TestService" android:process=":remote"/>下面为ITestService.aidl的代码：
package com.iceskysl.TestServiceHolder;
interface ITestService
{
int getCount();
}下面为Service的代码：
package com.iceskysl.TestServiceHolder;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
public class TestService extends Service {
private static final String TAG = "TestService";
private NotificationManager _nm;
private boolean threadEnable = true;
private int i = 0;
private ITestService.Stub serviceBinder = new ITestService.Stub() {
@Override
public int getCount() throws RemoteException {
// TODO Auto-generated method stub
return i;
}
};
@Override
public IBinder onBind(Intent i) {
Log.e(TAG, "============> TestService.onBind");
return serviceBinder;
}
@Override
public boolean onUnbind(Intent i) {
Log.e(TAG, "============> TestService.onUnbind");
return false;
}
@Override
public void onRebind(Intent i) {
Log.e(TAG, "============> TestService.onRebind");
}
@Override
public void onCreate() {
Log.e(TAG, "============> TestService.onCreate");
_nm = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
showNotification();
new Thread() {
public void run() {
try {
while (threadEnable) {
sleep(1000);
Log.d(TAG, "Count = " + (++i));
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
}
@Override
public void onStart(Intent intent, int startId) {
Log.e(TAG, "============> TestService.onStart");
}
@Override
public void onDestroy() {
_nm.cancel(R.string.service_started);
threadEnable = false;
Log.e(TAG, "============> TestService.onDestroy");
}
private void showNotification() {
Notification notification = new Notification(R.drawable.face_1,
"Service started", System.currentTimeMillis());
PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
new Intent(this, TestServiceHolder.class), 0);
// must set this for content view, or will throw a exception
notification.setLatestEventInfo(this, "Test Service",
"Service started", contentIntent);
_nm.notify(R.string.service_started, notification);
}
public int getCount() {
return i;
}
}下面为Activity代码：
package com.iceskysl.TestServiceHolder;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;
public class TestServiceHolder extends Activity {
private boolean _isBound;
private ITestService _boundService = null;
private static final String TAG = "TestServiceHolder";
private IBinder _service;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
setTitle("Service Test");
initButtons();
}
private ServiceConnection _connection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
_boundService = ITestService.Stub.asInterface(service);
Toast.makeText(TestServiceHolder.this, "Service connected",
Toast.LENGTH_SHORT).show();
Log.e(TAG, "=====>onServiceConnected()");
}
public void onServiceDisconnected(ComponentName className) {
// unexpectedly disconnected,we should never see this happen.
_boundService = null;
Toast.makeText(TestServiceHolder.this, "Service connected",
Toast.LENGTH_SHORT).show();
Log.e(TAG, "<=====onServiceDisconnected()");
}
};
private void initButtons() {
Button buttonStart = (Button) findViewById(R.id.start_service);
buttonStart.setOnClickListener(new OnClickListener() {
public void onClick(View arg0) {
startService();
}
});
Button buttonStop = (Button) findViewById(R.id.stop_service);
buttonStop.setOnClickListener(new OnClickListener() {
public void onClick(View arg0) {
stopService();
}
});
Button buttonBind = (Button) findViewById(R.id.bind_service);
buttonBind.setOnClickListener(new OnClickListener() {
public void onClick(View arg0) {
bindService();
}
});
Button buttonUnbind = (Button) findViewById(R.id.unbind_service);
buttonUnbind.setOnClickListener(new OnClickListener() {
public void onClick(View arg0) {
unbindService();
}
});
}
private void startService() {
Intent i = new Intent(this, TestService.class);
this.startService(i);
}
private void stopService() {
Intent i = new Intent(this, TestService.class);
this.stopService(i);
}
private void bindService() {
Intent i = new Intent(this, TestService.class);
bindService(i, _connection, Context.BIND_AUTO_CREATE);
_isBound = true;
}
private void unbindService() {
if (_boundService != null) {
try {
Log.e(TAG,"_boundService.getCount() = "+ _boundService.getCount());
} catch (RemoteException e) {
e.printStackTrace();
}
}
if (_isBound) {
unbindService(_connection);
_isBound = false;
}
}
}四、创建前台服务
代码：
import java.lang.reflect.Method;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.IBinder;
public class ForegroundService extends Service {
private static final Class[] mStartForegroundSignature = new Class[] {
int.class, Notification.class };
private static final Class[] mStopForegroundSignature = new Class[] {
boolean.class };
private NotificationManager mNM = null;
private Method mStartForeground = null;
private Method mStopForeground = null;
private Object[] mStartForegroundArgs = new Object[2];
private Object[] mStopForegroundArgs = new Object[1];
@Override
public IBinder onBind(Intent intent) {
// TODO Auto-generated method stub
return null;
}
public void onCreate() {
super.onCreate();
mNM = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
try {
mStartForeground = ForegroundService.class.getMethod("startForeground", mStartForegroundSignature);
mStopForeground = ForegroundService.class.getMethod("stopForeground", mStopForegroundSignature);
} catch(NoSuchMethodException e) {
mStartForeground = mStopForeground = null;
}
// 我们并不需要为notification.flags 设置FLAG_ONGOING_EVENT,因为前台服务的notification.flags总是默认包含了那个标志位
Notification notification = new Notification(R.drawable.icon, "Foreground Service Started.", System.currentTimeMillis());
PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), 0);
notification.setLatestEventInfo(this, "Foreground Service", "Foreground Service Started.", contentIntent);
// 注意使用startForeground, id 为0将不会显示notification
startForegroundCompat(1, notification);
}
public void onDestroy() {
super.onDestroy();
stopForegroundCompat(1);
}
private void startForegroundCompat(int id, Notification n) {
if(mStartForeground != null) {
mStartForegroundArgs[0] = id;
mStartForegroundArgs[1] = n;
try {
mStartForeground.invoke(this, mStartForegroundArgs);
} catch(Exception e) {
e.printStackTrace();
}
return;
}
// API Level >= 5
startForeground(id, n);
// API Level < 5
/*startForeground();
mNM.notify(id, n);*/
}
private void stopForegroundCompat(int id) {
if(mStopForeground != null) {
mStopForegroundArgs[0] = Boolean.TRUE;
try {
mStopForeground.invoke(this, mStopForegroundArgs);
} catch(Exception e) {
e.printStackTrace();
}
return;
}
// API Level >= 5
stopForeground(true);
// API Level < 5
// 在setForeground之前调用cancel，因为我们有可能在取消前台服务之后的那一瞬间被kill掉。这个时候notification便永远不会从通知一栏移除mNM.cancel(id);
/*mNM.cancel(id);
setForeground(false);*/
}
}五、使用情景
1：如果你只是想要启动一个后台服务长期进行某项任务那么使用 startService 便可以了。
2：如果你想要与正在运行的 Service 取得联系
A、使用 broadcast，缺点是如果交流较为频繁，容易造成性能上的问题，并且 BroadcastReceiver 本身执行代码的时间是很短的（也许执行到一半，后面的代码便不会执行）
B、使用 bindService，没有上面的问题，因此选择使用 bindService（这个时候便同时在使用 startService 和 bindService 了，这在 Activity 中更新 Service 的某些运行状态是相当有用的）
3：如果你的服务只是公开一个远程接口，供连接上的客服端（android 的 Service 是C/S架构）远程调用执行方法。这个时候你可以不让服务一开始就运行，而只用 bindService ，这样在第一次 bindService 的时候才会创建服务的实例运行它，这会节约很多系统资源，特别是如果你的服务是Remote Service，那么该效果会越明显（当然在 Service 创建的时候会花去一定时间，你应当注意到这点）。
六、Service 元素的常见选项
android:name：服务类名
android:label：服务的名字，如果此项不设置，那么默认显示的服务名则为类名
android:icon：服务的图标
android:permission：申明此服务的权限，这意味着只有提供了该权限的应用才能控制或连接此服务
android:process：表示该服务是否运行在另外一个进程，如果设置了此项，那么将会在包名后面加上这段字符串表示另一进程的名字
android:enabled：如果此项设置为 true，那么 Service 将会默认被系统启动，不设置默认此项为 false
android:exported：表示该服务是否能够被其他应用程序所控制或连接，不设置默认此项为 false
2230
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
