5.2 大数据量的传送
大数据量的传送,是指图片等数据量比较大的资源,需要通过NFC启动蓝牙的匹配,通过蓝牙来传送数据。
5.2.1 读写流程图
5.2.2 发送端发送蓝牙请求和发送数据流程
5.2.2.1时序图
大数据量的写操作跟小数据量的类似,我们这里主要关注差异的部分,我们从P2pLinkManager.doSenpProtocol()开始。前面部分的时序图,请查看5.1.2.1小数据量写操作的时序图.
5.2.2.2 代码分析
在看P2pLinkManager.doSenpProtocol()之前,我们先看看发送数据的Apk是如何设置数据的吧。
mNfcAdapter = NfcAdapter.getDefaultAdapter(mActivity.getAndroidContext()); mNfcAdapter.setBeamPushUris(new Uri[]{manager.getContentUri(path)},Activity); |
以上代码是在Gallery2中设置图片资源的代码,将图片的路径封装在Uri数组中,并调用NfcAdapter. setBeamPushUris()进行设置。这个跟小数据量的设置类似,是将数据保存在NfcActivityState. Uris变量中。P2pLinkManager将回调NfcActivityManager.getUris()获取到该数据。我们看看代码吧:
void prepareMessageToSend() { …… if (mCallbackNdef != null) { try { mMessageToSend = mCallbackNdef.createMessage(); mUrisToSend = mCallbackNdef.getUris(); return; } catch (RemoteException e) { } } } } |
P2pLinkManager. prepareMessageToSend()方法相信已经不再陌生,前面也见到过,这里就是通过Binder回调了NfcActivityManager.getUris()方法,读取数据,并暂存在mUrisToSend变量中。
好了,经过简单的介绍,那么现在我们可以从P2pLinkManager. doSenpProtocol()开始了,代码如下:
static int doSnepProtocol(HandoverManager handoverManager, NdefMessage msg, Uri[] uris) throws IOException { SnepClient snepClient = new SnepClient();//创建新的客户端 try { snepClient.connect();//与socket连接 } catch (IOException e) { } try { if (uris != null) {//说明有大数据量要发送 NdefMessage response = null; //封装蓝牙标志的请求信息在NdefMessage中 NdefMessage request = handoverManager.createHandoverRequestMessage(); if (request != null) { SnepMessage snepResponse = snepClient.get(request);//发送蓝牙请求,并读取另外设备回应数据保存在snepResponse中 response = snepResponse.getNdefMessage();//将SnepMessage数据转换成NdefMessage } // else, handover not supported if (response != null) {//有相应,可以发送数据 handoverManager.doHandoverUri(uris, response);//通过蓝牙发送数据 } else if (msg != null) { snepClient.put(msg); } else { return SNEP_HANDOVER_UNSUPPORTED; } } …… } |
在大数据量传送流程图中也说到,发送端要发送图片之前,需要创建标准的蓝牙请求信息,然后将信息封装在Ndefmessage中,发送给接收端,当收到接收端回应之后才能发送真正的图片数据。
下面我们来看看标准蓝牙请求数据的创建代码如下:
HandoverManager.createHandoverRequestMessage():
public NdefMessage createHandoverRequestMessage() { if (mBluetoothAdapter == null) return null;//是否支持蓝牙设备 return new NdefMessage(createHandoverRequestRecord(), createBluetoothOobDataRecord());//将数据封装在NdefMessage中 } |
当然,需要设备有蓝牙的支持,否则面谈,接着调用两个接口创建两个NdefRecord,封装在NdefMessage中。
先看看HandoverManager. createHandoverRequestRecord()方法,蓝牙请求数据:
NdefRecord createHandoverRequestRecord() { NdefMessage nestedMessage = new NdefMessage(createCollisionRecord(), createBluetoothAlternateCarrierRecord(false)); byte[] nestedPayload = nestedMessage.toByteArray(); ByteBuffer payload = ByteBuffer.allocate(nestedPayload.length + 1); payload.put((byte)0x12); // connection handover v1.2 payload.put(nestedMessage.toByteArray()); byte[] payloadBytes = new byte[payload.position()]; payload.position(0); payload.get(payloadBytes); return new NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_HANDOVER_REQUEST, null, payloadBytes); } |
接着看HandoverManager. createBluetoothOobDataRecord(),创建当前设备蓝牙地址数据:
NdefRecord createBluetoothOobDataRecord() { byte[] payload = new byte[8]; payload[0] = 0; payload[1] = (byte)payload.length; synchronized (HandoverManager.this) { if (mLocalBluetoothAddress == null) { mLocalBluetoothAddress = mBluetoothAdapter.getAddress();//获取当前设备蓝牙地址 } byte[] addressBytes = addressToReverseBytes(mLocalBluetoothAddress); System.arraycopy(addressBytes, 0, payload, 2, 6);//地址数据拷贝 } return new NdefRecord(NdefRecord.TNF_MIME_MEDIA, TYPE_BT_OOB, new byte[]{'b'}, payload);//将地址封装在NdefRecord中 } |
上面两个方法,创建了两个NdefRecord,一个是蓝牙请求数据,另一个是当前蓝牙地址数据。好了,将量数据封装在NdefMessage中返回。我们回头继续看doSnepProtocol()方法。createHandoverRequestMessage()之后就到SnepClient.get(request)发送请求了:
public SnepMessage get(NdefMessage msg) throws IOException { SnepMessenger messenger; synchronized (this) { messenger = mMessenger; } synchronized (mTransmissionLock) { try { messenger.sendMessage(SnepMessage.getGetRequest(mAcceptableLength, msg));//发送请求 return messenger.getMessage();//获取回应 } catch (SnepException e) { throw new IOException(e); } } } |
在发送数据之前,先调用SnepMessage.getGetRequest(mAcceptableLength, msg)将NdefMessage数据转换成SnepMessage数据,然后调用SnepMessenger.sendMessage开始发送数据,SnepMessenger中包含了Socket的端口。
发送数据之后直接调用SnepMessenger.getMessage();获取另一设备的回应信息。这里有个疑问,一直不明白,发送完数据之后立刻获取回应,这样是怎么做到同步的呢?求解释…....
到此,我们继续回到P2pLinkManager. doSnepProtocol()中,SnepClient.get()的get请求有了回应,回应的信息还是封装在SnepMessage中,接着调用SnepMessage的方法getNdefMessage()将回应的数据转换成NdefMessage数据。
有了回应,说明蓝牙可以匹配,调用HandoverManager.doHandoverUri(uris, response),开始通过蓝牙发送Uri。
// This starts sending an Uri over BT public void doHandoverUri(Uri[] uris, NdefMessage m) { if (mBluetoothAdapter == null) return; BluetoothHandoverData data = parse(m);//解析回应出蓝也数据 if (data != null && data.valid) { // Register a new handover transfer object getOrCreateHandoverTransfer(data.device.getAddress(), false, true);//创建蓝牙转换器 BluetoothOppHandover handover = new BluetoothOppHandover(mContext, data.device, uris, mHandoverPowerManager, data.carrierActivating); handover.start();//开始发送数据 } } |
首先需要调用HandoverManager.parse()将回应数据解析为蓝牙数据,里面当然包含了接收设备的蓝牙地址,接着创建了一个BluetoothOppHandover()实例,这样,该实例就包含了接收设备的蓝牙地址,Uris数据,然后就调用其start()开始传送数据了。
下面就需要看看接收端是怎么回应蓝牙请求了的。
5.2.3 接收端回应蓝牙请求流程
5.2.3.1时序图
5.2.3.2 代码分析
SnepServer我们这里也不陌生了的,里面有ConnectionThread线程读取收到的数据,在run方法中调用SnepServer.handleRequest()处理请求数据:
static boolean handleRequest(SnepMessenger messenger, Callback callback) throws IOException { SnepMessage request; try { request = messenger.getMessage();//读取收到的数据 } catch (SnepException e) { …… } if (((request.getVersion() & 0xF0) >> 4) != SnepMessage.VERSION_MAJOR) { …… } else if (request.getField() == SnepMessage.REQUEST_GET) {//get请求 messenger.sendMessage(callback.doGet(request.getAcceptableLength(), request.getNdefMessage())); } else if (request.getField() == SnepMessage.REQUEST_PUT) {//put请求 if (DBG) Log.d(TAG, "putting message " + request.toString()); messenger.sendMessage(callback.doPut(request.getNdefMessage())); } else { …… } return true; } |
SnepMessenger.getMessage()这里也不陌生了,是用来读取收到的数据的,将数据保存在SnepMessage中。
要清楚的是,我们这里是要回应蓝牙的请求,所以这里我们满足了条件request.getField() == SnepMessage.REQUEST_GET,即get请求,意思是,接收到得到的数据是其他设备的请求信息,当前设备作为接收端,需要解析其请求数据,满足条件后,将发送回应信息的请求端。
callback.doGet()就是去处理请求的信息,然后返回回应的信息,通过SnepMessenger. sendMessage()回应发送给请求端。
先来看看callback.doGet()。这个前面也见到过,Callback接口在P2pLinkManager被实现了:
final SnepServer.Callback mDefaultSnepCallback = new SnepServer.Callback() { @Override public SnepMessage doPut(NdefMessage msg) { onReceiveComplete(msg); return SnepMessage.getMessage(SnepMessage.RESPONSE_SUCCESS); } @Override public SnepMessage doGet(int acceptableLength, NdefMessage msg) {//处理请求信息 NdefMessage response = mHandoverManager.tryHandoverRequest(msg);//尝试处理请求信息,并返回回应信息。 if (response != null) { onReceiveHandover(); return SnepMessage.getSuccessResponse(response);返回响应信息给SnepServer } else { return SnepMessage.getMessage(SnepMessage.RESPONSE_NOT_FOUND); } } }; |
代码简单,我们只需要关注HandoverManager.tryHandoverRequest(),参数类型是NdefMessage:
public NdefMessage tryHandoverRequest(NdefMessage m) { NdefRecord r = m.getRecords()[0]; //判断数据是否是蓝牙请求数据 if (r.getTnf() != NdefRecord.TNF_WELL_KNOWN) return null; if (!Arrays.equals(r.getType(), NdefRecord.RTD_HANDOVER_REQUEST)) return null; BluetoothHandoverData bluetoothData = null; for (NdefRecord oob : m.getRecords()) { if (oob.getTnf() == NdefRecord.TNF_MIME_MEDIA && Arrays.equals(oob.getType(), TYPE_BT_OOB)) { bluetoothData = parseBtOob(ByteBuffer.wrap(oob.getPayload()));//解析蓝牙数据,当然包含了发送端的蓝牙地址 break; } } synchronized(HandoverManager.this) { if (!mHandoverPowerManager.isBluetoothEnabled()) { if (!mHandoverPowerManager.enableBluetooth()) {//启用当前设备的蓝牙 return null; } } // Create the initial transfer object HandoverTransfer transfer = getOrCreateHandoverTransfer(//创建蓝牙转换器 bluetoothData.device.getAddress(), true, true); transfer.updateNotification();//发送通知准备接收图片数据,状态栏看到了进度条 } // BT OOB found, whitelist it for incoming OPP data whitelistOppDevice(bluetoothData.device);//将蓝牙请求端设备添加到列表中 // return BT OOB record so they can perform handover return (createHandoverSelectMessage(bluetoothActivating));创建并返回响应的数据 } |
该方法的参数是NdefMessage,第一步需要判断数据是否是蓝牙请求数据。
第二步,符合标准之后,读取出蓝牙地址数据bluetoothData。
第三步,启用当前设备的蓝牙。
第四步,将获取到的蓝牙请求端的蓝牙地址数据,创建蓝牙转换器
第五步,发送通知准备接收图片数据,这时候状态栏那里就可以看到进图条了。
第六步,将蓝牙请求端设备添加到列表中。
第七步,创建并返回响应的数据。这里跟请求端创建请求数据类似,里面也包含了当前蓝牙设备的地址和回应数据。都封装在NdefMessage中。
Ok,接收端蓝牙就开始等待接收数据了。HandoverManager.tryHandoverRequest()方法,就是完成两件事情,第一件事情就是第一到第六步,完成接收端蓝牙的匹配工作,第二件事情就是第七步,创建响应信息,并返回创建的回应信息给到doGet()方法中,在doGet()中,将NdefMessage 转换成SnepMessage,然后返回到SnepServer中的handleRequest()方法中:
messenger.sendMessage(callback.doGet(request.getAcceptableLength(), request.getNdefMessage())); |
接着调用SnepMessenger.sendMessage(SnepMessage),发送响应数据给请求端。
请求端接收到相应数据后,就开始通过匹配蓝牙发送图片等大数据量的数据了。简单吧。
6 Tag设备读写流程
6.1 Tag设备读写流程图
6.2 时序图
6.2 代码分析
在4.2中,NFC的启动将调用NativeNfcManager.enableDiscovery(),然后将调用到JNI方法com_android_nfc_NfcManager_enableDiscovery()扫描tag及P2p设备。在该方法中,调用phLibNfc_RemoteDev_NtfRegister()方法注册回调函数nfc_jni_Discovery_notification_callback()。当扫面到tag或P2p的时候将回调该方法。下面看看JNI钟开始NFC设备扫描的方法com_android_nfc_NfcManager_enableDiscovery():
static void com_android_nfc_NfcManager_enableDiscovery(JNIEnv *e, jobject o) { NFCSTATUS ret; struct nfc_jni_native_data *nat; CONCURRENCY_LOCK(); nat = nfc_jni_get_nat(e, o); REENTRANCE_LOCK(); ret = phLibNfc_RemoteDev_NtfRegister(&nat->registry_info, nfc_jni_Discovery_notification_callback, (void *)nat); //注册回调函数 REENTRANCE_UNLOCK(); …… nfc_jni_start_discovery_locked(nat, false);//开始扫描 clean_and_return: CONCURRENCY_UNLOCK(); } |
我们这里主要看到其注册回调函数,然后就开始扫描NFC设备了,当发现有NFC设备的时候,将会回调nfc_jni_Discovery_notification_callback()方法,代码如下:
static void nfc_jni_Discovery_notification_callback(void *pContext, phLibNfc_RemoteDevList_t *psRemoteDevList, uint8_t uNofRemoteDev, NFCSTATUS status) { TRACE("Notify Nfc Service"); if((remDevInfo->RemDevType == phNfc_eNfcIP1_Initiator) || (remDevInfo->RemDevType == phNfc_eNfcIP1_Target)) { hLlcpHandle = remDevHandle; e->CallVoidMethod(nat->manager, cached_NfcManager_notifyLlcpLinkActivation, tag); …… } else { e->CallVoidMethod(nat->manager, cached_NfcManager_notifyNdefMessageListeners, tag); …… } e->DeleteLocalRef(tag); } } |
前面也介绍过了,发现NFC设备分为两种,一种是Tag设备,即公交卡等卡类,另一种是手机、平板等设备,完成点对点(P2p)的数据交换。在以上方法中,分别对这两类型的NFC设备做不同的处理。
当发现P2P设备的时候,回调了java层的NativeNfcManager.notifyLlcpLinkActivation(),当发现一个新的tag的时候,回调了java层的NativeNfcManager. notifyNdefMessageListeners().这里我们主要关注发现新的tag,消息是如何传送的呢?
NativeNfcManager. notifyNdefMessageListeners()代码如下:
private void notifyNdefMessageListeners(NativeNfcTag tag) { mListener.onRemoteEndpointDiscovered(tag); } |
mListener其实就是NfcService的实例,调用了其onRemoteEndpointDiscovered()方法,代码如下:
@Override public void onRemoteEndpointDiscovered(TagEndpoint tag) { sendMessage(NfcService.MSG_NDEF_TAG, tag); } |
这里是发送了MSG_NDEF_TAG的Handler消息到NfcServiceHandler,是NfcService的子类。在其handleMessage()方法中处理:
case MSG_NDEF_TAG: TagEndpoint tag = (TagEndpoint) msg.obj; playSound(SOUND_START); NdefMessage ndefMsg = tag.findAndReadNdef(); if (ndefMsg != null) { tag.startPresenceChecking(); dispatchTagEndpoint(tag); } else { if (tag.reconnect()) { tag.startPresenceChecking(); dispatchTagEndpoint(tag); } else { …… } } break; |
这里的tag,其实是NativeNfcTag的实例,调用了其findAndReadNdef()方法读取NDEF信息,在这个方法中,调用NativeNfcTag. readNdef(),读取消息。接着调用JNI方法,doRead()从JNI中读取消息,然后返回给NdefMessage。因为这里发现的是TAG设备,所以,返回了ndefMgs=null。
接下来看tag消息的传送。
NfcServiceHandler.dispatchTagEndPoint():
private void dispatchTagEndpoint(TagEndpoint tagEndpoint) { Tag tag = new Tag(tagEndpoint.getUid(), tagEndpoint.getTechList(), tagEndpoint.getTechExtras(), tagEndpoint.getHandle(), mNfcTagService); registerTagObject(tagEndpoint); if (!mNfcDispatcher.dispatchTag(tag)) { unregisterObject(tagEndpoint.getHandle()); playSound(SOUND_ERROR); } else { playSound(SOUND_END); } } |
这里面将NativeNfcTag消息用于构造一个Tag,tagEndpoint.getTechList()取出该Tag设备支持的technology。mNfcDispatcher是NfcDispatcher的实例,用于向Activity派发消息的。然后调用mNfcDispatcher.dispatchTag派发Tag消息。代码如下:
public boolean dispatchTag(Tag tag) { NdefMessage message = null; Ndef ndef = Ndef.get(tag); …… PendingIntent overrideIntent; IntentFilter[] overrideFilters; String[][] overrideTechLists; DispatchInfo dispatch = new DispatchInfo(mContext, tag, message); synchronized (this) { overrideFilters = mOverrideFilters; overrideIntent = mOverrideIntent; overrideTechLists = mOverrideTechLists; } …… if (tryTech(dispatch, tag)) { return true; } } |
这个方法已经不再陌生了,前面也看到过了的。因为我们这里发现的是Tag设备,所以将选择调用了NfcDispatcher.tryTech()方法,代码如下:
boolean tryTech(DispatchInfo dispatch, Tag tag) { dispatch.setTechIntent();//设置Intent的Action为ACTION_TECH_DISCOVERED String[] tagTechs = tag.getTechList();//获取Tag设备支持的technology Arrays.sort(tagTechs); // Standard tech dispatch path ArrayList<ResolveInfo> matches = new ArrayList<ResolveInfo>(); List<ComponentInfo> registered = mTechListFilters.getComponents();//获取Action为ACTION_TECH_DISCOVERED的Activity列表 // Check each registered activity to see if it matches for (ComponentInfo info : registered) { // Don't allow wild card matching if (filterMatch(tagTechs, info.techs) &&//该Activity支持解析该technology isComponentEnabled(mPackageManager, info.resolveInfo)) { // Add the activity as a match if it's not already in the list if (!matches.contains(info.resolveInfo)) { matches.add(info.resolveInfo);//满足条件,添加到列表中 } } } if (matches.size() == 1) {//只有一个Activity满足条件 // Single match, launch directly ResolveInfo info = matches.get(0); dispatch.intent.setClassName(info.activityInfo.packageName, info.activityInfo.name); if (dispatch.tryStartActivity()) { if (DBG) Log.i(TAG, "matched single TECH"); return true; } dispatch.intent.setClassName((String)null, null); } else if (matches.size() > 1) {//多个Activity满足条件 // Multiple matches, show a custom activity chooser dialog Intent intent = new Intent(mContext, TechListChooserActivity.class); intent.putExtra(Intent.EXTRA_INTENT, dispatch.intent); intent.putParcelableArrayListExtra(TechListChooserActivity.EXTRA_RESOLVE_INFOS, matches); if (dispatch.tryStartActivity(intent)) { if (DBG) Log.i(TAG, "matched multiple TECH"); return true; } } return false; } |
第一步,还是需要设置Intent的Action为ACTION_TECH_DISCOVERED。
第二步,获取该Tag设备支持的technology。
第三步,读取系统中Action为ACTION_TECH_DISCOVERED的Activity列表,并获取该Apk支持解析的technology列表,这个是在apk的Xml文件中定义的:
<?xml version="1.0" encoding="utf-8"?> <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> <tech-list> <tech>android.nfc.tech.NfcA</tech> </tech-list> <tech-list> <tech>android.nfc.tech.NfcB</tech> </tech-list> </resources> |
第四步,做一个匹配,将支持解析该Tag设备technology的Apk添加到matches列表中
第五步,如果只有一个Activity满足条件,直接启动该Activity
第六步,如果有多个Activity满足条件,发送Intent消息供用户选择启动哪里Activity。
到此,Tag消息就已经传送到Activity了。那么接下来就需要在Activity中,发起对Tag设备的读写了。
6.3 Activity中发起对Tag设备读写
6.3.1 三个Intent启动Activity
当设备扫描发现有tag或P2p设备的时候,将数据封装好后发送Intent启动Activity处理数据,有三类型Intent:
n ACTION_NDEF_DISCOVERED :处理NDEF数据,包含MIME、URI数据类型
n ACTION_TECH_DISCOVERED :处理非NDEF数据或者NDEF数据但不能映射为MIME、URI数据类型
n ACTION_TAG_DISCOVERED :如果没有Activity相应上面两个Intent,就由该Intent处理
官网上调度图如下:
6.3.2 Activity中对Tag设备读写
经过前面一大串的分析,对于Tag设备,首先需要获取Tag信息,也说过,Tag信息包含了支持的technology类型。获取方式如下:
Tag tagFromIntent = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG); |
我们以MifareUltralight的technology类型为例子,根据Tag构造MifareUltralight:
MifareUltralight.get(tagFromIntent); |
看看MifareUltralight.get()接口吧:
public static MifareUltralight get(Tag tag) { if (!tag.hasTech(TagTechnology.MIFARE_ULTRALIGHT)) return null;//判断该Tag是否支持 try { return new MifareUltralight(tag); } catch (RemoteException e) { return null; } } |
get()方法中,需要判断Tag设备是否支持MifareUltralight类型的technology,如果支持,那么就真正的构造它。
得到了MifareUltralight实例后,就可以开始完成读写操作了。
public void writeTag(Tag tag, String tagText) { MifareUltralight ultralight = MifareUltralight.get(tag); try { ultralight.connect(); ultralight.writePage(4, "abcd".getBytes(Charset.forName("US-ASCII"))); ultralight.writePage(5, "efgh".getBytes(Charset.forName("US-ASCII"))); ultralight.writePage(6, "ijkl".getBytes(Charset.forName("US-ASCII"))); ultralight.writePage(7, "mnop".getBytes(Charset.forName("US-ASCII"))); } catch (IOException e) { Log.e(TAG, "IOException while closing MifareUltralight...", e); } finally { try { ultralight.close(); } catch (IOException e) { Log.e(TAG, "IOException while closing MifareUltralight...", e); } } } public String readTag(Tag tag) { MifareUltralight mifare = MifareUltralight.get(tag); try { mifare.connect(); byte[] payload = mifare.readPages(4); return new String(payload, Charset.forName("US-ASCII")); } catch (IOException e) { Log.e(TAG, "IOException while writing MifareUltralight message...", e); } finally { if (mifare != null) { try { mifare.close(); } catch (IOException e) { Log.e(TAG, "Error closing tag...", e); } } } return null; } |
不管是read还是write,都会调用到TagService中,然后是NativeNfcTag,最终到JNI中。详细代码就不分析了,感兴趣就自己看。
参考:
http://www.eoeandroid.com/thread-173822-1-1.html
http://www.cnblogs.com/doandroid/archive/2011/11/29/2267404.html
http://blog.csdn.net/wchinaw/article/details/6542831
http://leave001.blog.163.com/blog/static/16269129320122283648327/
http://wiki.eoeandroid.com/index.php?title=NFC_Basics&diff=4589&oldid=4580
http://doandroid.info/android中nfc功能解析及代码演示/
P2p设备http://blog.csdn.net/karen2lotus/article/details/7922948
对NFC理解很好:http://www.360doc.com/content/11/0524/13/474846_119019554.shtml