NFC framework introduce
1 NFC 简介
对于NFC,是google在android4.0上推出来的,简单介绍下。近场通讯(NFC)是一系列短距离无线技术,一般需要4cm或者更短去初始化连接。近场通讯(NFC)允许你在NFC tag和Android设备或者两个Android设备间共享小负载数据。优酷上有其应用的视频:http://v.youku.com/v_show/id_XMjM3ODE5ODMy.html。
http://v.youku.com/v_show/id_XMzM1MTUyMzI4.html
2 总体框架
对于NFC框架的设计,同样是android的标准的c/s架构,其框架图如下:
n 客户端:android提供了两个API包给apk,分别是android.nfc.tech、android.nfc,实现了NFC的应用接口,代码路径frameworks/base/core/java/android/nfc/tech、frameworks/base/core/java/android/nfc。
n 服务端:packages/apps/Nfc是一个类似电话本的应用,这个程序在启动后自动运行,并一直运行,作为NFC的服务进程存在,是NFC的核心。
在这个程序代码中,有个JNI库,供NfcService调用,代码路径是packages/apps/Nfc/jni/
n 库文件:代码路径是external/libnfc-nxp,用C编写的库文件,有两个库,分别是libnfc.so和libnfc_ndef.so。libnfc.so是一个主要的库,实现了NFC stack的大部分功能,主要提供NFC的服务进程调用。libnfc_ndef是一个很小的库,主要是实现NDEF消息的解析,供framework调用
2.1总体类图关系
2.2 数据分类
NFC按照发展,分为两种,NFC basics和Advanced NFC。从字面上理解,第一种是最先设计的,第二种是在原来基础上扩展的。
2.2.1 NFC basics
是一种点对点(P2P)数据交换的功能,传送的数据格式是NDEF,是Nfc Data Exchange Format的缩写,这个数据格式用于设备之间点对点数据的交换,例如网页地址、联系人、邮件、图片等。对于除图片以外的数据,数据量比较小,直接封装在类NdefMessage中,通过NFC将NdefMessage类型数据发送到另一台设备,而对于图片这样数据量比较大的数据,需要构建一个标准的NdefMessage数据,发送给另外一台设备,等有回应之后,再通过蓝牙传送数据。
NdefMessage类是用于数据的封装,其包含有一个或多个NdefRecord类,NdefRecord才是存储数据的实体,将联系人、邮件、网页地址等转换才byte类型的数据存储在NdefRecord当中,并且包含了数据类型。举个例子吧:
NdefRecord uriRecord = new NdefRecord(
NdefRecord.TNF_ABSOLUTE_URI ,
"http://developer.android.com/index.html".getBytes(Charset.forName("US-ASCII")),
new byte[0], new byte[0]);
new NdefMessage(uriRecord);
以上是用NdefMessage对一个NdefRecord数据进行分装。
为了更好理解数据的传送方式,需要更细的分为三种:
n 在一个Apk中,用NdefMessage封装Apk的数据,在设置NdefRecord的数据类型,然后发送给其他设备。在接收设备的同样的APK的AndroidManifest文件中设置接收数据的类型,这样通过Intent消息就能找到对应的Activity启动。
n 直接将当前运行(除home程序外)的Apk的包名封装到NdefMessage中,发送给其他设备。接收设备收到NdefMessage数据,转换才成包名,根据包名构造Intent,启动指定的Activity。如果包名不存在,那么会启动google play去下载安装该Apk。
n 图片为数据量比较大的数据。需要封装一个标准的NdefMessage数据发送给其他设备,当有回应的时候,在将图片数据通过蓝牙发送给其他设备。
按照上面的分析,还可以将数据传送,分为小数据量的传送和大数据量的传送。小数据量是指联系人、邮件、网页地址、包名等,而大数据量是指图片等,需要通过蓝牙传送的。那么为什么NFC的功能还要蓝牙传送呢?原因是NFC的设计本来就是为了传送小的数据量,同我们通过NFC启动蓝牙传图片,更方便的不需要手动进行蓝牙的匹配,只需要将手机贴在一起就可以完成了蓝牙的匹配动作。
2.2.2 Advanced NFC
对于该类型的NFC,也是在点对点数据交换功能上的一个扩充,我们日常接触的有公交卡、饭卡,手机设备可以通过NFC功能读取该卡内的数据,也有支持NFC设备往这类卡里面写数据。所以,我们将这些卡类称为Tag。
需要直接通过Byte格式进行数据封装,对TAG数据进行读写。市面上有很多的卡,估计没个城市用的公交卡都不一样,就是使用的标准不一样,所以在 android.nfc.tech包下支持了多种technologies,如下图:
当tag设备与手机足够近的时候,手机设备首先收到了Tag信息,里面包含了当前Tag设备所支持的technology,然后将Tag信息发送到指定的Activity中。在Activity中,将读取Tag里面的数据,构造相应的technology,然后再以该technology的标准,对tag设备进行读写。
3初始化流程
3.1 时序图
3.2 代码分析
初始化分两部分,第一是服务端的初始化,并将服务添加到ServiceManager中,第二是初始化NFC适配器NfcAdapter。
3.2.1 Server端初始化
NFC的服务端代码在packages/apps/Nfc中,并且还包含了JNI代码,前面也介绍过,NFC的服务端是一个应用程序,跟随系统启动并一直存在的一个服务进程。
NfcService继承于Application,当程序启动的时候,调用onCreate()方法,代码如下:
public void onCreate() {
super.onCreate();
mNfcTagService = new TagService();
mNfcAdapter = new NfcAdapterService();
mExtrasService = new NfcAdapterExtrasService();
……
mDeviceHost = new NativeNfcManager(this, this);
mNfcDispatcher = new NfcDispatcher(this, handoverManager);
mP2pLinkManager = new P2pLinkManager(mContext, handoverManager);
……
ServiceManager.addService(SERVICE_NAME, mNfcAdapter);//将mNfcAdapter添加到系统服务列表中。
…….
new EnableDisableTask().execute(TASK_BOOT); // do blocking boot tasks
}
TagService是NfcService的内部类,并继承于INfcTag.stub,因此客户端可以通过Binder通信获取到TagService的实例mNfcTagService。其主要的功能是完成tag的读写。
NfcAdapterService也是NfcService的内部类,并继承于INfcAdapter.stub,同样客户端可以通过Binder通信获取到NfcAdapterService的实例mNfcAdapter。NfcAdapterService也是暴露给客户端的主要接口,主要完成对NFC的使能初始化,扫面读写tag,派发tag消息等。
NativeNfcManager类就像其名字一样,主要负责native JNI的管理。
NfcDispatcher主要负责tag消息处理,并派发Intent消息,启动Activity。
3.2.2 NfcAdapter客户端初始化
在ContextImpl类中,有一个静态模块,在这里创建了NfcManager的实例,并注册到服务中,代码如下:
Static{
registerService(NFC_SERVICE, new ServiceFetcher() {
public Object createService(ContextImpl ctx) {
return newNfcManager(ctx);
}});
}
在NfcManager的构造函数中,调用了NfcAdapter.getNfcAdapter(context),创建NFC Adapter。
public static synchronized NfcAdapter getNfcAdapter(Context context) {
……
sService =getServiceInterface();//获取NFC服务接口
……
try {
sTagService = sService.getNfcTagInterface();//获取NFC tag服务接口
} catch (RemoteException e) {
}
……
NfcAdapter adapter = sNfcAdapters.get(context);
if (adapter == null) {
adapter =new NfcAdapter(context);
sNfcAdapters.put(context, adapter);
}
return adapter;
}
private static INfcAdapter getServiceInterface() {//获取NFC服务接口
IBinder b =ServiceManager.getService("nfc");
if (b == null) {
return null;
}
return INfcAdapter.Stub.asInterface(b);
}
我们看看getServiceInterface()方法,在3.2.1我们也看到了,调用ServiceManager.addService()将NfcAdapterService的实例添加到系统的服务列表中,这里我们调用了ServiceManager.getService(“nfc”)获取到了服务端的NfcAdapterService对象的实例。
在NfcAdapterService类中提供了getNfcTagInterface接口,用于获取远程服务端的TagService对象的实例。
如果一切正常,那么将创建NfcAdapter的实例,在其构造函数中,创建了NfcActivityManager的实例。
4 启动NFC流程
4.1 时序图
4.2 代码分析
如果android设备有NFC硬件支持,那么将在设置应用的出现“无线和网络à更多àNFC”选项,点击将使能NFC功能。其实就是调用了NfcAdapter.enable()方法,代码如下:
public boolean enable() {
try {
returnsService.enable(); //调用了远程服务NfcAdapterService的enable方法
} catch (RemoteException e) {
}
}
在NfcAdapterService.enable()方法中,创建了一个Task任务来完成使能工作,代码如下:
public boolean enable() throws RemoteException {
……
new EnableDisableTask().execute(TASK_ENABLE);
return true;
}
EnableDisableTask是NfcService的一个内部类,继承于AsyncTask,一个异步的任务线程,实际工作的doInBackground方法中。根据了TASK_ENABLE参数,选择调用到了EnableDisableTask. enableInternal()完成NFC功能的使能,代码如下:
boolean enableInternal() {
……
if (!mDeviceHost.initialize()) { //NFC硬件初始化
return false;
}
synchronized(NfcService.this) {
mObjectMap.clear();
mP2pLinkManager.enableDisable(mIsNdefPushEnabled, true);//P2p功能的启动
updateState(NfcAdapter.STATE_ON);
}
initSoundPool();
applyRouting(true); //开始扫描
return true;
}
mDeviceHost其实是NativeNfcManager的实例,其继承于DeviceHost。调用了其initialize()方法,接着调用JNI方法doInitialize(),完成对NFC硬件的初始化。
硬件初始化完成之后,就需要初始化P2pLiskManager。P2p就是点对点传送的意思。这里初始化,需要创建读取数据线程,以及socket的创建。
下面看看P2pLinkManager.enableDisable(),启动P2p功能:
public void enableDisable(boolean sendEnable, boolean receiveEnable) {
if (!mIsReceiveEnabled && receiveEnable) {
mDefaultSnepServer.start();
mNdefPushServer.start();
……
} else ……
}
这里启动了两个服务,分别是SnepServer和NdefPushServer,但是在实际使用过程中优先使用SnepServer服务,只有当其使用失败的时候,才会用到NdefPushServer服务。所以,我们这里就看SnepServer就可以了,NdefPushServer也比较相似。SnepServer.start():
public void start() {
mServerThread = new ServerThread();
mServerThread.start();
mServerRunning = true;
}
代码非常的简单,ServerThread是继承与Thread的,且是SnepServer的内部类。看看其run()方法,为了方便理解,剪切了不少代码:
public void run() {
while (threadRunning) {
if (DBG) Log.d(TAG, "about create LLCP service socket");
try {
mServerSocket = NfcService.getInstance().createLlcpServerSocket(mServiceSap,
mServiceName, MIU, 1, 1024);//创建Socket
while (threadRunning) {
LlcpServerSocket serverSocket;
synchronized (SnepServer.this) {
serverSocket = mServerSocket;
}
LlcpSocket communicationSocket = serverSocket.accept();//创建Socket
if (communicationSocket != null) {
int miu = communicationSocket.getRemoteMiu();
new ConnectionThread(communicationSocket, fragmentLength).start();
}
}
}
}
这里主要是完成了Socket的创建,这个Socket是用于接收其他设备发送过来的数据的,ConnectionThread也是SnepServer的内部类,继承与Thread,看看其run()函数:
public void run() {
try {……
while (running) {
if (!handleRequest(mMessager, mCallback)) {
break;
}
synchronized (SnepServer.this) {
running = mServerRunning;
}
}
}
}
这个是一个连接线程,与客户端的Socket连接,如果有接收到Socket发送的数据的时候,就用handlerRequest处理数据。
以上已经完成了P2p设备的初始化,下面就需要去扫描查询tag及P2p设备。
本调用applyRouting(true)开始扫描tag及P2p消息。
void applyRouting(boolean force) {
……
try {
……
// configure NFC-EE routing
if (mScreenState >= SCREEN_STATE_ON_LOCKED &&
mEeRoutingState == ROUTE_ON_WHEN_SCREEN_ON) {
if (force || !mNfceeRouteEnabled) {
mDeviceHost.doSelectSecureElement();
}
} else {
if (force || mNfceeRouteEnabled) {
mDeviceHost.doDeselectSecureElement();
}
}
// configure NFC-C polling
if (mScreenState >= POLLING_MODE) {
if (force || !mNfcPollingEnabled) {
mDeviceHost.enableDiscovery();
}
} else {
if (force || mNfcPollingEnabled) {
mDeviceHost.disableDiscovery();
}
}
} finally {
watchDog.cancel();
}
}
}
这里我们关注NativeNfcManager.enableDiscovery()方法,最终调用到JNI中,在JNI中注册了回调函数,当扫描到tag或p2p后,将回调Java层函数。如果发现Tag设备,将会回调NativeManager.notifyNdefMessageListeners()方法,如果发现P2p设备,将会回调NativeManager.notifyLlcpLinkActivation()方法。JNI代码我们就不分析了,我们就主要关注这两个方法就可以了:
private void notifyNdefMessageListeners(NativeNfcTag tag) {
mListener.onRemoteEndpointDiscovered(tag);
}
private void notifyLlcpLinkActivation(NativeP2pDevice device) {
mListener.onLlcpLinkActivated(device);
}
5 NDEF数据读写流程
5.1 小数据量的传送
小数据量的传送,指的是传送联系人、网页地址、邮件、包名等,数据量比较小,可以直接用。
5.1.1读写流程图
5.1.2 数据写流程
5.1.2.1时序图
5.1.2.2代码分析
NfcAdapter提供了两个接口给应用程序设置推送的数据:
public void setNdefPushMessage(NdefMessage message, Activity activity,);//
public void setNdefPushMessageCallback(CreateNdefMessageCallback callback, Activity activity,);
public interface CreateNdefMessageCallback {
public NdefMessage createNdefMessage(NfcEvent event);
}
第一种是直接在Apk中完成NdefMessage数据的封装,调用setNdefPushMessage()进行设置,第二种是通过注册回调的方式,创建NdefMessage数据。这两个方式都一样,都需要将创建好的数据存放在NfcActivityState. ndefMessage变量中,等待着NfcService来取。NfcActivityState数据NfcActivityManager的内部类,每个Apk进行数据推送设置时,都会创建对应的NfcActivityState实例,该实例的ndefMessage变量就是用来存放封装好的NdefMessage数据的。
这里我需要说的是,当APK正在运行的时候,就已经完成了数据的封装,此时如果发现NFC设备,那么NfcService将取出数据进行推送。
前面介绍了NFC启动流程的时候,说到了在JNI中完成了回调函数的注册,当发现有P2p设备的时候,将会回调java层NativeNfcManager的notifyLlcpLinkActivation()方法:
private void notifyLlcpLinkActivation(NativeP2pDevice device) {
mListener.onLlcpLinkActivated(device);
}
这里的mListener其实是NfcService的实例,构造NativeNfcManager的时候注册进来的,那么将调用NfcService. onLlcpLinkActivated():
public void onLlcpLinkActivated(NfcDepEndpoint device) {
sendMessage(NfcService.MSG_LLCP_LINK_ACTIVATION, device);
}
发送Handler消息MSG_LLCP_LINK_ACTIVATION,那么将在NfcServiceHandler.handleMessage()中处理该消息,其是NfcService的内部类。接着调用了NfcServiceHandler. llcpActivated().然后调用P2pLinkManager.onLlcpActivated(),我们看看:
public void onLlcpActivated() {
switch (mLinkState) {
case LINK_STATE_DOWN:
mEventListener.onP2pInRange();
prepareMessageToSend();
if (mMessageToSend != null ||
(mUrisToSend != null && mHandoverManager.isHandoverSupported())) {
mSendState = SEND_STATE_NEED_CONFIRMATION;
mEventListener.onP2pSendConfirmationRequested();
}
break;
}
void prepareMessageToSend() {
if (mCallbackNdef != null) {
try {
mMessageToSend = mCallbackNdef.createMessage();//取出Apk中准备的数据
mUrisToSend = mCallbackNdef.getUris();//大数据量的数据
return;
} catch (RemoteException e) {
// Ignore
}
}
List<RunningTaskInfo> tasks = mActivityManager.getRunningTasks(1);
if (tasks.size() > 0) {
String pkg = tasks.get(0).baseActivity.getPackageName();
if (beamDefaultDisabled(pkg)) {//判断当前运行的是否是Home程序
Log.d(TAG, "Disabling default Beam behavior");
mMessageToSend = null;
} else {
mMessageToSend = createDefaultNdef(pkg);//将当前运行的包名数据封装在NdefMessage中。
}
} else {
mMessageToSend = null;
}
}
}
这里我们需要关注prepareMessageToSend()方法,这个方法就是完成准备将要被发送的数据。这里面有三种数据需要取,对于小数据量,我们只关注其中两种。
n 第一种,在当前运行Apk中准备有数据,mCallbackNdef变量其实是NfcActivityManager的实例,是当前运行的Apk设置的,通过Binder通信调用了其createMessage()方法,取出了当前运行Apk设置在NfcActivityState. ndefMessage变量中的数据。
n 第二种,是当前Apk没有准备有推送的数据,那么就将其包名作为数据,封装在NdefMessage中
数据准备好之后,暂时存放在P2pLinkManager. mMessageToSend变量中。
数据准备好后,将调用mEventListener.onP2pSendConfirmationRequested();发送P2p事件,mEventListener是P2pEventManager的实例,看看其代码:
public void onP2pSendConfirmationRequested() {
final int uiModeType = mContext.getResources().getConfiguration().uiMode
& Configuration.UI_MODE_TYPE_MASK;
if (uiModeType == Configuration.UI_MODE_TYPE_APPLIANCE) {
mCallback.onP2pSendConfirmed();
} else {
mSendUi.showPreSend();//缩小屏幕
}
}
根据模式的选择,调用到SendUi.showPreSend()方法,这个方法完成的功能是缩小屏幕供用户点击,当用户点击的时候才能推送数据,点击的时候,将回调P2pEventManager.onSendConfirmed()方法:
public void onSendConfirmed() {
if (!mSending) {
mSendUi.showStartSend();
mCallback.onP2pSendConfirmed();
}
}
mCallback其实是P2pLinkManager的实例,调用onP2pSendConfirmed():
public void onP2pSendConfirmed() {
sendNdefMessage();
}
void sendNdefMessage() {
synchronized (this) {
cancelSendNdefMessage();
mSendTask = new SendTask();
mSendTask.execute();
}
}
调用了sendNdefMessage(),在该方法中,创建了SendTask实例,其继承于Task,且是P2pLinkManager的内部类,看看SendTask的doInBackground()方法:
public Void doInBackground(Void... args) {
NdefMessage m;
Uri[] uris;
boolean result;
synchronized (P2pLinkManager.this) {
m = mMessageToSend;
uris = mUrisToSend;
}
try {
int snepResult =doSnepProtocol(mHandoverManager, m, uris);
} catch (IOException e) {
if (m != null) {
result = new NdefPushClient().push(m);
} else {
result = false;
}
}
}
在异步在Task中,开始数据的推送。doSnepProtocol方法其实是通过SnepServer服务完成推送,而只有其出现异常的时候才会启用NdefPushServer完成推送。看看P2pLinkManagerdoSnepProtocol().:
static int doSnepProtocol(HandoverManager handoverManager,
NdefMessage msg, Uri[] uris) throws IOException {
SnepClient snepClient = new SnepClient();
try {
snepClient.connect();
} catch (IOException e) {
}
try {
if (uris != null) {//小数据量,uris为空
……
} else if (msg != null) {
snepClient.put(msg);
}
return SNEP_SUCCESS;
} catch (IOException e) {
// SNEP available but had errors, don't fall back to NPP.
}
}
在该方法中,构建了一个SnepClient的实例,变调用snepClient.connect(),其实就是创建了Socket的客户端,并使其连接起来,通过Socket将数据推送。
对于小数据量,uris为空,mgs不为空。调用snepClient.put(msg)了开始数据的推送。
5.1.3 数据读流程
5.1.3.1时序图
5.1.3.2代码分析
在前面接收启动NFC流程的时候,提到了P2pLinkManager的初始化,在初始化中,启动了一个线程,用于接收数据的,我们看看SnepServer. ConnectionThread线程的run函数:
ConnectionThread(LlcpSocket socket, int fragmentLength) {
super(TAG);
mSock = socket;
mMessager = new SnepMessenger(false, socket, fragmentLength);
}
public void run() {
if (DBG) Log.d(TAG, "starting connection thread");
try {
boolean running;
synchronized (SnepServer.this) {
running = mServerRunning;
}
while (running) {
if (!handleRequest(mMessager, mCallback)) {//读取消息
break;
}
synchronized (SnepServer.this) {
running = mServerRunning;
}
}
} catch (IOException e) {
}
}
开启线程接收数据,在handlerRequest()完成数据的处理,我们注意到有两个参数,第一个mMessager是SnepMessenger的实例,在ConnectionThread的构造函数被创建的。看看SnepServer.handlerRequest()方法吧:
static boolean handleRequest(SnepMessenger messenger, Callback callback) throws IOException {
SnepMessage request;
try {
request = messenger.getMessage();//真正的读数据
} catch (SnepException e) {
……
return false;
}
if (((request.getVersion() & 0xF0) >> 4) != SnepMessage.VERSION_MAJOR) {
……
} else if (request.getField() == SnepMessage.REQUEST_GET) {
//在需要蓝牙传送大量数据的时候,用到的
……
} else if (request.getField() == SnepMessage.REQUEST_PUT) {
messenger.sendMessage(callback.doPut(request.getNdefMessage()));//回调doput方法,传送数据
} else {
……
}
return true;
}
SnepMessenger类其实是将数据有封装了一层到SnepMessage,调用SnepMessenger.getMessage,通过Socket读取到数据,调用SnepMessage.getNdefMessage将读取到的数据转换成NdefMessage,然后调用callback.doPut()将数据传送到P2pLinkManager。Callback接口在P2pLinkManager被实现了:
final SnepServer.Callback mDefaultSnepCallback = new SnepServer.Callback() {
@Override
public SnepMessagedoPut(NdefMessage msg) {
onReceiveComplete(msg); //处理NdefMessage数据
return SnepMessage.getMessage(SnepMessage.RESPONSE_SUCCESS);
}
@Override
public SnepMessage doGet(int acceptableLength, NdefMessage msg) {
NdefMessage response = mHandoverManager.tryHandoverRequest(msg);
}
};
void onReceiveComplete(NdefMessage msg) {
// Make callbacks on UI thread
mHandler.obtainMessage(MSG_RECEIVE_COMPLETE, msg).sendToTarget();
}
在onReceiveComplete(msg)中,通过发送Handler消息对MSG_RECEIVE_COMPLETE,将NdefMessage数据的继续往上传。在P2pLinkManager. handleMessage()接收处理消息:
public boolean handleMessage(Message msg) {
case MSG_RECEIVE_COMPLETE:
NdefMessage m = (NdefMessage) msg.obj;
mEventListener.onP2pReceiveComplete(true);
NfcService.getInstance().sendMockNdefTag(m);
}
break;
}
调用了NfcService的sendMockDefTag()方法:
public void sendMockNdefTag(NdefMessage msg) {
sendMessage(MSG_MOCK_NDEF, msg);
}
再一次发送Handler消息,将msg传到NfcServiceHandler中,代码如下:
case MSG_MOCK_NDEF: {
NdefMessage ndefMsg = (NdefMessage) msg.obj;
Bundle extras = new Bundle();
extras.putParcelable(Ndef.EXTRA_NDEF_MSG, ndefMsg);
…….
Tag tag = Tag.createMockTag(new byte[] { 0x00 },
new int[] { TagTechnology.NDEF },
new Bundle[] {extras });
boolean delivered = mNfcDispatcher.dispatchTag(tag);
break;
}
在这里,对NdefMessage数据进行了一次封装,将其封装到Tag里面,然后调用NfcDispatcher.dispatchTag()派发Tag数据。详细代码如下:
public boolean dispatchTag(Tag tag) {
NdefMessage message = null;
Ndef ndef = Ndef.get(tag); //前面调用Tag.createMockTag创建Tag实例的时候
if (ndef != null) {
message = ndef.getCachedNdefMessage();
}
……
DispatchInfo dispatch = new DispatchInfo(mContext, tag, message);
……
if (tryNdef(dispatch, message)) {
return true;
}……
return false;
}
public DispatchInfo(Context context, Tag tag, NdefMessage message) {
intent = new Intent();
intent.putExtra(NfcAdapter.EXTRA_TAG, tag);
intent.putExtra(NfcAdapter.EXTRA_ID, tag.getId());
if (message != null) {
intent.putExtra(NfcAdapter.EXTRA_NDEF_MESSAGES, new NdefMessage[] {message});
ndefUri = message.getRecords()[0].toUri();
ndefMimeType = message.getRecords()[0].toMimeType();
} else {
ndefUri = null;
ndefMimeType = null;
}
}
前面调用Tag.createMockTag创建Tag实例的时候,带有TagTechnology.NDEF参数,已经说明了Tag支持的数据类型是NDEF,所以这里调用Ndef.get(tag)返回的ndef不为空,message也不为空,我之前读取的NdefMessage数据。
接着够着了一个DispatchInfo的实例,在构造函数中,创建了Intent的实例,并将tag、message封装到Intent中,供Activity读取。这里还将NdefMessage转换为uri和mime,这两个数据也是用来找Activity的一个参数。
然后调用NfcDispatcher.tryNdef()尝试发送NDEF消息启动Activity,这个能成功启动。代码如下:
public Intent setNdefIntent() {
intent.setAction(NfcAdapter.ACTION_NDEF_DISCOVERED);
if (ndefUri != null) {
intent.setData(ndefUri);
return intent;
} else if (ndefMimeType != null) {
intent.setType(ndefMimeType);
return intent;
}
return null;
}
boolean tryNdef(DispatchInfo dispatch, NdefMessage message) {
dispatch.setNdefIntent();//设置Action为ACTION_NDEF_DISCOVERED
// Try to start AAR activity with matching filter
List<String> aarPackages = extractAarPackages(message);//将数据转换成合法的包名
for (String pkg : aarPackages) {
dispatch.intent.setPackage(pkg);
if (dispatch.tryStartActivity()) {
if (DBG) Log.i(TAG, "matched AAR to NDEF");
return true;
}
}
// Try to perform regular launch of the first AAR
if (aarPackages.size() > 0) {
String firstPackage = aarPackages.get(0);
Intent appLaunchIntent =mPackageManager.getLaunchIntentForPackage(firstPackage);
if (appLaunchIntent != null && dispatch.tryStartActivity(appLaunchIntent)) {
if (DBG) Log.i(TAG, "matched AAR to application launch");
return true;
}
// Find the package in Market:
Intent marketIntent = getAppSearchIntent(firstPackage);
if (marketIntent != null && dispatch.tryStartActivity(marketIntent)) {
if (DBG) Log.i(TAG, "matched AAR to market launch");
return true;
}
}
// regular launch
dispatch.intent.setPackage(null);
if (dispatch.tryStartActivity()) {
if (DBG) Log.i(TAG, "matched NDEF");
return true;
}
return false;
}
首先调用setNdefIntent设置Intent的Action为ACTION_NDEF_DISCOVERED,如果前面读取的ndefUri、ndefMimeType不为空,那么设置到Intent里。
下面的代码,有四种方式处理数据发送不同的Intent。我们需要注意的是,首先需要调用extractAarPackages()将NdefMessage数据转换层系统合法的包名,下面看4种处理的方式:
n 第一种为AAR,为 Android Application Record的简写
如果作为P2p的发送端,调用NdefRecord.createApplicationRecord (String packageName)将包名封装到Ndefmessage中,意思是只允许包名为packageName的Apk处理数据。那么现在我们分析的是接收端的代码,解析NdefMessage数据,将其转换成合法的包名。如果包名存在于当前的系统中,那么就启动该Apk来处理数据。所以对于AAR,接收数据的包名必须是packageName,Activity的ACTION必须包含ACTION_NDEF_DISCOVERED,数据类型必须满足ndefUri、ndefMimeType。
n 以包名封装Intent
如果NdefMessage中能转换成合法的包名,且前面的Intent没有Activity响应,那么就需要一包名封装的Intent启动Activity。这样情况是把当前正在运行的apk的包名发送给其他设备,其他设备将启动该apk
n 在第二种Intent的情况下,如果接收设备没有该Apk,那么将通过Intent启动google play去下载该Apk
n 第四种为正常类型,通过Action为ACTION_NDEF_DISCOVERED、及ndefUri、ndefMimeType去启动Activity。有可能多个Activity响应的。
0 0