Android_Service组件详解

public abstract class IntentService extends Service {
private volatile Looper mServiceLooper;
private volatile ServiceHandler mServiceHandler;
private String mName;
private boolean mRedelivery;

private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}

@Override
public void handleMessage(Message msg) {
onHandleIntent((Intent)msg.obj);
stopSelf(msg.arg1);
}
}

@Override
public void onCreate() {
super.onCreate();
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
thread.start();
/*
* 在thread.start();	对应执行的run方法中，执行了
* Looper.prepare();
* Looper.loop();
* 操作，然后将生成的looper作为参数，传递到handler中，虽然该handler在主线程中创建，
* 但是由于为其制定了looper，故工作线程在阻塞掉用Loop.loop()，调用依然在工作线程中，
* 耗时操作可以方法onHandleIntent中，可以处理接收到intent对象
*/
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}

@Override
public void onStart(Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}

protected abstract void onHandleIntent(Intent intent);
}

(1).START_NOT_STICKY

public class MainActivity extends Activity {

private ProgressBar bar;
private IMyBinder mBinder;
private Handler handler = new Handler(){
public void handleMessage(Message msg) {
bar.setProgress(Integer.parseInt(msg.obj.toString()));
}
};

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
bar = (ProgressBar) findViewById(R.id.progressBar1);
startService(new Intent(this, MyService.class));
bindService(new Intent(this, MyService.class), conn, Context.BIND_AUTO_CREATE);
}

public void click(View view){
mBinder.doLongWork();
}
private ServiceConnection conn = new ServiceConnection() {

@Override
public void onServiceDisconnected(ComponentName name) {
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mBinder = (IMyBinder) service;

//得到binder对象，为其设定handler对象
mBinder.setHandler(handler);
};
};
}

public class MyService extends Service {

private Handler mHandler;
private Mybinder binder;
@Override
public void onCreate() {
super.onCreate();
binder = new Mybinder();
}

@Override
public IBinder onBind(Intent intent) {
return binder;
}

class Mybinder extends Binder implements IMyBinder{

@Override
public void setHandler(Handler handler) {
//用于接收handler对象，完成ui的更新
mHandler = handler;
}

@Override
public void doLongWork() {
//开启线程，完成耗时操作
new Thread(){
public void run() {
for(int i=0; i<11; i++){
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("i = "+i);
Message msg = mHandler.obtainMessage();
msg.obj = i*10;
mHandler.sendMessage(msg);
}
}
}.start();
}
}
}

/**
* 提供一个公共接口
* @author Administrator
*
*/
public interface IMyBinder {
public void setHandler(Handler handler);
public void doLongWork();
}

(1).本地服务

(1).通用型(本地/远程)

1).广播接收者

/**
* TestService.java
* 允许第三方应用，启动该服务完成计算的功能，第三方广播的intent设置需要计算的参数，
* 在内部类广播接收者中获得该参数信息，并调用服务的方法，完成计算功能
* @author Administrator
*/
public class TestService extends Service {
private MyReceiver receiver;

@Override
public void onCreate() {
/*
* 服务开启的时候注册一个广播接收者，广播接收者注册不用再清单文件中配置
* 其action为com.baidu.caluservice2
*/
receiver = new MyReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction("com.baidu.caluservice2");
registerReceiver(receiver, filter);	//注册接收者
super.onCreate();
}

//内部类的广播接收者
class MyReceiver extends BroadcastReceiver{
@Override
public void onReceive(Context context, Intent intent) {
//得到传递的参数信息
int m = intent.getIntExtra("m", 0);
int n = intent.getIntExtra("n", 0);
// 调用服务的计算功能
int result = methodService(m, n);
Toast.makeText(getApplicationContext(), m+"+"+n+"="+result, Toast.LENGTH_SHORT).show();
}
}

//服务计算功能
public int methodService(int m, int n){
int result = m*n;
return result;
}

@Override
public IBinder onBind(Intent intent) {
// TODO Auto-generated method stub
return null;
}
// 对于注册的广播接收者，在服务销毁时，应该解除广播的注册
@Override
public void onDestroy() {
unregisterReceiver(receiver);
super.onDestroy();
}
}

<!-- AndroidManifest.xml -->
<service android:name="com.baidu.calu.TestService">
<intent-filter>
<action android:name="com.baidu.caluservice"/>
</intent-filter>
</service>

/**
* TestService.java
* 第三方应用发送一个携带传递参数的广播，通过其它应用的服务，完成计算的功能
* @author Administrator
*
*/
public class MainActivity extends Activity {
private EditText textm;
private EditText textn;
private Intent intent;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textm = (EditText) this.findViewById(R.id.textm);
textn = (EditText) this.findViewById(R.id.textn);

//首先应该启动第三方服务，完成广播接收者注册初始化
intent = new Intent();
intent.setAction("com.baidu.caluservice");
startService(intent);
}
public void start(View view){

//发送一个广播，并未intent设置需要传递的参数信息
Intent intent2 = new Intent();
intent2.setAction("com.baidu.caluservice2");
//设置需要传递 的参数信息
intent2.putExtra("m", Integer.parseInt(textm.getText().toString()));
intent2.putExtra("n", Integer.parseInt(textn.getText().toString()));
sendBroadcast(intent2);
}
@Override
protected void onDestroy() {
stopService(intent);
super.onDestroy();
}
}

2).Parcel

private ServiceConnection conn = new ServiceConnection() {

@Override
public void onServiceDisconnected(ComponentName name) {
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInt(10);
data.writeInt(20);
try {
/*
* transact()，将包含数据的data，调用binder对象的onTransact()方法，
* 接收onTransact()写入的数据reply，通过reply得到执行结果
* 实际上，service中的binder的onTransact()方法在主线程中调用，不能执行耗时操作
* 可以在执行service.transact(100, data, reply, 0);时使用多线程
*/
service.transact(100, data, reply, 0);
int result = reply.readInt();
//得到结果
} catch (RemoteException e) {
e.printStackTrace();
}
data.recycle();
reply.recycle();
};
};

public class MyService extends Service {

private Mybinder binder;
@Override
public void onCreate() {
super.onCreate();
binder = new Mybinder();
}

@Override
public IBinder onBind(Intent intent) {
return binder;
}

class Mybinder extends Binder{

@Override
protected boolean onTransact(int code, Parcel data, Parcel reply,
int flags) throws RemoteException {
/*
* Parcel data	activity写入的数据
* Parcel reply	执行完成之后写入的数据
*/
int x = data.readInt();
int y = data.readInt();
reply.writeInt(x+y);

return super.onTransact(code, data, reply, flags);
}
}
}

(2).代理通信

1).本地Binder通信

/**
* MainActivity.java
* @author Administrator
*
*/
public class MainActivity extends Activity {
private EditText textm;
private EditText textn;
private IMyBinder binder;	//Binder对象
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textm = (EditText) this.findViewById(R.id.textm);
textn = (EditText) this.findViewById(R.id.textn);
}
public void start(View view){
Intent intent = new Intent(this, CalService.class);
// 绑定服务
bindService(intent, new MyServiceConn(), Context.BIND_AUTO_CREATE);
}
class MyServiceConn implements ServiceConnection{
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//service返回Binderdialing对象，由于代理对象私有，只能强转为其实现的接口类型
binder = (IMyBinder) service;
String m = textm.getText().toString();
String n = textn.getText().toString();
try {
//调用binder的方法，从而调用service内部计算方法，并得到计算的返回值
int result = binder.method(Integer.parseInt(m), Integer.parseInt(n));
Toast.makeText(MainActivity.this, m+"+"+n+"="+result, Toast.LENGTH_SHORT).show();
} catch (Exception e) {
e.printStackTrace();
}
}
//服务异常退出或者终止时才调用该方法
@Override
public void onServiceDisconnected(ComponentName name) {
}
}
}

/**
* IMyBinder.java
* 供代理类继承，并暴露代理类的方法，供调用者使用
* @author Administrator
*
*/
interface IMyBinder {
int method(int m, int n);
}

/**
* CalService.java
* 计算服务
* @author Administrator
*
*/
public class CalService extends Service {
private MyBinder binder;
@Override
public void onCreate() {
binder = new MyBinder();
super.onCreate();
}
//每次绑定会调用该方法
@Override
public IBinder onBind(Intent intent) {
return binder;
}
//内部代理类，该类应该设置为私有的，只向外暴露继承接口的方法
private class MyBinder extends Binder implements IMyBinder {
@Override
public int method(int m, int n) {
//调用服务内部方法
int result = methodService(m, n);
return result;
}
}
// 服务计算功能
public int methodService(int m, int n) {
int result = m + n;
return result;
}
}

2) .远程aidl通信

/**
* TestService.java
* 允许第三方应用，启动该服务完成计算的功能，第三方广播的intent设置需要计算的参数，
* 在内部类广播接收者中获得该参数信息，并调用服务的方法，完成计算功能
* @author Administrator
*
*/
public class TestService extends Service {

private MyBinder binder;
@Override
public void onCreate() {
System.out.println("onCreate");
binder = new MyBinder();
super.onCreate();
}
//返回Binder对象
@Override
public IBinder onBind(Intent intent) {
System.out.println("onBind");
return binder;
}
//直接继承IMyBinder的Stub内部类，由于该类已经继承了Binder
private class MyBinder extends IMyBinder.Stub{
@Override
public int method(int m, int n) throws RemoteException {
//调用service方法
int result = methodService(m, n);
return result;
}
}
//计算中心
public int methodService(int m, int n){
int result = m*n;
return result;
}
}

/**
* 服务下的IMyBinder.aidl文件
* aidl文件，该文件定义不能使用public使用权限，由于接口已经默认为public，该文件会自动编译
* 调用该服务的应用也应该声明同样的IMyBinder.aidl文件，注意包名也应该一致
* @author Administrator
*
*/
interface IMyBinder {
int method(int m, int n);
}

/**
* MainActivity.java
* 第三方应用发送一个携带传递参数的广播，通过其它应用的服务，完成计算的功能
* @author Administrator
*
*/
public class MainActivity extends Activity {
private EditText textm;
private EditText textn;
private IMyBinder binder;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textm = (EditText) this.findViewById(R.id.textm);
textn = (EditText) this.findViewById(R.id.textn);
}
public void start(View view){
//绑定服务
Intent intent = new Intent();
intent.setAction("com.baidu.caluservice");
bindService(intent, new MyServiceConn(), Context.BIND_AUTO_CREATE);
}
class MyServiceConn implements ServiceConnection{
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//得到服务onBind返回的Binder对象
binder = IMyBinder.Stub.asInterface(service);	//使用该方式得到返回的接口对象
String m = textm.getText().toString();
String n = textn.getText().toString();
try {
//调用binder方法，并得到返回值
int result = binder.method(Integer.parseInt(m), Integer.parseInt(n));
Toast.makeText(MainActivity.this, m+"+"+n+"="+result, Toast.LENGTH_SHORT).show();
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
}
}

/**
* 第三方应用的IMyBinder.aidl文件
* 注意包名应该与服务的包名一致
* @author Administrator
*
*/
interface IMyBinder {
int method(int m, int n);
}