跨进程调用 Service（AIDL Service）

最新推荐文章于 2024-04-05 12:17:38 发布

xiaobaiooo

最新推荐文章于 2024-04-05 12:17:38 发布

阅读量406

点赞数

分类专栏： android 文章标签： android Service AIDL

android 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

根据疯狂Android讲义学习：

AIDL Service 是一个跨进程通信IPC服务（Interprocess Communication），类似于JAVA的CORBA、RMI。

AIDL Service 简介

和JAVA RMI类似，都需要先定义远程调用接口，然后为该接口提供一个实现类。

不同的是RMI会将对象返回给客户端，而AIDL则是将Service的代理对象(IBinder对象)通过onBind()返回给客户端，因此AIDL的远程实现类就是IBinder的实现类。

绑定本地Service会将IBinder对象传给调用者ServiceConnection的onServiceConnected方法作为参数，但远程AIDL Service调用只是将IBinder的代理对象传过去。

创建AIDL文件

RMI是由JAVA直接定义的，但AIDL Service是由AIDL（Android Interface Definition Language）语言定义的。

AIDL和JAVA类似，区别主要在一下两点：

AIDL定义接口的源代码文件必须以.aidl结尾。
AIDL的数据类型（除了基本类型、String、List、Map、CharSequence）需要导包。

下边是一个简单的AIDL接口：

package org.crazyit.service;

interface ICat
{
	String getColor();
	double getWeight();
}

ADT下边的aidl.exe工具会自动生成实现类在gen目录下，该类包含一个内部类Stub，这个内部类实现了IBinder接口和咱们定义的AIDL接口ICat，会作为onBind()的返回值。

将接口暴露给客户端

定义完AIDL接口之后就可以定义实现的Service类了。该类里的内部类IBinder是ICat.Stub的子类。

/**
 *
 */
package org.crazyit.service;

import java.util.Timer;
import java.util.TimerTask;

import org.crazyit.service.ICat.Stub;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;

public class AidlService extends Service
{
	private CatBinder catBinder;
	Timer timer = new Timer();
	String[] colors = new String[]{
		"红色",
		"黄色",
		"黑色"
	};
	double[] weights = new double[]{
		2.3,
		3.1,
		1.58
	};
	private String color;
	private double weight;
	// 继承Stub，也就是实现额ICat接口，并实现了IBinder接口
	public class CatBinder extends Stub
	{
		@Override
		public String getColor() throws RemoteException
		{
			return color;
		}
		@Override
		public double getWeight() throws RemoteException
		{
			return weight;
		}
	}
	@Override
	public void onCreate()
	{
		super.onCreate();
		catBinder = new CatBinder();
		timer.schedule(new TimerTask()
		{
			@Override
			public void run()
			{
				// 随机地改变Service组件内color、weight属性的值。
				int rand = (int)(Math.random() * 3);
				color = colors[rand];
				weight = weights[rand];
				System.out.println("--------" + rand);
			}
		} , 0 , 800);
	}
	@Override
	public IBinder onBind(Intent arg0)
	{
		/* 返回catBinder对象
		 * 在绑定本地Service的情况下，该catBinder对象会直接
		 * 传给客户端的ServiceConnection对象
		 * 的onServiceConnected方法的第二个参数；
		 * 在绑定远程Service的情况下，只将catBinder对象的代理
		 * 传给客户端的ServiceConnection对象
		 * 的onServiceConnected方法的第二个参数；
		 */
		return catBinder; //①
	}
	@Override
	public void onDestroy()
	{
		timer.cancel();
	}
}

子类CatBinder集成了Stub类，也就实现了ICat AIDL接口和IBinder接口，作为onBind的返回对象，给到客户端的ServiceConnection对象。
至此一个AIDL Service就实现了，它只是比普通的Service多了一个AIDL接口。然后让服务里的Binder代理实现这个接口，就可以让跨进程访问者访问服务了。

将此服务配置到AndroidManifest.xml文件里，就可以安装到手机里了，因为没有配置Activity对象，所以应用不能被看到，但这个AIDL Serviec可以被其他应用访问。

客户端访问AIDL Service

AIDL Service的访问者也许要之前定义的AIDL接口，把ICat.aidl文件复制到访问应用中，然后ADT生成实现代码。

具体访问方法和一般的Service类似，在访问者里定义ServiceConnection子类，在bindService()方法中把ServiceConnection对象作为参数。

唯一的区别是onServiceConnected方法不能直接取到远程IBinder对象，需要通过以下代码获取IBinder的代理对象：

catService = ICat.Stub.asInterface(service); //catService是一个ICat全局变量,service是onServiceConnected的IBinder参数。

下边是一个访问者应用的代码，有一个按钮，两个文本框组成，点击按钮后绑定远程的AIDL Service，取得它的数据然后显示在文本框里：

package org.crazyit.client;

import org.crazyit.service.ICat;

import android.app.Activity;
import android.app.Service;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

public class AidlClient extends Activity
{
	private ICat catService;
	private Button get;
	EditText color, weight;
	private ServiceConnection conn = new ServiceConnection()
	{
		@Override
		public void onServiceConnected(ComponentName name
			, IBinder service)
		{
			// 获取远程Service的onBind方法返回的对象的代理
			catService = ICat.Stub.asInterface(service);
		}

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

	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		get = (Button) findViewById(R.id.get);
		color = (EditText) findViewById(R.id.color);
		weight = (EditText) findViewById(R.id.weight);
		// 创建所需绑定的Service的Intent
		Intent intent = new Intent();
		intent.setAction("org.crazyit.aidl.action.AIDL_SERVICE");
		// 绑定远程Service
		bindService(intent, conn, Service.BIND_AUTO_CREATE);
		get.setOnClickListener(new OnClickListener()
		{
			@Override
			public void onClick(View arg0)
			{
				try
				{
					// 获取、并显示远程Service的状态
					color.setText(catService.getColor());
					weight.setText(catService.getWeight() + "");
				}
				catch (RemoteException e)
				{
					e.printStackTrace();
				}
			}
		});
	}

	@Override
	public void onDestroy()
	{
		super.onDestroy();
		// 解除绑定
		this.unbindService(conn);
	}
}

总结一下AIDL Service访问者和一般Service的访问者有两点区别：

一是需要复制AIDL接口（ICat.aidl）到访问者应用，二是ServiceConnection获取的IBinder实例是通过代理获取的。

实例：传递复杂数据的AIDL Service

下边的例子定义了两个复杂的数据类型Person和Pet，一个Person有多个Pets。AIDL Service里有Person和Pets实例，访问者想获取具体的数据。

首先是定义Person和Pet类。Person作为参数，Pet作为返回值都必须实现Parcelable接口（就像RMI要求实现的Serializable接口）。

首先是Person和Pet的AIDL文件，分别只有一行代码：

Person.aidl

parcelable Person;

Pet.aidl

parcelable Pet;

然后是Person.java 和 Pet.java

package org.crazyit.service;

import android.os.Parcel;
import android.os.Parcelable;

public class Person implements Parcelable
{
	private Integer id;
	private String name;
	private String pass;

	public Person()
	{
	}
	public Person(Integer id, String name, String pass)
	{
		super();
		this.id = id;
		this.name = name;
		this.pass = pass;
	}
	public Integer getId()
	{
		return id;
	}
	public void setId(Integer id)
	{
		this.id = id;
	}
	public String getName()
	{
		return name;
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public String getPass()
	{
		return pass;
	}
	public void setPass(String pass)
	{
		this.pass = pass;
	}
	@Override
	public int hashCode()
	{
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + ((pass == null) ? 0 : pass.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj)
	{
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (name == null)
		{
			if (other.name != null)
				return false;
		}
		else if (!name.equals(other.name))
			return false;
		if (pass == null)
		{
			if (other.pass != null)
				return false;
		}
		else if (!pass.equals(other.pass))
			return false;
		return true;
	}
	// 实现Parcelable接口必须实现的方法
	@Override
	public int describeContents()
	{
		return 0;
	}
	// 实现Parcelable接口必须实现的方法
	@Override
	public void writeToParcel(Parcel dest, int flags)
	{
		//把该对象所包含的数据写到Parcel
		dest.writeInt(id);
		dest.writeString(name);
		dest.writeString(pass);
	}

	// 添加一个静态成员,名为CREATOR,该对象实现了Parcelable.Creator接口
	public static final Parcelable.Creator<Person> CREATOR
		= new Parcelable.Creator<Person>() //①
	{
		@Override
		public Person createFromParcel(Parcel source)
		{
			// 从Parcel中读取数据，返回Person对象
			return new Person(source.readInt()
				, source.readString()
				, source.readString());
		}

		@Override
		public Person[] newArray(int size)
		{
			return new Person[size];
		}
	};
}

package org.crazyit.service;

import android.os.Parcel;
import android.os.Parcelable;

public class Pet implements Parcelable
{
	private String name;
	private double weight;
	public Pet()
	{
	}
	public Pet(String name, double weight)
	{
		super();
		this.name = name;
		this.weight = weight;
	}
	public String getName()
	{
		return name;
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public double getWeight()
	{
		return weight;
	}
	public void setWeight(double weight)
	{
		this.weight = weight;
	}

	@Override
	public int describeContents()
	{
		return 0;
	}
	/* (non-Javadoc)
	 * @see android.os.Parcelable#writeToParcel(android.os.Parcel, int)
	 */
	@Override
	public void writeToParcel(Parcel dest, int flags)
	{
		//把该对象所包含的数据写到Parcel
		dest.writeString(name);
		dest.writeDouble(weight);
	}

	// 添加一个静态成员,名为CREATOR,该对象实现了Parcelable.Creator接口
	public static final Parcelable.Creator<Pet> CREATOR
		= new Parcelable.Creator<Pet>()
	{
		@Override
		public Pet createFromParcel(Parcel source)
		{
			// 从Parcel中读取数据，返回Person对象
			return new Pet(source.readString()
				, source.readDouble());
		}

		@Override
		public Pet[] newArray(int size)
		{
			return new Pet[size];
		}
	};
	@Override
	public String toString()
	{
		return "Pet [name=" + name + ", weight=" + weight + "]";
	}
}

上边的两个类都实现了Parcelable接口，并且实现了必须实现的方法。主要需要实现writeToParcle（）方法，并且需要一个CREATOR的全局变量，实现createFromParcle方法。

然后定义了通信接口，根据person获取他的pets，IPet.aidl

package org.crazyit.service;

import org.crazyit.service.Pet;
import org.crazyit.service.Person;

interface IPet
{
	// 定义一个Person对象作为传入参数
	List<Pet> getPets(in Person owner);
}

值得注意的是AIDL方法的参数多了关键字in，代表传入参数。

前边介绍过，AIDL通讯接口写好后ADT会自动生成对应JAVA文件。

然后是AIDLService文件：

package org.crazyit.service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.crazyit.service.IPet.Stub;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;

public class ComplexService extends Service
{
	private PetBinder petBinder;
	private static Map<Person , List<Pet>> pets
		= new HashMap<Person , List<Pet>>();
	static
	{
		// 初始化pets Map集合
		ArrayList<Pet> list1 = new ArrayList<Pet>();
		list1.add(new Pet("旺财" , 4.3));
		list1.add(new Pet("来福" , 5.1));
		pets.put(new Person(1, "sun" , "sun") , list1);
		ArrayList<Pet> list2 = new ArrayList<Pet>();
		list2.add(new Pet("kitty" , 2.3));
		list2.add(new Pet("garfield" , 3.1));
		pets.put(new Person(2, "bai" , "bai") , list2);
	}
	// 继承Stub，也就是实现额IPet接口，并实现了IBinder接口
	public class PetBinder extends Stub
	{
		@Override
		public List<Pet> getPets(Person owner) throws RemoteException
		{
			// 返回Service内部的数据
			return pets.get(owner);
		}
	}
	@Override
	public void onCreate()
	{
		super.onCreate();
		petBinder = new PetBinder();
	}
	@Override
	public IBinder onBind(Intent arg0)
	{
		/* 返回catBinder对象
		 * 在绑定本地Service的情况下，该catBinder对象会直接
		 * 传给客户端的ServiceConnection对象
		 * 的onServiceConnected方法的第二个参数；
		 * 在绑定远程Service的情况下，只将catBinder对象的代理
		 * 传给客户端的ServiceConnection对象
		 * 的onServiceConnected方法的第二个参数；
		 */
		return petBinder; //①
	}
	@Override
	public void onDestroy()
	{
	}
}

在该Service里初始化了static数据persons和pets，内部类作为IBinder的代理集成了AIDL的Stub类。
最终在AndroidManifest.xml里加入该service，就完成了。

然后是一个访问者的实例，它需要把所有的AIDL文件（IPet.aidl,Pet.aidl,Person.aidl,Person.java,Pet.java）复制到项目里，然后是访问的Activity代码：

package org.crazyit.client;

import java.util.List;

import org.crazyit.service.IPet;
import org.crazyit.service.Person;
import org.crazyit.service.Pet;

import android.app.Activity;
import android.app.Service;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;

public class ComplexClient extends Activity
{
	private IPet petService;
	private Button get;
	EditText personView;
	ListView showView;
	private ServiceConnection conn = new ServiceConnection()
	{
		@Override
		public void onServiceConnected(ComponentName name
			, IBinder service)
		{
			// 获取远程Service的onBind方法返回的对象的代理
			petService = IPet.Stub.asInterface(service);
		}

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

	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		personView = (EditText) findViewById(R.id.person);
		showView = (ListView) findViewById(R.id.show);
		get = (Button) findViewById(R.id.get);
		// 创建所需绑定的Service的Intent
		Intent intent = new Intent();
		intent.setAction("org.crazyit.aidl.action.COMPLEX_SERVICE");
		// 绑定远程Service
		bindService(intent, conn, Service.BIND_AUTO_CREATE);
		get.setOnClickListener(new OnClickListener()
		{
			@Override
			public void onClick(View arg0)
			{
				try
				{
					String personName = personView.getText().toString();
					// 调用远程Service的方法
					List<Pet> pets = petService.getPets(new Person(1,
						personName, personName)); //①
					// 将程序返回的List包装成ArrayAdapter
					ArrayAdapter<Pet> adapter = new ArrayAdapter<Pet>(
						ComplexClient.this,
						android.R.layout.simple_list_item_1, pets);
					showView.setAdapter(adapter);
				}
				catch (RemoteException e)
				{
					e.printStackTrace();
				}
			}
		});
	}

	@Override
	public void onDestroy()
	{
		super.onDestroy();
		// 解除绑定
		this.unbindService(conn);
	}
}

xiaobaiooo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
跨进程调用 Service（AIDL Service）

根据疯狂Android讲义学习： AIDL Service 是一个跨进程通信IPC服务（Interprocess Communication），类似于JAVA的CORBA、RMI。AIDL Service 简介和JAVA RMI类似，都需要先定义远程调用接口，然后为该接口提供一个实现类。不同的是RMI会将对象返回给客户端，而AIDL则是
复制链接

扫一扫

专栏目录