四大组件

一．Activity

1.Activity与Task的关系

1）LaunchMode

------stantard:创建一个新的Activity实例，且压入Task栈顶，taskId与启动这个Activity的调用者的Taskid相同

------singleTop：ActivityManageService（AMS）会查询Task栈顶是否为该要被启动的Activity，如果不是该Activity的实例，则新建一个新的Activity实例，压入栈顶，反之将直接原封不动调用栈顶的Activity实例

------singleTask：AMS查询Task中是否存在将被启动的Activity，如果存在则将此Activity位于栈中之前的所有Activity销毁，将此Activity置于栈顶，并调用该Activity的onNewIntent（）方法，如此时战中有A,B,C,D,如果此时要启动Activity B，那么将会销毁B之前的C和D，并将B置于栈顶，此时栈状态时A,B,最后调用B的onNewIntent（）

------singleInstance：如果Task中已有一个该Activity实例，则直接调用其onNewIntent

否则将新建一个Activity实例，并为之创建一个与其所在apk进程不同的Taski,且该TaskId值不会再被其他的Activity所用。

2）Intent启动Activity的参数launchFlags

3）Manifest的taskAffinity，allowTaskRparenting,clearTaskLaunch

-----allowTaskReparenting：标识Activity能否从启动的Task移动到有着affinity的Task，默认为false。用于：Activity从启动到死亡都在Task中，如果Task消亡，想使得Activity移动到有affinity的Task中，如将一个应用的Activity移动到另一个应用中的task中

----alwaysRetainTaskState：标识Activity的Task的状态是否总是有系统保存，由于特定情况下系统会清理Task的状态，如果需要保存则需要设置为true

----clearTaskOnLaunch:标识是否从Task中清除出根Activity意外的其他Activity

2.判断Activity是否存在

二．BroadcastReceiver

BroadcastReceiver-----通过注册于Manifest文件中，可接收指定Action的广播，如短信，或其他程序发送的广播

抽象类，可继承得到一个Receiver，在onReceive（）中处理事件

通过sendReceiver(new Intent(Action))发送广播

2.异步发送广播：

sendStickyBroadcast(intent)----intent将一直存在，直到使用removeStickyBroadcast(intent)

需要添加<user-permission>----android.permission.BROADCAST_STICKY

否则抛出安全异常

3.判断BroadcastReceiver是否存在

三．Service----四大组件之一，继承自Context，后台运行组件

startService

1.生命周期：

startService()==>onCreate()==>onStart()==>Runing stopService()==>onDestroy()==>Stop Service

如果服务已运行则只调用onCreate（），服务未运行则按上述方式。

2.IPC通信

bindService:

1.生命周期：

bindService()==>onCreate()==>onBind()==>Running

onUnBind()==onDestroy()==>Stop Service

此种方式将Activity与Service绑定在一起，Activity退出则Service 停止，此谓同生共死。其中onBind()返回一个IBinder类对象，客户端可由此回调Service的方法。

2.aidl支持的数据类型

Java原语（int, long, char, boolean）|String,Charsequece|List&Map

而如果需要在AIDL中使用其他AIDL接口类型，需要import，即使是在相同包结构下。AIDL允许传递实现Parcelable接口的类，需要先添加一个该类的aidl文件再由import引入。
    需要特别注意的是，对于非基本数据类型，也不是String和CharSequence类型的，需要有方向指示，包括in、out和inout，in表示由客户端设置，out表示由服务端设置，inout是两者均可设置。

 3.IPC不同进程之间远程通信（Remote）

1）基于C/S(客户端/服务端)架构的

2）用途：调用其他程序的服务，如在本程序中调用google的翻译服务等

需配置Manifest的service标签android:process=":remote"，代表在应用程序里，当需要该service时，会自动创建新的进程。而如果是android:process="remote"，没有“:”分号的，则创建全局进程，不同的应用程序共享该进程。

服务端和客户端的aidl文件必须存在于相同的包名下才能通过协议正确的通信否则出现Binder invocation to an incorrect interface，因为服务器端和客户端aidl文件的包名不同导致生成的java文件不同。

相关文件

1.aidl文件:定义了客户端可用的方法和数据的接口

package com.ccp.wj.doit.aidl;

interface  DoItAidl {
	void onDataChanged(String reflag,String notifyCity);
}

2.客户端：

  注：使用Interface AIDLInterface{}

注：声明IBinder mBinder  = new IBinder.Stub()

注：在onBind()中返回IBinder对象

代码如下

public class DoItService extends Service{
	private static final String tag = "DoItService";
	private  Context mContext;
	private  DoItService mService;
	private DoItAidl.Stub mBinder = new DoItAidl.Stub(){
		@Override
		public void onDataChanged(String reflag,String notifyCity) throws RemoteException {
			// TODO Auto-generated method stub
			onDateChange(reflag,notifyCity);
		}
		
	};
	@Override
	public void onCreate() {
		// TODO Auto-generated method stub
		super.onCreate();
		Log.d(tag, "onCreate---startService");
	}	
	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		return mBinder;//返回Binder
	}

3.服务端：

声明AIDL对象--》实现ServiceConnection-》获取AIDL对象实例

    private static DoItAidl mBinder;
	String flag="",notifyCity = null;
	private ServiceConnection mSC = new ServiceConnection(){
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			// TODO Auto-generated method stub
			//mService = (DoItService) ((DoItService.MyBinder) service).getService();//取得Service
			mBinder = DoItAidl.Stub.asInterface(service);//获取binder对象
				try {
					mBinder.onDataChanged(flag,notifyCity);
				} catch (RemoteException e) {
					// TODO Auto-generated catch block
					Log.e(tag, e.toString());
				}
		}
		@Override
		public void onServiceDisconnected(ComponentName name) {
			// TODO Auto-generated method stub
			
		}
		
	};

注：创建了AIDL接口后将会在gen/包名/AIDL.java生成相对应的java文件

其中与LocalService不同：

1.Ibinder对象：LocalService的IBinder对象继承Binder类，IPC继承自AIDL接口中的Stub内部类

4.实现传递复杂数据，传递类

关于Parcelable类

1.使用Parcelable可以实现比序列化更高效率

2.注意要继承自Parcelable接口的类写成JavaBean模式

3.关于writeToParcelable（par,flag）和createFromParcel(par)

    1）writeToParcelable(par,flag)

将Parcelable类打包成Parcel对象，有parcel的writeXXX()方法将类的属性写入Parcel中，打包之后通过Intent和IPC传递。

    2）createFromParcel（par）

将parcel中的类对象属性由par.getXXX（）读出来，然后由类的setXXX（）方法将属性赋予新的JavaBean对象

4.实现了Parcelable的类必须有一个Parcelable.Creator<T>CREATOR的字段

步骤

1.实现Parcelable接口得到Person类并重写相应的方法writeToParcel（）和
Parcelable.Creator<MyParcelable>

2.添加一个Person的aidl文件并要和Person类放在同一个包中，一定要同名

3.在主aidl中就可以引入Person类了，作为参数需在前加in/out/inout

1.实现Parcelable


package com.doit.aidl;
 
import android.os.Parcel;
import android.os.Parcelable;
import android.util.Log;
/**server
 * 实现IPC 传递由Parcelable实现的类对象,写为JavaBean
 * 重点：
 * 1.Parcelable.Creator<T>对象的实现
 * 2.createFromParcel()--反序列化化
 * 3.newArray()--创建一个Parcel的对象数组
 * 4.writeToParcel()--序列化对象
 * @author ChenChunPeng
 *
 */
public class Person implements Parcelable {
private  String name , sex;
private int age;
private static String tag="Person"; 
public Person(Parcel pl){ //构造函数，与Parcelable.Creator中的createFromParcel(source)对应
        readFromParcel(pl);
} 
@Override
public int describeContents() {
// TODO Auto-generated method stub
Log.d("Person--Server", "describeContents");
return 0;
}
public void setName(String name){
this.name = name;
}
public void setSex(String Sex){
this.sex = Sex;
}
public void setAge(int age){
this.age = age;
}
public String getName(){
return name;
}
public String getSex( ){
return sex;
}
public int getAge( ){
return age;
}
@Override
public void writeToParcel(Parcel par, int flag) {//此方法将类对象打包成Parcel
// TODO Auto-generated method stub
Log.d("Person--Server", "writeToParcel");
par.writeString(name);
par.writeString(sex);
par.writeInt(age);
}
public void readFromParcel(Parcel in) {
// TODO Auto-generated method stub
name = in.readString(); 
        sex = in.readString(); 
        age = in.readInt(); 
Log.d(tag, "readFromParcel");
}
public final static Parcelable.Creator<Person>CREATOR = new Parcelable.Creator<Person>() {
@Override
public Person createFromParcel(Parcel source) {
// TODO Auto-generated method stub
Log.d(tag+"CREATOR", "createFromParcel");
return new Person(source);
}
@Override
public Person[] newArray(int size) {
// TODO Auto-generated method stub
Log.d(tag+"CREATOR", "newArray");
return new Person[size];
}
};
}

注：如何将Service和Activity绑定起来

ServiceConnection类是监控Service状态的一个类，bindService（intent，con,flag）将调用ServiceConnection对象，将客户端和服务端连接起来，连接成功后将调用onServiceConnected（）。

3.LocalService---让service的方法可以被其他类所调用

1.原理

因为service不同于Activity等的类，可以实例化后随便调用其方法或属性等，所以需要将需要调用Service方法的Activity与Service绑定起来，这样就可以由Activity直接调用Service的方法了。

2.步骤

服务端：

----继承自Service

----实现一个继承自Binder类的类，以便在onBind（）方法中返回给调用者

客户端：

-----添加一个新的ServiceConnection对象并在其中的onServiceConnected中获取Binder对象，onServiceDisconneted做出相关操作

----调用bindService将Service与调用者连接起来

5.设置前台程序----挂载到通知栏，如qq

6.判断Service是否存在

四．ContentProvider

一）ContentProvider

通过继承ContentProvider类，实现抽象方法

2.关于URI

[content://][shy.luo.providers.articles][/item][/123]

        |------A------|-----------------B-------------------|---C---|---D--|

        A组件称为Scheme，它固定为content://，表示它后面的路径所表示的资源是由Content Provider来提供的。

        B组件称为Authority，它唯一地标识了一个特定的Content Provider，因此，这部分内容一般使用Content Provider所在的package来命名，使得它是唯一的。

        C组件称为资源路径，它表示所请求的资源的类型，这部分内容是可选的。如果我们自己所实现的Content Provider只提供一种类型的资源访问，那么这部分内部就可以忽略；如果我们自己实现的Content Provider同时提供了多种类型的资源访问，那么这部分内容就不可以忽略了。例如，我们有两种电脑资源可以提供给用户访问，一种是笔记本电脑，一种是平板电脑，我们就把分别它们定义为notebook和pad；如果我们想进一步按照系统类型来进一步细分这两种电脑资源，对笔记本电脑来说，一种是安装了windows系统的，一种是安装了linux系统的，我们就分别把它们定义为notebook/windows和notebook/linux；对平板电脑来说，一种是安装了ios系统的，一种是安装了android系统的，我们就分别把它们定义为pad/ios和pad/android。

        D组件称为资源ID，它表示所请求的是一个特定的资源，它通常是一个数字，对应前面我们所介绍的数据库表中的_id字段的内容，它唯一地标志了某一种资源下的一个特定的实例。继续以前面的电脑资源为例，如果我们请求的是编号为123的装了android系统的平板电脑，我们就把它定义为pad/android/123

3.关于MIME类型---与URI对应

我们还需要定义与URI对应的资源的MIME类型。每个MIME类型由两部分组成

           MIME类型示意图

4.URi匹配规则

        因为我们是根据URI来操作数据库的，不同的URI对应不同的操作，所以我们首先要定义好URI匹配规则，这样，当我们获得一个URI时，就能快速地判断出要如何去操作数据库。设置URI匹配规则的代码如下所示：

[java] view plaincopy

private static final UriMatcher uriMatcher;  

static {  

      uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);  

      uriMatcher.addURI(Articles.AUTHORITY, "item", Articles.ITEM);  

      uriMatcher.addURI(Articles.AUTHORITY, "item/#", Articles.ITEM_ID);  

      uriMatcher.addURI(Articles.AUTHORITY, "pos/#", Articles.ITEM_POS);  

}  

        在创建UriMatcher对象uriMatcher时，我们传给构造函数的参数为UriMatcher.NO_MATCH，它表示当uriMatcher不能匹配指定的URI时，就返回代码UriMatcher.NO_MATCH。接下来增加了三个匹配规则，分别是content://shy.luo.providers.articles/item、content://shy.luo.providers.articles/item/#和content://shy.luo.providers.articles/pos/#，它们的匹配码分别是Articles.ITEM、Articles.ITEM_ID和Articles.ITEM_POS，其中，符号#表示匹配任何数字

二）ContentProvider

1.创建步骤

--》继承ContentProvider并Overrider getType（）方法

--》提供供外部访问的Uri

     注：（1）格式：content：//<Authority>/<DataPath>/<单独的行号>

      ---Authority:如”com.ccp.provider”,

      ---DataType：可以随便自己定义如items/daries等等。

例：content://com.ccp.provider/items</1>返回所有内容<第一行>

--》通过UriMatcher类的addUri配置不同的访问形式的uri，最后由其match解析uri

 注：UriMatcher就是为配置和解析ContentProvider中的Uri而存在

      （1）addUri（String authority,String path,int code)

--authority:Uri中的Authority

--path:Uri中的DataPath，如果Uri中DataPath为items则，path为items

--code:调用match（）方法时返回的代码，如果为1，则match（uri）返回1

      （2）match（Uri uri）

--》添加数据库并实现insert，update，delete等

--》返回MIME类型

   --返回的是一般数据：重写getType（）方法返回MIME类型

注：

所有项：vnd.android.cursor.dir/contentType||vnd.<companyNmae>.cursor.dir/contenttype

单独项：vnd.android.cursor.item/contentType

contentType:vnd.<name>.<type>

<name>:com.companyName

<type>:自定义的文件类型

   --返回的是文件如图片等则重写getStreamTypes()

--》在Manifest中注册

<provider android:name=”ProviderName”

 Android:authority=”Authority”>

判断ContentProvider是否存在

五．关于ContentResolver

1.如何获取：通过Context对象调用getContentResolver（）函数获取

六．Intent

Intent为何物

Intent是程序与系统之间的通信员，程序通过Intent对象告诉系统我将要做什么，系统根据程序的intent来做出适当的事情。如我要使得蓝牙在200s内可见，我就可以用intent（action_found）来告诉系统我要蓝牙可见200s，系统知道了则打开蓝牙，使得可见200s

概述

自我体会：action与data的关系--data是action所要操作的数据，如ACTION_VIEW所对应的data表示我要看的data内容是什么，是图片image/* ,文本 text/plain；ACTION_SEND所对应的data表示我要发送的data内容是什么。

1.ACTION:

常用解释

ACTION_VIEW:表示打开一个与视图’看‘相关的，比如我在外部打开txt文档，所选择的应用就是一个view

ACTION_SEND：表示与发送有关，如发送短信，邮件，发送qq空间心情，发微博，这是因为相关的应用在相应的IntentFilter中添加了相应的DATA即MIME数据类型。

ACTION_EDIT

2.DATA:添加了相应的data即ＭＩＭＩ数据类型就可以让用户在外部打开相应的文件时，让本身应用可被选中。

Intent打开其他应用

1.打开网页（借助第三方软件）

startActivity(new Intent(Intent.ACTION_VIEW),url);//打开指定url的网页

2.打开闹钟设置

Intent(“android.intent.action.SET_ALARM”)

注：需要添加

<uses-permission android:name="com.android.alarm.permission.SET_ALARM"/>，因为时钟程序设置了<permission标签>

3.发送邮件

4.打电话

Intent(Intent.ACTION_CALL,Uri.parse(“tel:12345667”));

5.将号码传入拨号 程序

Intent(Intent.ACTION_DIAL,Uri.parse(“tel:12344”));

6.调用拨号程序

Intent(“com.android.phone.action.TOUCH_DIALER”);

注：添加权限<uses-permission id="android.permission.CALL_PHONE" />

7.查看联系人

Intent（“com.android.contacts.action.LIST_CONTACTS”）;

8.显示设置界面

Intent(“android.settings.SETTINGS”);

9.WIFI设置

Intent(‘android.settings.WIFI_SETTINGS’)

10.打开地图具体位置

Uri uri = Uri.parse("geo:38.899533,-77.036476");

Intent it = new Intent(Intent.Action_VIEW,uri);

startActivity(it); 

11.显示路径

Uri uri = 

Uri.parse("http://maps.google.com/maps?f=d&saddr=startLat%20startLng&daddr=endLat%20endLng&hl=en");

Intent it = new Intent(Intent.ACTION_VIEW,URI);

startActivity(it);

12.发送短信-调用短信程序

Intent it = new Intent(Intent.ACTION_VIEW);   

it.putExtra("sms_body", "The SMS text");   

it.setType("vnd.android-dir/mms-sms");   

startActivity(it);  

13.发送短信

Uri uri = Uri.parse("smsto:0800000123");   

Intent it = new Intent(Intent.ACTION_SENDTO, uri);   

it.putExtra("sms_body", "The SMS text");   

startActivity(it);  

14.发送彩信

Uri uri = Uri.parse("content://media/external/images/media/23");   

Intent it = new Intent(Intent.ACTION_SEND);   

it.putExtra("sms_body", "some text");   

it.putExtra(Intent.EXTRA_STREAM, uri);   

it.setType("image/png");   

startActivity(it); 

15.发送邮件 

16.在GooglePlay中搜索应用

17.打开安装界面

18.发送图片

PendingIntent相关

1.如何获取PendingIntent

PendingIntent pi = PendingIntent.getBroadcast();//获取一个PendingIntent将发送一个广播

= PendingIntent.getActivity();//将启动一个Intent

=PendingIntent.getService();//将启动一个Service

注：

当在屏幕上有多个widget时，无论在哪个widget上点击，响应事件的总是最后一个widget，原因就是PendingIntent传值时出现了错误，每次添加的新PendingIntent把原来的PendingIntent的替换掉了、

PendingIntent pi = PendintIntent.getBroadcast(context, 0, intent,0);

我们固定把第二个参数设置了为0.而第二个参数表示的是requestCode表示发送器的私有请求码，相当于pendingIntent的一个Id，PendingIntent会根据这个请求码来判断是否存在相同的PendingIntent，如果存在则替换，所以出现了以上情况。

建议PendingIntent pendingIntent = PendingIntent.getBroadcast(context,appWidgetId,intent,0);

 七．Intent与其余组件的关系

可有Intent对象转到目的Activity，

1.步骤：

（1）声明Intent对象

（2）调用setClass（）设置转向目的地

//如果为用new Intent（MainActivity.this,ShowActivity.class）

（3）向目的Activity传递数据：

---------可直接调用intent.putExtra(key,Value)

----------亦可由Bundle类来装载需传递数据

（4）启动intent：调用startActivity（intent）---不需要返回结果

调用startActivityForResult（intent，REQUEST_CODE）；有返回结果，并

  且与onActivityResult相互关联：返回结果之后由系统自动调用此函数来处理相关

（5）setResult（RESULT_OK,intent）;//为startActivityForResult（）设置返回结果，用于                     onActivityResult(int requestCode, int resultCode, Intent data) 中第二个参
数resultCode的判断；

代码如下：

@Override
public void onClick(View v) {
// TODO Auto-generated method stub
dispToast("new activity");
Intent intent= new Intent();
        intent.setClass（MainActivity.this,ShowActivity.class）;
Bundle bundle = new Bundle();
bundle.putString("name", "ccc");
intent.putExtras(bundle);
startActivityForResult(intent,REQUEST_CODE);
//startActivity(intent);
setResult(RESULT_OK,intent);
}
//onActivity
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
// TODO Auto-generated method stub
super.onActivityResult(requestCode, resultCode, data);
Toast.makeText(this,"for Result",Toast.LENGTH_SHORT).show();
if(requestCode==REQUEST_CODE ){
if(resultCode == RESULT_CANCELED){
setTitle("Cancel");
}
if(resultCode == RESULT_OK){
String temp;
Bundle bundle = data.getExtras();
temp = bundle.getString("name");
setTitle(temp);
}
}
}
 
}

（二）调用外部程序的方法

1.使用action

Intent intent =new Intent();

intent.setAction(com.test.action.PLAYER)

startActivity(intent);

注：B程序中的AndroidManifest.xml中启动Activity的intent-filter：

<intent-filter

action android:name="android.intent.action.MAIN"

action android:name="com.test.action.PLAYER"

category android:name="android.intent.category.DEFAULT"必须，否则无效

category android:name="android.intent.category.LAUNCHER"></intent-filter>

2.使用包名和类名

Intent intent =new Intent();

intent.setClassName(包名，类名)

startActivity(intent);

注：

打开qq

//intent.setClassName("com.tencent.mobileqq", "com.tencent.mobileqq.activity.SplashActivity");

intent.setClassName(arg1,arg2)中的arg1是被调用程序B的包名，arg2是B程序中目的activity的完整类名。

3.使用ComponentName

Intent intent =new Intent();         

ComponentName comp=new ComponentName(包名，类名);

//打开qq

intent.setComponent("com.tencent.mobileqq", "com.tencent.mobileqq.activity.SplashActivity");

intent.setComponent(comp); 

startActivity(intent);

注：B程序（被调用）中的AndroidManifest.xml中启动Activity的intent-filter不需要特别加入其它信息，如下即可：

<intent-filter 

action android:name="android.intent.action.MAIN"

category android:name="android.intent.category.LAUNCHER">

<.intent-filter>

4.示例

A)打开系统闹钟设置界面

1)因为时钟程序设置了

<permission android:name = com.android.alarm.permission.SET_ALARM>的限制，所以需要添加一个<uses-permission android:name = “com.android.alarm.permission.SET_ALARM”>

2)由Intent的action隐式调用时钟的Activity

Intent intent = new Intent();

intent.setAction("android.intent.action.SET_ALARM");

startActivity(intent);

（三）使得Activity被其他程序所调用

但是如果你的程序可以实现某些功能，这些功能能够被其他程序使用，那么你的程序需要准备好响应其他程序的请求。例如，如果你做了一个可以分享信息和照片给朋友的社交程序，你最好让你的程序支持ACTION_SEND意图，以便用户可以在其他程序启动一个“分享”功能，并且运行你的程序去执行这个功能。

要让其他程序可以运行你的activity，你需要在相应的元素中添加一个元素。

当你的程序安装到设备中时，系统会识别你的intent过滤器，并把这些信息添加到一个内部intent支持目录，这个目录包含所有安装好的程序所支持的intent。当程序调用startActivity()或者startActivityForResult()，并使用隐式intent时，系统会查找能够响应这个intent的activity。

添加一个Intent过滤器

为了合理定义你的activity能够处理的intent，每个添加的过滤器必须尽可能详细的指明功能类型和activity支持的数据。

如果activity包含的intent过滤器符合下面所有的Intent对象的条件，系统会发送一个给定的intent给activity：

Action

动作执行的字符串名称，通常使用一个平台指定值，如ACTION_SEND或者ACTION_VIEW。

使用intent过滤器的元素指定。值必须是完整的动作名称，而不仅仅是API常数。

Data

和intent相关联的数据描述。

使用元素指定。这个元素可以使用一个或者多个属性，你可以指定只是MIME type，只是URI prefix，只是URI scheme，或者一个他们的组合体和其他可以接受的数据类型。

提示：如果你不详细的声明数据Uri（例如activity不是处理URI，而是其他附加数据），你应该仅指明一个Android:mimeType属性去声明你的activity可以处理的数据类型，比如text/plain或者image/jpeg。

Category

提供一个额外的方式去描述一个activity可以处理的intent，通常是关于用户开始的手势或者位置。这里有很多系统支持的分类，但是大部分不常用。所有隐式的intent都是默认定义了CATEGORY_DEFAULT分类。

使用元素指定。

在你的intent过滤器中，你可以在内部使用XML声明你的activity可以接受的条件。

例如，这里有一个intent过滤器，它能处理ACTION_SEND Intent，数据必须是文本或者图像：

<activityandroid:name="ShareActivity">

<intent-filter>

<actionandroid:name="android.intent.action.SEND"/>

<categoryandroid:name="android.intent.category.DEFAULT"/>

<dataandroid:mimeType="text/plain"/>

<dataandroid:mimeType="image/*"/>

</intent-filter>

</activity>

每个intent只能指定一个动作和一个数据类型，但是在<intent-filter>中声明多个<action>,<category>, <data>是允许的。

如果两对动作和数据是相互独立的，你应该创建两个独立的intent过滤器去指定哪个动作接收哪个数据类型。

例如，假如你的activity使用ACTION_SEND和ACTION_SENDTO处理文本和图像。这种情况下，你必须定义两个独立的intent过滤器，因为ACTION_SENDTO intent必须使用Uri数据去指定收件人的地址，使用send或者sendto执行URI方案。例如：

<activityandroid:name="ShareActivity">

<!-- filter for sending text; accepts SENDTO action with sms URI schemes -->

<intent-filter>

<actionandroid:name="android.intent.action.SENDTO"/>

<categoryandroid:name="android.intent.category.DEFAULT"/>

<dataandroid:scheme="sms"/>

<dataandroid:scheme="smsto"/>

</intent-filter>

<!-- filter for sending text or images; accepts SEND action and text or image data -->

<intent-filter>

<actionandroid:name="android.intent.action.SEND"/>

<categoryandroid:name="android.intent.category.DEFAULT"/>

<dataandroid:mimeType="image/*"/>

<dataandroid:mimeType="text/plain"/>

</intent-filter>

</activity>

提示：为了接收隐式的intent，你必须包括CATEGORY_DEFAULT分类在intent过滤器中。startActivty()和startActivityForResult()处理所有包含了CATEGORY_DEFAULT分类的intent。如果不声明，那么隐式的intent不会匹配你的activity。

更多关于发送和接收ACTION_SEND意图执行分享动作的信息，可以查看 Receiving Content from Other Apps。

在你的Activity中处理Intent

为了决定在activity中执行什么动作，你需要读取intent。

当你启动activity时，调用getIntent()去接收Intent。你可以在activity生命周期的任何时候调用，但是通常是在onCreate()或者onStart()中。

例如：

@Override

protectedvoidonCreate(BundlesavedInstanceState){

super.onCreate(savedInstanceState);setContentView(R.layout.main);

// Get the intent that started this activity

Intentintent =getIntent();

Uridata =intent.getData();

// 基于intent类决定做什么

if(intent.getType().indexOf("image/")!=-1){

// 使用图片类型处理intent ...

}elseif(intent.getType().equals("text/plain")){

// 使用文本类型处理intent ...

}

}

返回一个结果

如果你想返回一个结果给调用你的activity，调用setResult()去指定结果代码和结果Intent。当你的操作完成，用户需要返回到原来的activity，你需要调用finish()去关闭你的activity。例如：

// Create intent to deliver some kind of result data

Intentresult =newIntent("com.example.RESULT_ACTION",Uri.parse("content://result_uri");

setResult(Activity.RESULT_OK,result);

finish();

你必须指定一个结果代码，通常是RESULT_OK或者RESULT_CANCELED。需要的话还可以附加数据到intent中。

提示：RESULT_CANCELED是默认的，如果用户在完成动作前，或者是设置结果前按返回按钮，那么原来的activity会接收到“canceled”结果。

如果你只是需要返回一个整形去指定多个操作中的一个，你可以设置结果代码为任何大于0的数。如果是使用结果代码发送一个数，你不需要包含Intent，你可以调用setResult()接收一个唯一的结果代码，例如：

setResult(RESULT_COLOR_RED);

finish();

这种情况下，可能只有少数可能的结果，所有结果代码是一个本地定义的整数。在自己的程序中可以运行良好，因为这个结果代码可以被定义成公共的常量。

提示：不用判断你的activity是通过startActivity()还是startActivityForResult()启动的。只要调用setResult()就可以返回一个结果。如果原来的activity是通过startActivityForResult()调用的，系统就会发送你提供给setResult()的结果。startActivity()调用的话，结果会被忽略。