转载 android service 使用以及aidl使用

service
将android:exported属性声明为false，则无论你在manifest文件中声明了什么样的过滤条件，这个service都只能为你自己私用。



1:service的启动方式
service 是一个在后台运行的服务。你所启动的这个service所做得工作最好在另一个线程中做。因为这个service的线程的工作将阻塞调用它的线程。
在service的onCreate函数中你可能需要启动一个线程来完成service需要干的工作
public void onCreate() {
// Start up the thread running the service. Note that we create a
// separate thread because the service normally runs in the process's
// main thread, which we don't want to block. We also make it
// background priority so CPU-intensive work will not disrupt our UI.
HandlerThread thread = new HandlerThread("ServiceStartArguments",
Process.THREAD_PRIORITY_BACKGROUND);
thread.start();

// Get the HandlerThread's Looper and use it for our Handler
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}



创建和启动一个service有两种方式
Intent in = new Intent(***);
startService(in) 和 bindService(in)。
与上面相对应，停止一个service也有两种方式
stopService(in) 和 unbindService(in)。

但是不管一个service是如何启动的，它基本都是可以被客户端bind的，除非你禁止他这个功能。所以不要把start和bind看的过分分离



如果是本地的service 则 Intent in = new Intent(this,LocalService.class)。同时那个service要在manifest文件中标明自己的name
<service android:name = ".serviceA"/>

如果是非本地的service 则在Intent中指明就可以了Intent in= new Intent("com.test.A") 与此同时那个非本地的service也要在manifest文件中申明自己的name和intent-filter
<service android:name = ".serviceA">
<intent-filter>
<action android:name="com.test.A"/>
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</service>



2:使用startService 和 stopService
这种启动和停止方式是比较简单的。只需要在调用Activity中直接写上就可以了。

2.1service客户端代码
调用service的客户端的activity的代码：
package com.D_activity;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;


public class D_activity extends Activity {
Button b;
private boolean running = false;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
//设置一个按钮来开启和关闭服务
b=(Button)findViewById(R.id.button);
}
@Override
protected void onResume() {
//指定一个Intent
final Intent in = new Intent("com.test.A");
super.onResume();
b.setOnClickListener(new OnClickListener(){

@Override
public void onClick(View v) {
if(running){
running = false;
//关闭服务
stopService(in);
b.setText("start ");
}
else{
running = true;
//开启服务
startService(in);
b.setText("stop");
}
}

});
}
}


2.2 被startService()调用的service 的代码：
通过startService启动的service在service的生命周期中将调用：onCreate()->onStartCommand()->onDestory()。
onCreate 仅仅在第一次创建这个service的时候调用。

onStartCommand会在你使用startService()后调用,并且必须返回一个Int值用来表示这个service被系统杀掉后该如何处理。数值如下：

START_NOT_STICKY：系统将不再重新创建service

START_STICKY：系统将重现创建service并调用onStartCommand（）但不会使用上一次的Intent。

START_REDELIVER_INTENT:系统将重现创建service并调用onStartCommand（）并且会使用上一次的Intent。

如果你只实现了onStartCommand()那么由于无法onBind（）所以这将是你的service唯一与外界沟通的地方

onDestory会在你使用stopSerivce的时候调用。

以下代码将实现一个每5秒打印系统时间的service,多半代码都是从文档中直接拿过来的。
package com.A_s;


public class serviceA extends Service {

private boolean flag =true;
private Looper mServiceLooper;
private ServiceHandler mServiceHandler;

// Handler that receives messages from the thread
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
// Normally we would do some work here, like download a file.
// For our sample, we just sleep for 5 seconds.
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
while(flag){
synchronized (this) {
try {
Log.i("TEST","A :"+sdf.format(System.currentTimeMillis()));
wait(5*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// Stop the service using the startId, so that we don't stop
// the service in the middle of handling another job
stopSelf(msg.arg1);
}
}

@Override
public void onCreate() {
// Start up the thread running the service. Note that we create a
// separate thread because the service normally runs in the process's
// main thread, which we don't want to block. We also make it
// background priority so CPU-intensive work will not disrupt our UI.
HandlerThread thread = new HandlerThread("ServiceStartArguments",
Process.THREAD_PRIORITY_BACKGROUND);
thread.start();

// Get the HandlerThread's Looper and use it for our Handler
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();

// For each start request, send a message to start a job and deliver the
// start ID so we know which request we're stopping when we finish the job
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
mServiceHandler.sendMessage(msg);

// If we get killed, after returning from here, restart
return START_STICKY;
}

@Override
public IBinder onBind(Intent intent) {
// We don't provide binding, so return null
return null;
}

@Override
public void onDestroy() {
Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();
flag =false;
}
}

Manifest文件：
<service android:name = ".serviceA">
<intent-filter>
<action android:name="com.test.A"/>
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</service>



3:使用bindService和 unbindService
这种方式启动的service 生命周期中将调用：onCreate()->onBind()->onUnbind()->onDestory()。
在service中与之前startService最不同的一点是，这次service不再使用onStartCommand而是使用onBind.

客户端通过bindService去连接service的必须在自身实现ServiceConnection接口，用来处理回传的IBind

只有Activity provider service可以绑定到service上 但是broadcastReceiver不能

基于你的需求，你可以在activity的 onstart->onstop区间 或者 oncreate()->onDestroy()进行绑定和解绑定，但是千万不要再OnResume()->OnPause()进行，因为他会导致activity的频繁切换时频繁绑定和解绑定


@Override
public IBinder onBind(Intent intent) {
// We don't provide binding, so return null
Toast.makeText(this, "service starting in onBind", Toast.LENGTH_SHORT).show();
Message msg = mServiceHandler.obtainMessage();
mServiceHandler.sendMessage(msg);

return IBind;
}




3.1使用bindService的客户端的代码如下

这次的Activity明显比之前使用startService的Activity多了一点东西，就是多了ServiceConnection类。当bindService完成时，service会通过ServiceConnection类回调相关接口和回传IBind

当最后一个客户端调用unBind后，service将被系统销毁，除非service是被startService启动的


package com.C_activity;

public class C_activity extends Activity {
Button b;
private boolean running = false;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
b=(Button)findViewById(R.id.button);

}
@Override
protected void onResume() {
final Intent in = new Intent("com.test.E");
super.onResume();
b.setOnClickListener(new OnClickListener(){

@Override
public void onClick(View v) {
if(running){
running = false;
unbindService(sc);
b.setText("start ");
}
else{
running = true;
//bindService方法的最后一个参数有其特定的意义，最好找文档确定自己需要哪种
bindService(in, sc, 1);
b.setText("stop");
}
}

});
}


private ServiceConnection sc = new ServiceConnection(){

@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//你可以在这个地方处理service回传的IBinder，如果符合你的需求的话，这个IBinder甚至可以继承成你自己的IBinder，更方便操作。
}

@Override
public void onServiceDisconnected(ComponentName name) {
}
};

}

4:利用aidl 远程调用service
当service 不是本地的服务，也就不能通过onServiceConnected中的IBinder来强制转换成相应服务类来使用service提供的一些方法。这时就需要使用aidl了。
直观的去看，远程服务如果能够被操作，也需要提供一个操作的接口，而这个接口不光在服务器端实现，同时在客户端也需要知道调用和使用的方式；因此我们需要定义aidl文件来描述这么一个服务，也就是通过双方共享一个aidl文件的方式来共享一个接口。
在aidl里面定义了这个接口的内容之后， android的IDE帮助编译自动生成一个相应名字的java文件。这个java里面生成一个接口：test_aidl （extends android.os.IInterface） ，
同时，最主要的，里面有个桩： public static abstract class Stub extends android.os.Binder implements test_aidl

比如我写了一个叫test_aidl.aidl的文件 内容如下：
package com.E_s;
interface test_aidl{
int getCount();
}
那么在工程的gen目录下会自动生成一个test_aidl.java文件。然后在service中你就可以使用并实现这个接口中的方法。

private final test_aidl.Stub IBind = new test_aidl.Stub() {
@Override
public int getCount() throws RemoteException {
// TODO Auto-generated method stub
return i;
}
};

4.1 使用aidl的service端的全部代码如下：
package com.E_s;

public class serviceA extends Service {

private boolean flag =true;
private Looper mServiceLooper;
private ServiceHandler mServiceHandler;
public static int i = 0;

// Handler that receives messages from the thread
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
// Normally we would do some work here, like download a file.
// For our sample, we just sleep for 5 seconds.
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
while(flag){
synchronized (this) {
try {
i++;
Toast.makeText(serviceA.this, "E_s", Toast.LENGTH_SHORT).show();
Log.i("liyufei","E(A) :"+sdf.format(System.currentTimeMillis()));
wait(5*1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
// Stop the service using the startId, so that we don't stop
// the service in the middle of handling another job
// stopSelf(msg.arg1);
}
}

@Override
public void onCreate() {
// Start up the thread running the service. Note that we create a
// separate thread because the service normally runs in the process's
// main thread, which we don't want to block. We also make it
// background priority so CPU-intensive work will not disrupt our UI.
HandlerThread thread = new HandlerThread("ServiceStartArguments",
Process.THREAD_PRIORITY_BACKGROUND);
thread.start();

// Get the HandlerThread's Looper and use it for our Handler
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}

@Override
public IBinder onBind(Intent intent) {
Toast.makeText(this, "service starting in onBind", Toast.LENGTH_SHORT).show();

Message msg = mServiceHandler.obtainMessage();
mServiceHandler.sendMessage(msg);

return IBind;
}

private final test_aidl.Stub IBind = new test_aidl.Stub() {

@Override
public int getCount() throws RemoteException {
return i;
}
};

@Override
public void onDestroy() {
Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();
flag =false;
}
}


在客户端，你首先要在客户端的工程中也创建相应的包名和aidl文件。比如将文中的test_aidl.aidl也放入客户端的com.E_s包中。然后客户端中也会自动生成一个test_aidl.java文件。
然后就只需要将之前的使用bindService的客户端代码中的ServiceConnection方法中添加些东西就好了。
test_aidl testAidl;

private ServiceConnection sc = new ServiceConnection(){
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
testAidl = test_aidl.Stub.asInterface(service);
}
@Override
public void onServiceDisconnected(ComponentName name) {
testAidl = null;
}
};

然后你就可以使用这个ta就可以直接操作service中的方法了。比如testAidl.getCount();