程序博客网 > 淘宝卖家交流论坛

NFC--Tag读写模式java层源码分析

来源：互联网 发布：淘宝卖家交流论坛 编辑：程序博客网 时间：2024/05/16 18:15
          文章整理总结NFC读取和写入Tag的java层的流程，至于一些native层的接入点，暂记住。后续持续更新。
1、读取Tag的流程
           NfcService启动完成后，会进入到NfcService中的applyRouting方法持续的监听是否有Tag靠近，它会使Nfc的RF工作在
polling模式，polling模式下会检测那个Tag进入到了自己的射频厂，进而产生反应。与其相对的是listen模式，Tag就相当于是listen
模式，监听谁往外polling，产生响应.
  1.     void applyRouting(boolean force) {
  2.         synchronized (this) {
  3.             ......
  4.             //mInProvisionMode：用来标记当前系统是否处于开机向导界面.
  5.             //对应于android开机时候的引导provision apk，是否出在引导模式
  6.             if (mInProvisionMode) {
  7.                 mInProvisionMode = Settings.Secure.getInt(mContentResolver,
  8.                         Settings.Global.DEVICE_PROVISIONED, 0) == 0;
  9.                 if (!mInProvisionMode) {
  10.                     //就是设置NfcDispatcher中的mProvisioningOnly = false;
  11.                     mNfcDispatcher.disableProvisioningMode();
  12.                     //调用native方法doSetProvisionMode，去通知native层，当前不是处于ProvisionMode
  13.                     mDeviceHost.doSetProvisionMode(mInProvisionMode);
  14.                 }
  15.             }
  16.             ......
  17.             try {
  18.                 //此处更新于polling状态的NFC的参数.computeDiscoveryParameters方法就是位于NfcService内部
  19.                 //所以就直接用执行到applyRouting之前实例化的一些全局参数进行了初始化，详见下一个函数.
  20.                 NfcDiscoveryParameters newParams = computeDiscoveryParameters(mScreenState);
  21.                 //传入参数为true的时候或者参数有所变化.
  22.                 if (force || !newParams.equals(mCurrentDiscoveryParameters)) {
  23.                     // shouldEnableDiscovery内及时一个判断语句为：mTechMask != 0 || mEnableHostRouting  
  24.                     if (newParams.shouldEnableDiscovery()) {
  25.                         boolean shouldRestart = mCurrentDiscoveryParameters.shouldEnableDiscovery();
  26.                         //最重要的就是调用到了这里，mDeviceHost的实现类是NativeNfcManager最终调用到内部的如下：
  27.                         //   private native void doEnableDiscovery(int techMask,
  28.                         //                  boolean enableLowPowerPolling,
  29.                         //                  boolean enableReaderMode,
  30.                         //                  boolean enableP2p,
  31.                         //                  boolean restart);
  32.                         //去native层，初始化发现Tag的流程。
  33.                         mDeviceHost.enableDiscovery(newParams, shouldRestart);
  34.                     } else {
  35.                         mDeviceHost.disableDiscovery();
  36.                     }
  37.                     mCurrentDiscoveryParameters = newParams;
  38.                 } else {
  39.                     Log.d(TAG, "Discovery configuration equal, not updating.");
  40.                 }
  41.             } finally {
  42.                 ......
  43.             }
  44.         }
  45.     }
         我们看一下computeDiscoveryParameters这个函数，它返回NfcDiscoveryParameters，这个类描述了处于polling或者listen
以及host card emulation.状态的NFC的参数.
  1.     private NfcDiscoveryParameters computeDiscoveryParameters(int screenState) {
  2.         //基于屏幕的状态重新计算NfcDiscoveryParameters.
  3.         NfcDiscoveryParameters.Builder paramsBuilder = NfcDiscoveryParameters.newBuilder();
  4.         // Polling
  5.         if ((screenState >= NFC_POLLING_MODE)||mIsTaskBoot) {
  6.             // Check if reader-mode is enabled
  7.             //当当前NFC读模式开启后，按照协议，看看当前的Tag属于那种类型的Tag，然后设置techMask.
  8.             //此处支持如下五中.
  9.             if (mReaderModeParams != null) {
  10.                 int techMask = 0;
  11.                 if ((mReaderModeParams.flags & NfcAdapter.FLAG_READER_NFC_A) != 0)
  12.                     techMask |= NFC_POLL_A;
  13.                 if ((mReaderModeParams.flags & NfcAdapter.FLAG_READER_NFC_B) != 0)
  14.                     techMask |= NFC_POLL_B;
  15.                 if ((mReaderModeParams.flags & NfcAdapter.FLAG_READER_NFC_F) != 0)
  16.                     techMask |= NFC_POLL_F;
  17.                 if ((mReaderModeParams.flags & NfcAdapter.FLAG_READER_NFC_V) != 0)
  18.                     techMask |= NFC_POLL_ISO15693;
  19.                 if ((mReaderModeParams.flags & NfcAdapter.FLAG_READER_NFC_BARCODE) != 0)
  20.                     techMask |= NFC_POLL_KOVIO;
  22.                 paramsBuilder.setTechMask(techMask);
  23.                 paramsBuilder.setEnableReaderMode(true);
  24.             } else {
  25.                 paramsBuilder.setTechMask(NfcDiscoveryParameters.NFC_POLL_DEFAULT);
  26.                 paramsBuilder.setEnableP2p(true);
  27.             }
  28.         //锁屏并且在ProvisionMode
  29.         } else if (screenState == ScreenStateHelper.SCREEN_STATE_ON_LOCKED && mInProvisionMode) {
  30.             paramsBuilder.setTechMask(NfcDiscoveryParameters.NFC_POLL_DEFAULT);
  31.             // enable P2P for MFM/EDU/Corp provisioning
  32.             paramsBuilder.setEnableP2p(true);
  33.         } else if (screenState == ScreenStateHelper.SCREEN_STATE_ON_LOCKED &&
  34.                 mNfcUnlockManager.isLockscreenPollingEnabled()) {
  35.             // For lock-screen tags, no low-power polling
  36.             paramsBuilder.setTechMask(mNfcUnlockManager.getLockscreenPollMask());
  37.             paramsBuilder.setEnableLowPowerDiscovery(false);
  38.             paramsBuilder.setEnableP2p(false);
  39.         }
  40.         //处在卡模拟状态是一直是使能的，即使屏幕关闭了。
  41.         if (mIsHceCapable && mScreenState >= ScreenStateHelper.SCREEN_STATE_ON_LOCKED) {
  42.             // Host routing is always enabled at lock screen or later
  43.             paramsBuilder.setEnableHostRouting(true);
  44.         }
  45.         //To make routing table update.
  46.         if(mIsRoutingTableDirty) {
  47.             mIsRoutingTableDirty = false;
  48.             //TODO: Take this logic from L_OSP_EXT [PN547C2]
  49.             int protoRoute = mNxpPrefs.getInt("PREF_MIFARE_DESFIRE_PROTO_ROUTE_ID", 
  50.                                                               GetDefaultMifareDesfireRouteEntry());
  51.             int defaultRoute=mNxpPrefs.getInt("PREF_SET_DEFAULT_ROUTE_ID", GetDefaultRouteEntry());
  52.             int techRoute=mNxpPrefs.getInt("PREF_MIFARE_CLT_ROUTE_ID", GetDefaultMifateCLTRouteEntry());
  54.             defaultRoute = NfcCertDebugModeUtil.calculateDefaultRoute(defaultRoute,
  55.                     mDeviceHost.getDefaultAidPowerState(), ROUTE_LOC_MASK);
  57.             if (DBG) Log.d(TAG, "Set default Route Entry");
  58.             setDefaultRoute(defaultRoute, protoRoute, techRoute);
  59.         }
  60.         ...
  61.         return paramsBuilder.build();
  62.     }
          通过JNI技术native层会调用doEnableDiscovery相对应的函数，进行一些列处理后，最终会回调到NativeNfcManager中的
  1.     private void notifyNdefMessageListeners(NativeNfcTag tag) {
  2.         mListener.onRemoteEndpointDiscovered(tag);
  3.     }
          mListener的实现就是NfcService，又重新回到Nfcservice中
  1.     @Override
  2.     public void onRemoteEndpointDiscovered(TagEndpoint tag) {
  3.         android.util.Log.d("zy","nfeservice onRemoteEndpointDiscovered ");
  4.         sendMessage(NfcService.MSG_NDEF_TAG, tag);
  5.     }
  6.     void sendMessage(int what, Object obj) {
  7.         Message msg = mHandler.obtainMessage();
  8.         msg.what = what;
  9.         msg.obj = obj;
  10.         mHandler.sendMessage(msg);
  11.     }
         到此为止，native层对发现的tag进行了一系列的初始化和封装操作，如按照ndef协议把Tag的消息封装到TagEndpoint当中
TagEndpoint就是代表了一个远端的Nfc tag.
         然后执行到mHandler中的MSG_NDEF_TAG
  1.                 case MSG_NDEF_TAG:
  2.                     ......
  3.                     //如果是reader模式
  4.                     if (readerParams != null) {
  5.                         presenceCheckDelay = readerParams.presenceCheckDelay;
  6.                         //如果FLAG_READER_SKIP_NDEF_CHECK标记位不为0，那么直接开始调用dispatchTagEndpoint分发
  7.                         if ((readerParams.flags & NfcAdapter.FLAG_READER_SKIP_NDEF_CHECK) != 0) {
  8.                             if (DBG) Log.d(TAG, "Skipping NDEF detection in reader mode");
  9.                             tag.startPresenceChecking(presenceCheckDelay, callback);
  10.                             dispatchTagEndpoint(tag, readerParams);
  11.                             break;
  12.                         }
  13.                     }
  14.                     //当是NFC Barcode的时候也是直接分发，（？？？）NFC Barcode是NFC tag中数据的一种模式吗？
  15.                     if (tag.getConnectedTechnology() == TagTechnology.NFC_BARCODE) {
  16.                         ......
  17.                         if (DBG) Log.d(TAG, "Skipping NDEF detection for NFC Barcode");
  18.                         tag.startPresenceChecking(presenceCheckDelay, callback);
  19.                         dispatchTagEndpoint(tag, readerParams);
  20.                         break;
  21.                     }
  22.                     //去调用NativeNfcTag的findAndReadNdef，进行相关初始化后把native层的数据按照NDEF
  23.                     //协议封装成java中的类NdefMessage.
  24.                     NdefMessage ndefMsg = tag.findAndReadNdef();
  25.                     //解析的消息有问题的时候，比如解析一个身份证或者公交卡，在你底层没有专门处理的时候是会失败的。
  26.                     if (ndefMsg == null) {
  27.                         // First try to see if this was a bad tag read
  28.                         if (!tag.reconnect()) {
  29.                             tag.disconnect();
  30.                             if (mScreenState == ScreenStateHelper.SCREEN_STATE_ON_UNLOCKED) {
  31.                                 String toastString = mContext.getString(
  32.                                         R.string.nfc_strings_toast_prompt_touch_again_txt);
  33.                                 if (!ToastMaster.isSameToastShown(toastString)) {
  34.                                     ToastMaster.showToast(mContext, toastString);
  35.                                 }
  36.                             }
  37.                             break;
  38.                         }
  39.                     }
  40.                     if(tag.getConnectedTechnology() == TagTechnology.NFC_F)
  41.                     {
  42.                         presenceCheckDelay = NFC_F_TRANSCEIVE_PRESENCE_CHECK_DELAY;
  43.                     }
  44.                     
  45.                     //这个如名字是抖动的tag，就是由于距离没控制好，一直检测到同一个tag的uid
  46.                     if (debounceTagUid != null) {
  47.                         // If we're debouncing and the UID or the NDEF message of the tag match,
  48.                         // don't dispatch but drop it.
  49.                         ......
  50.                     }
  52.                     mLastReadNdefMessage = ndefMsg;
  54.                     tag.startPresenceChecking(presenceCheckDelay, callback);
  55.                     //解析出问题的ndef消息也要分发出去.
  56.                     dispatchTagEndpoint(tag, readerParams);
  57.                     break;
        TagTechnology有很多种，按照对应的Tag技术协议进行的定定义
  1.     public static final int NFC_A = 1;
  3.     public static final int NFC_B = 2;
  5.     public static final int ISO_DEP = 3;
  7.     public static final int NFC_F = 4;
  9.     public static final int NFC_V = 5;
  10.     ......
          先了解NativeNfcTag几个常用的方法，方法内具体的native实现暂未分析。
         判断tag是否能转换成ndef的java层的代码如下，从注释也可以看出是让native去实现的，可能和芯片有关.
  1.     native boolean doIsIsoDepNdefFormatable(byte[] poll, byte[] act);
  2.     @Override
  3.     public synchronized boolean isNdefFormatable() {
  4.         // Let native code decide whether the currently activated tag
  5.         // is formatable.  Although the name of the JNI function refers
  6.         // to ISO-DEP, the JNI function checks all tag types.
  7.         return doIsIsoDepNdefFormatable(mTechPollBytes[0],
  8.                 mTechActBytes[0]);
  9.     }
          检查ndef的数据格式是否合法，方法过后感觉底层会往这个数组存放，当先Tag的一些信息.当前正在和那个Tag通信就是读
取的谁。
  1.     private native int doCheckNdef(int[] ndefinfo);
  2.     private synchronized int checkNdefWithStatus(int[] ndefinfo) {
  3.         if (mWatchdog != null) {
  4.             mWatchdog.pause();
  5.         }
  6.         int status = doCheckNdef(ndefinfo);
  7.         if (mWatchdog != null) {
  8.             mWatchdog.doResume();
  9.         }
  10.         return status;
  11.     }
          读取tag上的ndef数据，当前正在和那个Tag通信就是读取的谁。
  1.     private native byte[] doRead();
  2.     @Override
  3.     public synchronized byte[] readNdef() {
  4.         if (mWatchdog != null) {
  5.             mWatchdog.pause();
  6.         }
  7.         byte[] result = doRead();
  8.         if (mWatchdog != null) {
  9.             mWatchdog.doResume();
  10.         }
  11.         return result;
  12.     }
          然后就是重头戏findAndReadNdef
  1.     @Override
  2.     public NdefMessage findAndReadNdef(){
  3.         // Try to find NDEF on any of the technologies.
  4.         int[] technologies = getTechList();
  5.         int[] handles = mTechHandles;
  6.         NdefMessage ndefMsg = null;
  7.         boolean foundFormattable = false;
  8.         int formattableHandle = 0;
  9.         int formattableLibNfcType = 0;
  10.         int status;
  12.         for (int techIndex = 0; techIndex < technologies.length; techIndex++) {
  13.             ......
  14.             //？？？下面这个方法可能也和协议的实现相关，读了几遍代码暂很难理解
  15.             //网上：判断connectedHandle与当前Index对应的handle的关系,并更新状态, 。
  16.             status = connectWithStatus(technologies[techIndex]);
  17.             //状态返回不为0的时候直接跳过本次循环。
  18.             if (status != 0) {
  19.                 Log.d(TAG, "Connect Failed - status = "+ status);
  20.                 if (status == STATUS_CODE_TARGET_LOST) {
  21.                     break;
  22.                 }
  23.                 continue;  // try next handle
  24.             }
  25.             // 判断当前的tag是否可以转换成ndef格式.
  26.             if (!foundFormattable) {
  27.                 //如果可以转换
  28.                 if (isNdefFormatable()) {
  29.                     foundFormattable = true;
  30.                     formattableHandle = getConnectedHandle();
  31.                     formattableLibNfcType = getConnectedLibNfcType();
  32.                 }
  33.                 reconnect();
  34.             }
  35.             //检查当前tag中ndef数据的合法性
  36.             int[] ndefinfo = new int[2];
  37.             status = checkNdefWithStatus(ndefinfo);
  38.             if (status != 0) {
  39.                 Log.d(TAG, "Check NDEF Failed - status = " + status);
  40.                 if (status == STATUS_CODE_TARGET_LOST) {
  41.                     break;
  42.                 }
  43.                 continue;  // try next handle
  44.             }
  46.             // found our NDEF handle
  47.             boolean generateEmptyNdef = false;
  49.             int supportedNdefLength = ndefinfo[0];
  50.             int cardState = ndefinfo[1];
  51.             //读取tag中的数据，读出来的是字节数组。
  52.             byte[] buff = readNdef();
  53.             if (buff != null && buff.length > 0) {
  54.                 try {
  55.                     //正常的应该走到这里，通过获取的数据实例化NdefMessage.
  56.                     //在NdefMessage实例化的时候就按照NDEF的协议去解析这个byte数组
  57.                     //中的数据，然后封装成各个类和相应的字段供我们到时候直接调用
  58.                     ndefMsg = new NdefMessage(buff);
  59.                     addNdefTechnology(ndefMsg,
  60.                             getConnectedHandle(),
  61.                             getConnectedLibNfcType(),
  62.                             getConnectedTechnology(),
  63.                             supportedNdefLength, cardState);
  64.                     foundFormattable = false;
  65.                     reconnect();
  66.                 } catch (FormatException e) {
  67.                    // Create an intent anyway, without NDEF messages
  68.                    generateEmptyNdef = true;
  69.                 }
  70.             } else if(buff != null){
  71.                 // Empty buffer, unformatted tags fall into this case
  72.                 generateEmptyNdef = true;
  73.             }
  74.             //当产生异常的时候generateEmptyNdef为true的一些处理
  75.             if (generateEmptyNdef) {
  76.                 ndefMsg = null;
  77.                 addNdefTechnology(null,
  78.                       getConnectedHandle(),
  79.                       getConnectedLibNfcType(),
  80.                       getConnectedTechnology(),
  81.                       supportedNdefLength, cardState);
  82.                 foundFormattable = false;
  83.                 reconnect();
  84.             }
  85.             break;
  86.         }
  87.         ......
  88.         return ndefMsg;
  89.     }
          然后就是分发Tag消息的最终实现了dispatchTagEndpoint
  1.         private void dispatchTagEndpoint(TagEndpoint tagEndpoint, ReaderModeParams readerParams){
  2.             //Tag用来封装一个已经被发现的Tag.Tag类是framework提供的api
  3.             Tag tag = new Tag(tagEndpoint.getUid(), tagEndpoint.getTechList(),
  4.                     tagEndpoint.getTechExtras(), tagEndpoint.getHandle(), mNfcTagService);
  5.             //把tagEndpoint以 key = tagEndpoint.gethandle;value = tagEndpoint放入到集合中
  6.             registerTagObject(tagEndpoint);
  7.             if (readerParams != null) {
  8.                 try {
  9.                     if ((readerParams.flags & NfcAdapter.FLAG_READER_NO_PLATFORM_SOUNDS) == 0) {
  10.                         playSound(SOUND_END);
  11.                     }
  12.                     if (readerParams.callback != null) {
  13.                         /调用回调.
  14.                         readerParams.callback.onTagDiscovered(tag);
  15.                         return;
  16.                     } else {
  17.                         // Follow normal dispatch below
  18.                     }
  19.                 } catch (RemoteException e) {
  20.                     ......
  21.                 } catch (Exception e) {
  22.                     ......
  23.                 }
  24.             }
  25.             //正真开始分发的地方.
  26.             //mNfcDispatcher是NfcDispatcher实例，初始化也是在NfcService启动的时候在构造当中
  27.             //mNfcDispatcher = new NfcDispatcher(mContext, mHandoverDataParser, mInProvisionMode);
  28.             //传入的mHandoverDataParser = new HandoverDataParser();同样是在构造当中
  29.             int dispatchResult = mNfcDispatcher.dispatchTag(tag);
  30.             if (dispatchResult == NfcDispatcher.DISPATCH_FAIL) {
  31.                 unregisterObject(tagEndpoint.getHandle());
  32.                 if (mScreenState == ScreenStateHelper.SCREEN_STATE_ON_UNLOCKED) {
  33.                     String toastString = mContext.getString(
  34.                             R.string.nfc_strings_toast_prompt_read_error_txt);
  35.                     //弹出Toast进行提示.
  36.                     if (!ToastMaster.isSameToastShown(toastString)) {
  37.                         ToastMaster.showToast(mContext, toastString);
  38.                         playSound(SOUND_ERROR);
  39.                     }
  40.                 }
  41.             } else if (dispatchResult == NfcDispatcher.DISPATCH_SUCCESS) {
  42.                 ...
  43.                 //播放声音
  44.                 playSound(SOUND_END);
  45.             }
  46.         }
         上面的函数可以看到最最重要的就是NfcDispatcher中的dispatchTag（Tag）了，先前一直是在NfcService中进入到
NfcDispatcher类，此类从名字也能看出主要功能，它就是分发NFC的events然后去开启指定的activity。
         阅读下面的流程代码之前，最好对Android NFC的TAG的分发机制有个整体了解，这样和代码对应上就更为轻松了。
  1.     public int dispatchTag(Tag tag) {
  2.         PendingIntent overrideIntent;
  3.         IntentFilter[] overrideFilters;
  4.         String[][] overrideTechLists;
  5.         String[] provisioningMimes;
  6.         boolean provisioningOnly;
  8.         synchronized (this) {
  9.             //overrideFilters的赋值是外部的app，运行在前台，想要处理Nfc的Tag使用的
  10.             //外部通过调用NfcService的setForegroundDispatch来实现。
  11.             overrideFilters = mOverrideFilters;
  12.             overrideIntent = mOverrideIntent;
  13.             overrideTechLists = mOverrideTechLists;
  14.             provisioningOnly = mProvisioningOnly;
  15.             provisioningMimes = mProvisioningMimes;
  16.         }
  18.         //在屏幕是SCREEN_STATE_ON_LOCKED的状态下尝试调用handleNfcUnlock去解锁屏幕。
  19.         boolean screenUnlocked = false;
  20.         if (!provisioningOnly &&
  21.                 mScreenStateHelper.checkScreenState() == ScreenStateHelper.SCREEN_STATE_ON_LOCKED) {
  22.             screenUnlocked = handleNfcUnlock(tag);
  23.             if (!screenUnlocked) {
  24.                 return DISPATCH_FAIL;
  25.             }
  26.         }
  28.         NdefMessage message = null;
  29.         //将Tag解析成Ndef的格式.
  30.         Ndef ndef = Ndef.get(tag);
  31.         if (ndef != null) {
  32.             //再通过这样获取到NdefMessage，(???)此处的疑问，前面不是已经获取到NdefMessage
  33.             //为什么还要再用NdefMessage生成个Tag，是然后在通过Tag获取，看起来好像是威力方便framewok
  34.             //统一接口，供外部调用.
  35.             message = ndef.getCachedNdefMessage();
  36.         } else {
  37.             NfcBarcode nfcBarcode = NfcBarcode.get(tag);
  38.             if (nfcBarcode != null && nfcBarcode.getType() == NfcBarcode.TYPE_KOVIO) {
  39.                 message = decodeNfcBarcodeUri(nfcBarcode);
  40.             }
  41.         }
  43.         if (DBG) Log.d(TAG, "dispatch tag: " + tag.toString() + " message: " + message);
  45.         //DispatchInfo一是在一个Tag分发的过程中的帮助类。
  46.         DispatchInfo dispatch = new DispatchInfo(mContext, tag, message);
  48.         //Tells the ActivityManager to resume allowing app switches.
  49.         resumeAppSwitches();
  50.         
  51.         如果正在运行的APP有定义了前台分发机制，则会走到这里
  52.         if (tryOverrides(dispatch, tag, message, overrideIntent, overrideFilters,
  53.                 overrideTechLists)) {
  54.             return screenUnlocked ? DISPATCH_UNLOCK : DISPATCH_SUCCESS;
  55.         }
  57.         //判断NDEF消息是否是handover格式
  58.         if (tryPeripheralHandover(message)) {
  59.             if (DBG) Log.i(TAG, "matched BT HANDOVER");
  60.             return screenUnlocked ? DISPATCH_UNLOCK : DISPATCH_SUCCESS;
  61.         }
  63.         //判断NDEF消息是否是WifiConfiguration格式 
  64.         if (NfcWifiProtectedSetup.tryNfcWifiSetup(ndef, mContext)) {
  65.             if (DBG) Log.i(TAG, "matched NFC WPS TOKEN");
  66.             return screenUnlocked ? DISPATCH_UNLOCK : DISPATCH_SUCCESS;
  67.         }
  69.        ......
  71.         //将TAg消息发送给对action为ACTION_NDEF_DISCOVERED感兴趣的APP处理 
  72.         if (tryNdef(dispatch, message)) {
  73.             return screenUnlocked ? DISPATCH_UNLOCK : DISPATCH_SUCCESS;
  74.         }
  76.         //将TAg消息发送给对ACTION_TECH_DISCOVERED感兴趣的APP处理  
  77.         if (tryTech(dispatch, tag)) {
  78.             return DISPATCH_SUCCESS;
  79.         }
  80.         //如上两个action相关的activity都未处理的时候
  81.         //将intent设置为ACTION_TAG_DISCOVERED 
  82.         dispatch.setTagIntent();
  83.         if (dispatch.tryStartActivity()) {
  84.             if (DBG) Log.i(TAG, "matched TAG");
  85.             return DISPATCH_SUCCESS;
  86.         }
  87.         //都无法处理就返回false.
  88.         if (DBG) Log.i(TAG, "no match");
  89.         return DISPATCH_FAIL;
  90.     }
         下面依次介绍这个方法中用到的几个具体的子函数：
          NfcService的setForegroundDispatch最终会调用到NfcDispatcher中的.
  1.     public synchronized void setForegroundDispatch(PendingIntent intent,
  2.             IntentFilter[] filters, String[][] techLists) {
  3.         if (DBG) Log.d(TAG, "Set Foreground Dispatch");
  4.         mOverrideIntent = intent;
  5.         mOverrideFilters = filters;
  6.         mOverrideTechLists = techLists;
  7.     }
         帮助类DispatchInfo中的几个方法
        构造：
  1.         public DispatchInfo(Context context, Tag tag, NdefMessage message) {
  2.             intent = new Intent();
  3.             //先把这个Tag对象放入intent，app获取到当前intent的时候可以取出来
  4.             intent.putExtra(NfcAdapter.EXTRA_TAG, tag);
  5.             intent.putExtra(NfcAdapter.EXTRA_ID, tag.getId());
  6.             if (message != null) {
  7.                 //有ndef消息的时候也把消息设置进去
  8.                 intent.putExtra(NfcAdapter.EXTRA_NDEF_MESSAGES, new NdefMessage[] {message});
  9.                 ndefUri = message.getRecords()[0].toUri();
  10.                 ndefMimeType = message.getRecords()[0].toMimeType();
  11.             } else {
  12.                 ndefUri = null;
  13.                 ndefMimeType = null;
  14.             }
  15.             //启动rootIntent的时候会启动下面三个设置的intent，就是putExtra处的参数.
  16.             rootIntent = new Intent(context, NfcRootActivity.class);
  17.             rootIntent.putExtra(NfcRootActivity.EXTRA_LAUNCH_INTENT, intent);
  18.             rootIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
  20.             this.context = context;
  21.             packageManager = context.getPackageManager();
  22.         }
          把当前的intent设置action为NfcAdapter.ACTION_TAG_DISCOVERED
  1.         public Intent setTagIntent() {
  2.             android.util.Log.d("zy","NfcDispatcher setTagIntent ");
  3.             intent.setData(null);
  4.             intent.setType(null);
  5.             intent.setAction(NfcAdapter.ACTION_TAG_DISCOVERED);
  6.             return intent;
  7.         }
         把当前的intent设置action为NfcAdapter.ACTION_NDEF_DISCOVERED
  1.         public Intent setNdefIntent() {
  2.             intent.setAction(NfcAdapter.ACTION_NDEF_DISCOVERED);
  3.             if (ndefUri != null) {
  4.                 intent.setData(ndefUri);
  5.                 return intent;
  6.             } else if (ndefMimeType != null) {
  7.                 intent.setType(ndefMimeType);
  8.                 return intent;
  9.             }
  10.             return null;
  11.         }
          把当前的intent设置action为NfcAdapter.ACTION_TECH_DISCOVERED
  1.         public Intent setTechIntent() {
  2.             android.util.Log.d("zy","NfcDispatcher setTechIntent ");
  3.             intent.setData(null);
  4.             intent.setType(null);
  5.             intent.setAction(NfcAdapter.ACTION_TECH_DISCOVERED);
  6.             return intent;
  7.         }
          第三方app使用前台分发系统时的调用
  1.     boolean tryOverrides(DispatchInfo dispatch, Tag tag, NdefMessage message, PendingIntent overrideIntent,
  2.             IntentFilter[] overrideFilters, String[][] overrideTechLists) {
  3.         ......
  4.         // 首先是当NdefMessage存在的时候，先去判断NDEF格式的消息
  5.         if (message != null) {
  6.             intent = dispatch.setNdefIntent();
  7.             //当当前的NdefMessage中是对应的NDEF消息时，使用传入的PendingIntent去启动对应的activity
  8.             if (intent != null &&
  9.                     isFilterMatch(intent, overrideFilters, overrideTechLists != null)) {
  10.                 try {
  11.                     overrideIntent.send(mContext, Activity.RESULT_OK, intent);
  12.                     if (DBG) Log.i(TAG, "matched NDEF override");
  13.                     return true;
  14.                 } catch (CanceledException e) {
  15.                     return false;
  16.                 }
  17.             }
  18.         }
  20.         // TECH
  21.         intent = dispatch.setTechIntent();
  22.         //当传入的Tag的Technolg也是支持的时候，把action设置成ACTION_NDEF_DISCOVERED去启动
  23.         if (isTechMatch(tag, overrideTechLists)) {
  24.             try {
  25.                 overrideIntent.send(mContext, Activity.RESULT_OK, intent);
  26.                 if (DBG) Log.i(TAG, "matched TECH override");
  27.                 return true;
  28.             } catch (CanceledException e) {
  29.                 return false;
  30.             }
  31.         }
  33.         // TAG 和上面同理。
  34.         intent = dispatch.setTagIntent();
  35.         if (isFilterMatch(intent, overrideFilters, overrideTechLists != null)) {
  36.             try {
  37.                 overrideIntent.send(mContext, Activity.RESULT_OK, intent);
  38.                 if (DBG) Log.i(TAG, "matched TAG override");
  39.                 return true;
  40.             } catch (CanceledException e) {
  41.                 return false;
  42.             }
  43.         }
  44.         return false;
  45.     }
          接下来是通过tryPeripheralHandover的，就是交由Bt进行发送的数据的处理
  1.     public boolean tryPeripheralHandover(NdefMessage m) {
  2.         //消息为空，或者说设备不支持蓝牙，那么就直接返回
  3.         if (m == null || !mDeviceSupportsBluetooth) return false;
  5.         if (DBG) Log.d(TAG, "tryHandover(): " + m.toString());
  7.         HandoverDataParser.BluetoothHandoverData handover = mHandoverDataParser.parseBluetooth(m);
  8.         ......
  9.         //得到使用的handover的各个参数以后，设置到intent内，并启动PeripheralHandoverService这个service.
  10.         Intent intent = new Intent(mContext, PeripheralHandoverService.class);
  11.         intent.putExtra(PeripheralHandoverService.EXTRA_PERIPHERAL_DEVICE, handover.device);
  12.         intent.putExtra(PeripheralHandoverService.EXTRA_PERIPHERAL_NAME, handover.name);
  13.         intent.putExtra(PeripheralHandoverService.EXTRA_PERIPHERAL_TRANSPORT, handover.transport);
  14.         if (handover.oobData != null) {
  15.             intent.putExtra(PeripheralHandoverService.EXTRA_PERIPHERAL_OOB_DATA, handover.oobData);
  16.         }
  17.         if (handover.uuids != null) {
  18.             intent.putExtra(PeripheralHandoverService.EXTRA_PERIPHERAL_UUIDS, handover.uuids);
  19.         }
  20.         if (handover.bluetoothClass != null) {
  21.             intent.putExtra(PeripheralHandoverService.EXTRA_PERIPHERAL_CLASS, handover.bluetoothClass);
  22.         }
  23.         intent.putExtra(PeripheralHandoverService.EXTRA_CLIENT, mMessenger);
  24.         intent.putExtra(PeripheralHandoverService.EXTRA_BT_ENABLED, mBluetoothEnabledByNfc.get());
  26.         if (CtaUtils.showCtaBtDialogIfNeeded(mContext, null, intent, null)) {
  27.             return true;
  28.         }
  30.         //最后启动这个Intent的service.
  31.         mContext.startServiceAsUser(intent, UserHandle.CURRENT);
  33.         return true;
  34.     }
  1.     public BluetoothHandoverData parseBluetooth(NdefMessage m){
  2.         //取得Ndef消息中的第一个NdefRecord记录，这个记录中肯定包含了完整的Header
  3.         NdefRecord r = m.getRecords()[0];
  4.         //获取Header中的tnf字段。
  5.         short tnf = r.getTnf();
  6.         //获取Header的Type字段。
  7.         byte[] type = r.getType();
  8.         //上面的获取不清楚的话去看看NDEF协议，较为简单.
  9.         // Check for BT OOB record 感觉现在都不用这个了，打印Log看看.
  10.         if (r.getTnf() == NdefRecord.TNF_MIME_MEDIA && Arrays.equals(r.getType(), TYPE_BT_OOB)) {
  11.             return parseBtOob(ByteBuffer.wrap(r.getPayload()));
  12.         }
  14.         // Check for BLE OOB record
  15.         if (r.getTnf() == NdefRecord.TNF_MIME_MEDIA && Arrays.equals(r.getType(), TYPE_BLE_OOB)) {
  16.             return parseBleOob(ByteBuffer.wrap(r.getPayload()));
  17.         }
  19.         // Check for Handover Select, followed by a BT OOB record
  20.         if (tnf == NdefRecord.TNF_WELL_KNOWN &&
  21.                 Arrays.equals(type, NdefRecord.RTD_HANDOVER_SELECT)) {
  22.             return parseBluetoothHandoverSelect(m);
  23.         }
  24.         ......
  26.         return null;
  27.     }
         如上可以看到最终都是调用到parseBtOob然后根据getPayload的数据的（？？？看了源码不太懂）
         接下来我们去看看PeripheralHandoverService这个service的启动流程
         生命周期的回调：
  1.     @Override
  2.     public int onStartCommand(Intent intent, int flags, int startId) {
  3.         ......
  4.         //最主要的就是调用如下方法去打开蓝牙.
  5.         if (doPeripheralHandover(intent.getExtras())) {
  6.             return START_STICKY;
  7.         } else {
  8.             stopSelf(startId);
  9.             return START_NOT_STICKY;
  10.         }
  11.     }
  13.     @Override
  14.     public void onCreate() {
  15.         super.onCreate();
  17.         mSoundPool = new SoundPool(1, AudioManager.STREAM_NOTIFICATION, 0);
  18.         mSuccessSound = mSoundPool.load(this, R.raw.end, 1);
  19.         mNfcAdapter = NfcAdapter.getDefaultAdapter(getApplicationContext());
  21.         IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
  22.         registerReceiver(mBluetoothStatusReceiver, filter);
  23.     }
  1.     boolean doPeripheralHandover(Bundle msgData) {
  2.         ......
  3.         mDevice = msgData.getParcelable(EXTRA_PERIPHERAL_DEVICE);
  4.         String name = msgData.getString(EXTRA_PERIPHERAL_NAME);
  5.         int transport = msgData.getInt(EXTRA_PERIPHERAL_TRANSPORT);
  6.         OobData oobData = msgData.getParcelable(EXTRA_PERIPHERAL_OOB_DATA);
  7.         Parcelable[] parcelables = msgData.getParcelableArray(EXTRA_PERIPHERAL_UUIDS);
  8.         BluetoothClass bluetoothClass = msgData.getParcelable(EXTRA_PERIPHERAL_CLASS);
  10.         ParcelUuid[] uuids = null;
  11.         if (parcelables != null) {
  12.             uuids = new ParcelUuid[parcelables.length];
  13.             for (int i = 0; i < parcelables.length; i++) {
  14.                 uuids[i] = (ParcelUuid)parcelables[i];
  15.             }
  16.         }
  18.         mClient = msgData.getParcelable(EXTRA_CLIENT);
  19.         mBluetoothEnabledByNfc = msgData.getBoolean(EXTRA_BT_ENABLED);
  21.         mBluetoothPeripheralHandover = new BluetoothPeripheralHandover(
  22.                 this, mDevice, name, transport, oobData, uuids, bluetoothClass, this);
  24.         if (transport == BluetoothDevice.TRANSPORT_LE) {
  25.             mHandler.sendMessageDelayed(
  26.                     mHandler.obtainMessage(MSG_PAUSE_POLLING), PAUSE_DELAY_MILLIS);
  27.         }
  28.         if (mBluetoothAdapter.isEnabled()) {
  29.             if (!mBluetoothPeripheralHandover.start()) {
  30.                 mHandler.removeMessages(MSG_PAUSE_POLLING);
  31.                 mNfcAdapter.resumePolling();
  32.             }
  33.         } else {
  34.             //调用enableBluetooth去打开蓝牙
  35.             if (!enableBluetooth()) {
  36.                 Log.e(TAG, "Error enabling Bluetooth.");
  37.                 mBluetoothPeripheralHandover = null;
  38.                 return false;
  39.             }
  40.         }
  42.         return true;
  43.     }
  44.     
  45.     boolean enableBluetooth() {
  46.         if (!mBluetoothAdapter.isEnabled()) {
  47.             mBluetoothEnabledByNfc = true;
  48.             //再往下就是Bluetooth中的启动链接流程了！
  49.             return mBluetoothAdapter.enableNoAutoConnect();
  50.         }
  51.         return true;
  52.     }
          然后就是优先级最高的处理方式，注册了action为NfcAdapter.ACTION_NDEF_DISCOVERED的
  1.     boolean tryNdef(DispatchInfo dispatch, NdefMessage message) {
  2.         ......
  3.         //获取对应的intent
  4.         Intent intent = dispatch.setNdefIntent();
  6.         if (intent == null) return false;
  8.         //如果发送的NdefMessage包含打开这个消息的包的信息（AAR）
  9.         //那么就用指定的包处理这个Tag消息
  10.         List<String> aarPackages = extractAarPackages(message);
  11.         for (String pkg : aarPackages) {
  12.             dispatch.intent.setPackage(pkg);
  13.             if (dispatch.tryStartActivity()) {
  14.                 if (DBG) Log.i(TAG, "matched AAR to NDEF");
  15.                 return true;
  16.             }
  17.         }
  19.         // Try to perform regular launch of the first AAR
  20.         if (aarPackages.size() > 0) {
  21.             ......
  22.         }
  23.         ......
  25.         //当消息中没有包名的时候，就用前面设置的intent：setNdefIntent
  26.         //来启动activity，所以此时所有注册的activity都会受到这个action，然后你可以选择用那个启动
  27.         dispatch.intent.setPackage(null);
  28.         if (dispatch.tryStartActivity()) {
  29.             if (DBG) Log.i(TAG, "matched NDEF");
  30.             return true;
  31.         }
  33.         return false;
  34.     }
          而tryTech（）的思想是一样的，也是经过一系列判断后，通过dispatch.tryStartActivity()来启动，不过它启动的是action为
NfcAdapter.ACTION_TECH_DISCOVERED的，不再赘述。
          最终当都不能处理的时候就调用dispatch.setTagIntent()把intent设置为NfcAdapter.ACTION_TAG_DISCOVERED
用它去启动符合要求的activity.
          至此完成整体Tag的读取分发系统，回到NfcService中的mHandler中MSG_MOCK_NDEF，继续向下执行发送相关的成功
或失败的音效

2、写入Tag的流程
      写开发时app调用framework层的对应的不同协议的Tag代表的类的接口有如下：
             位于：android/frameworks/base/core/java/android/nfc/tech
             有：  NfcA.java、NfcB.java、NfcF.java；
                       Ndef.java、IsoDep.java ...  等等。这些类都代表了指定的不同协议的Tag的实现.
             此处我们以android中的Ndef为例，你想要写入数据的时候，调用Ndef类的如下接口
  1.     public void writeNdefMessage(NdefMessage msg) throws IOException, FormatException {
  2.         checkConnected();
  3.         try {
  4.             //tagServices 在 packages/app/Nfc中实现的
  5.             INfcTag tagService = mTag.getTagService();
  6.             ......
  7.             int serviceHandle = mTag.getServiceHandle();
  8.             if (tagService.isNdef(serviceHandle)) {
  9.                 //调用tagService的ndefWrite实现真正的写入
  10.                 int errorCode = tagService.ndefWrite(serviceHandle, msg);
  11.                 switch (errorCode) {
  12.                     case ErrorCodes.SUCCESS:
  13.                         break;
  14.                     case ErrorCodes.ERROR_IO:
  15.                         throw new IOException();
  16.                     case ErrorCodes.ERROR_INVALID_PARAM:
  17.                         throw new FormatException();
  18.                     default:
  19.                         // Should not happen
  20.                         throw new IOException();
  21.                 }
  22.             }
  23.             ......
  24.         } catch (RemoteException e) {
  25.             Log.e(TAG, "NFC service dead", e);
  26.         }
  27.     }
         那么我们就需要去packages/app/Nfc当中找INfcTag的具体实现了，是位于NfcService当中的内部类
  1.     final class TagService extends INfcTag.Stub调用内部方法ndefWrite
  2.         @Override
  3.         public int ndefWrite(int nativeHandle, NdefMessage msg) throws RemoteException {
  4.             NfcPermissions.enforceUserPermissions(mContext);
  5.             
  6.             TagEndpoint tag;
  7.             ......
  8.             //下面是真正的写入的地方    
  9.             if (tag.writeNdef(msg.toByteArray())) {
  10.                 return ErrorCodes.SUCCESS;
  11.             } else {
  12.                 return ErrorCodes.ERROR_IO;
  13.             }
  14.         }
          前面我们已经说过TagEndpoint是有NativeNfcTag实现的，对应的方法如下
  1.     private native boolean doWrite(byte[] buf);
  2.     @Override
  3.     public synchronized boolean writeNdef(byte[] buf) {
  4.         if (mWatchdog != null) {
  5.             mWatchdog.pause();
  6.         }
  7.         //可以看到去native层进行进一步的读写！
  8.         boolean result = doWrite(buf);//go to the native
  9.         if (mWatchdog != null) {
  10.             mWatchdog.doResume();
  11.         }
  12.         return result;
  13.     }
          至此java层的写入流程就分析完毕了。
         下面是调试的时候一次写入的Log记录一下，会先调用链接，再调用transceive，最后再写入。
  1. 04-21 00:37:02.032 D/zy      ( 2652): Nfcervice  connect 
  2. 04-21 00:37:02.042 D/zy      ( 2652): NativeNfc transceive 
  3. 04-21 00:37:02.070 D/zy      ( 2652): Nfcervice  connect 
  4. 04-21 00:37:02.094 D/zy      ( 2652): Nfcervice  ndefWrite 
  5. 04-21 00:37:02.094 D/zy      ( 2652): NativeNfc writeNdef

文章参考：
        http://blog.csdn.net/xuwen0306/article/details/44724845
 

0 0
淘宝卖家交流论坛 淘宝卖家交流论坛
原创粉丝点击
热门IT博客
qq农场鱼塘升级数据qq农场鱼塘升级数据
阿里云费用如何提现阿里云费用如何提现
域名劫持 软件
最好的矢量图软件
淘宝十大女童模
知美术馆成都
除甲醛最有效方法知乎
盛世启航网络
怎样开情趣用品淘宝店
重复文件查找软件
几何光学实验数据
淘宝买苹果数据线
淘宝大学在哪里?
microsoft fix it 64
照片大小软件
银河号事件真相 知乎
python与r语言哪个好
信达通炒股软件
微信二次开发源码
真人娱乐系统源码
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 血瘀症 气滞血瘀饮食 气滞血瘀型体质 女性气滞血瘀怎么调理 血瘀所致的月经不调 气滞血瘀吃什么调理 什么是血瘀症 月经气滞血瘀的症状 宫寒气滞血瘀的症状 肝郁血瘀吃什么中成药 血瘀型月经不调吃什么药 血有病 容血病 血的颤动 天堂血盟 血盟荣耀 血盟2 英雄血盟 血盟荣耀手机版 天堂2血盟技能 300英雄血盟桐人 轩辕传奇血盟名字大全 轩辕传奇血盟名字 古风血眸银发女子戴狐狸面具 血瞳魅世 血瞳妖巫 血瞳 血瞳杀神 血瞳妖妃 血瞳魅世银发魔妃 古风银发血瞳美男 妖临天下血瞳魅世 fgo血之泪石 乌鸦血石 肾结石血尿是在排石吗 肾结石尿血是在排石吗 血之泪石 血之泪石在哪里刷 fgo血之泪石在哪刷 肾结石尿血是加重还是排石 血石图片

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里