NFC源码分析之Handover

最新推荐文章于 2023-05-11 15:38:59 发布
最新推荐文章于 2023-05-11 15:38:59 发布
阅读量2.7k 收藏 9
点赞数 2
分类专栏： NFC知识 文章标签： NFC Handover
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zy00000000001/article/details/73730458
版权

         此处的代码为Android O的代码，本也有有一些patch的添加和修改，不过这些都不影响整个流程的理解。Handover相关的

大致可分为两种情况：直接读取带NFC的特殊设备如：带Nfc的蓝牙耳机、键盘、照相机等；还一种是传输文件的过程中由于文

件较大使用Handover也就是BT(目前仅支持BT)来传输此时也称之为Android Beam。

1、当检测到支持Nfc的蓝牙键盘、鼠标等的时候：(我们以链接蓝牙键盘为例子来分析).
          从NfcDispatcher类中的dispatchTag()方法开始分析，至于如何到这一步的可以看别的文章。 
  
  
  1.        public int dispatchTag(Tag tag) {
  2.         ......
  3.         if (tryPeripheralHandover(message)) {
  4.             if (DBG) Log.i(TAG, "matched BT HANDOVER");
  5.             NfcIddEvent.NfcTag.dispatchedToPrioritizedMethod(tag,
  6.                     NfcIddEvent.NfcTag.VALUE_APP_HANDOVER);
  7.             return screenUnlocked ? DISPATCH_UNLOCK : DISPATCH_SUCCESS;
  8.         }
  9.         ......
  10.      }
  
  
  1.     public boolean tryPeripheralHandover(NdefMessage m){
  2.         //下面这个方法mHandoverDataParser.parseBluetooth(m)方法是通过检测到的Tag中携带的Ndef格式的信息，
  3.         //信息包含了当前Nfc设备（蓝牙鼠标、键盘、耳机等）的各种设备信息，再往下的具体解析和协议息息相关，暂无深入分析。
  4.         HandoverDataParser.BluetoothHandoverData handover = mHandoverDataParser.parseBluetooth(m);
  5.         //如果解析出来的信息出问题，就需要去分析一下解析相关的协议了。
  6.         ......
  7.         //下面就是解析完Tag中的NDEF携带的信息后，放到响应的变量中以便后续使用。
  8.         Intent intent = new Intent(mContext, PeripheralHandoverService.class);
  9.         intent.putExtra(PeripheralHandoverService.EXTRA_PERIPHERAL_DEVICE, handover.device);
  10.         intent.putExtra(PeripheralHandoverService.EXTRA_PERIPHERAL_NAME, handover.name);
  11.         intent.putExtra(PeripheralHandoverService.EXTRA_PERIPHERAL_TRANSPORT, handover.transport);
  12.         if (handover.oobData != null) {
  13.             intent.putExtra(PeripheralHandoverService.EXTRA_PERIPHERAL_OOB_DATA, handover.oobData);
  14.         }
  15.         if (handover.uuids != null) {
  16.             intent.putExtra(PeripheralHandoverService.EXTRA_PERIPHERAL_UUIDS, handover.uuids);
  17.         }
  18.         if (handover.btClass != null) {
  19.             intent.putExtra(PeripheralHandoverService.EXTRA_PERIPHERAL_CLASS, handover.btClass);
  20.         }
  21.         intent.putExtra(PeripheralHandoverService.EXTRA_CLIENT, mMessenger);
  22.         intent.putExtra(PeripheralHandoverService.EXTRA_BT_ENABLED, mBluetoothEnabledByNfc.get());
  23.         ...
  24.         //启动PeripheralHandoverService去进一步的处理。
  25.         mContext.startServiceAsUser(intent, UserHandle.CURRENT);
  27.         return true;
  28.     }
          接下来就是看PeripheralHandoverService中的构造和onCreate以及onStartCommand 
  
  
  1. public class PeripheralHandoverService extends Service implements BluetoothPeripheralHandover.Callback {
  2.     ...
  3.     public PeripheralHandoverService() {
  4.         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
  5.         mHandler = new MessageHandler();
  6.         mMessenger = new Messenger(mHandler);
  7.         mBluetoothHeadsetConnected = false;
  8.         mBluetoothEnabledByNfc = false;
  9.         mStartId = 0;
  10.     }    
  11.     ...
  12.         @Override
  13.     public void onCreate() {
  14.         super.onCreate();
  15.         mNfcAdapter = NfcAdapter.getDefaultAdapter(getApplicationContext());
  17.         IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
  18.         registerReceiver(mBluetoothStatusReceiver, filter);
  19.     }
  20.         @Override
  21.     public int onStartCommand(Intent intent, int flags, int startId) {
  22.         ......
  23.         if (doPeripheralHandover(intent.getExtras())) {
  24.             return START_STICKY;
  25.         } else {
  26.             stopSelf(startId);
  27.             return START_NOT_STICKY;
  28.         }
  29.     }
  30. }
         主要的我们需要关注的就是：
                a、注册的BluetoothAdapter.ACTION_STATE_CHANGED广播。
                b、调用doPeripheralHandover去进一步的操作。
           mBluetoothStatusReceiver如下：这个reveiver的作用在蓝牙打开的时候并且是由Nfc打开的时候就进一步的调用handover
相关的流程进行处理。 
   
   
  1.     final BroadcastReceiver mBluetoothStatusReceiver = new BroadcastReceiver() {
  2.         @Override
  3.         public void onReceive(Context context, Intent intent) {
  4.             String action = intent.getAction();
  5.             if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
  6.                 handleBluetoothStateChanged(intent);
  7.             }
  8.         }
  9.    };
  10.    private void handleBluetoothStateChanged(Intent intent) {
  11.         int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE,
  12.                 BluetoothAdapter.ERROR);
  13.         if (state == BluetoothAdapter.STATE_ON) {
  14.             // If there is a pending device pairing, start it
  15.             //下面最主要的其实就是调用mBluetoothPeripheralHandover.start()方法进行进一步的操作，
  16.             //而此时一般蓝牙刚被Nfc设备打开，根据是否配对来提示用户进行配对或者直接连接。
  17.             if (mBluetoothPeripheralHandover != null &&
  18.                     !mBluetoothPeripheralHandover.hasStarted()) {
  19.                 if (!mBluetoothPeripheralHandover.start()) {
  20.                     mNfcAdapter.resumePolling();
  21.                 }
  22.             }
  23.         } else if (state == BluetoothAdapter.STATE_OFF) {
  24.             if (mBluetoothAdapter.getState() != BluetoothAdapter.STATE_TURNING_ON) {
  25.                 mBluetoothEnabledByNfc = false;
  26.              }
  27.             mBluetoothHeadsetConnected = false;
  28.         }
  29.     }
             doPeripheralHandover的详解 
   
   
  1.     boolean doPeripheralHandover(Bundle msgData) {
  2.         //只能有一个BluetoothPeripheralHandover对象，处理这个的Nfc Tag信息读取，
  3.         //此时想要再检测就得把Nfc设备的开关进行打开和关闭操作。
  4.         if (mBluetoothPeripheralHandover != null) {
  5.             Log.d(TAG, "Ignoring pairing request, existing handover in progress.");
  6.             return true;
  7.         }
  8.         ......//这块就是把msgData中携带的数据取出来。(NDEF信息中的数据)
  9.         mBluetoothEnabledByNfc = msgData.getBoolean(EXTRA_BT_ENABLED);
  11.         //BluetoothPeripheralHandover是真正的处理的地方，此处进行唯一的实例化.
  12.         //传入的参数大都是从NDEF信息中解析出来的.
  13.         mBluetoothPeripheralHandover = new BluetoothPeripheralHandover(
  14.                 this, mDevice, name, transport, oobData, uuids, btClass, this);
  15.         ......
  16.         if (mBluetoothAdapter.isEnabled()) {
  17.             //如果蓝牙已经打开，直接调用start()去进行配对等的处理。
  18.             if (!mBluetoothPeripheralHandover.start()) {
  19.                 mHandler.removeMessages(MSG_PAUSE_POLLING);
  20.                 mNfcAdapter.resumePolling();
  21.             }
  22.         } else {
  23.             //如果蓝牙没有打开那么就调用enableBluetooth去打开蓝牙设备.
  24.             //此处你打开蓝牙成功后也会往外发送广播最终到前面的receiver中最后也是调用start进行了处理。
  25.             if (!enableBluetooth()) {
  26.                 Log.e(TAG, "Error enabling Bluetooth.");
  27.                 mBluetoothPeripheralHandover = null;
  28.                 return false;
  29.             }
  30.         }
  32.         return true;
  33.     }
  34.      //此处调用的是framework专门为system级别的app设定的方法enableNoAutoConnect，这个方法
  35.      //打开蓝牙后不会记录此次操作。
  36.      boolean enableBluetooth() {
  37.         if (!mBluetoothAdapter.isEnabled()) {
  38.             mBluetoothEnabledByNfc = true;
  39.             return mBluetoothAdapter.enableNoAutoConnect();
  40.         }
  41.         return true;
  42.     }
         上面的两种情况最终都走到了BluetoothPeripheralHandover的start方法。 
   
   
  1.     public boolean start() {
  2.         checkMainThread();
  3.         ...
  5.         IntentFilter filter = new IntentFilter();
  6.         filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
  7.         filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
  8.         filter.addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED);
  9.         filter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
  10.         filter.addAction(BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED);
  11.         filter.addAction(ACTION_ALLOW_CONNECT);
  12.         filter.addAction(ACTION_DENY_CONNECT);
  14.         mContext.registerReceiver(mReceiver, filter);
  15.         //很多地方都会发送这个timeout信息，因为无法确定蓝牙那块是走到了预期，或者出现什么别的情况。
  16.         mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_TIMEOUT), TIMEOUT_MS);
  17.         //现在的行为是初始化阶段ACTION_INIT
  18.         mAction = ACTION_INIT;
  19.         mRetryCount = 0;
  20.         //调用nextStep去做进一步的处理
  21.         nextStep();
  22.         return true;
  23.     }
         这个nextStep很关进，它根据当前所处的不同的action来选择具体的我们下一步要执行的动作。 
   
   
  1.     void nextStep() {
  2.         if (mAction == ACTION_INIT) {
  3.             nextStepInit();
  4.         } else if (mAction == ACTION_CONNECT) {
  5.             nextStepConnect();
  6.         } else {
  7.             nextStepDisconnect();
  8.         }
  9.     }
          此时我们处于ACTION_INIT的action所以走到nextStepInit(); 
   
   
  1.      void nextStepInit() {
  2.         switch (mState) {
  3.             case STATE_INIT:
  4.                 //如下只要有一个为null，就去getProfileProxys且改变状态STATE_WAITING_FOR_PROXIES.
  5.                 if (mA2dp == null || mHeadset == null || mInput == null) {
  6.                     mState = STATE_WAITING_FOR_PROXIES;
  7.                     if (!getProfileProxys()) {
  8.                         complete(false);
  9.                     }
  10.                     break;
  11.                 }
  12.             //走到此处的时候证明已经获得了需要连接的蓝牙的对应协议的profile对应的service的实现。
  13.             case STATE_WAITING_FOR_PROXIES:
  14.                 //注意state的改变此时变成了STATE_INIT_COMPLETE
  15.                 mState = STATE_INIT_COMPLETE;
  16.                 // Check connected devices and see if we need to disconnect
  17.                 synchronized(mLock) {
  18.                     if (mTransport == BluetoothDevice.TRANSPORT_LE || mIsHidCapability) {
  19.                         //根据当前时候连接来决定下一个的状态.
  20.                         if (mInput.getConnectedDevices().contains(mDevice)) {
  21.                             Log.i(TAG, "ACTION_DISCONNECT addr=" + mDevice + " name=" + mName);
  22.                             mAction = ACTION_DISCONNECT;
  23.                         } else {
  24.                             Log.i(TAG, "ACTION_CONNECT addr=" + mDevice + " name=" + mName);
  25.                             mAction = ACTION_CONNECT;
  26.                         }
  27.                     } else {
  28.                         //处理A2DP和HeadSet.
  29.                         if (mA2dp.getConnectedDevices().contains(mDevice) ||
  30.                                 mHeadset.getConnectedDevices().contains(mDevice)) {
  31.                             Log.i(TAG, "ACTION_DISCONNECT addr=" + mDevice + " name=" + mName);
  32.                             mAction = ACTION_DISCONNECT;
  33.                         } else {
  34.                             // Check if each profile of the device is disabled or not
  35.                             if (mHeadset.getPriority(mDevice) == BluetoothProfile.PRIORITY_OFF) {
  36.                                 mIsHeadsetAvailable = false;
  37.                             }
  38.                             if (mA2dp.getPriority(mDevice) == BluetoothProfile.PRIORITY_OFF) {
  39.                                 mIsA2dpAvailable = false;
  40.                             }
  41.                             if (!mIsHeadsetAvailable && !mIsA2dpAvailable) {
  42.                                 Log.i(TAG, "Both Headset and A2DP profiles are unavailable");
  43.                                 complete(false);
  44.                                 break;
  45.                             }
  46.                             Log.i(TAG, "ACTION_CONNECT addr=" + mDevice + " name=" + mName);
  47.                             mAction = ACTION_CONNECT;
  48.                             mNeedStartTheMusic = mAudioManager.isBluetoothA2dpOn()
  49.                                     & mAudioManager.isMusicActive();
  50.                         }
  51.                     }
  52.                 }
  53.                 //接着进行下一步。
  54.                 nextStep();
  55.         }
  56.     }
         至此我们应该先分析一下getProfileProxys(),如下，很简单的实现，就是调用了蓝牙提供的接口去获得对应的proflie的但是并
又返回对象啊？注意BluetoothPeripheralHandover implements BluetoothProfile.ServiceListener.所以在你连接到对应的profile会回
调相关的接口onServiceConnected. 
   
   
  1.     boolean getProfileProxys() {
  2.         if (mTransport == BluetoothDevice.TRANSPORT_LE || mIsHidCapability) {
  3.             if (!mBluetoothAdapter.getProfileProxy(mContext, this, BluetoothProfile.INPUT_DEVICE))
  4.                 return false;
  5.         } else {
  6.             if(!mBluetoothAdapter.getProfileProxy(mContext, this, BluetoothProfile.HEADSET))
  7.                 return false;
  9.             if(!mBluetoothAdapter.getProfileProxy(mContext, this, BluetoothProfile.A2DP))
  10.                 return false;
  11.         }
  12.         return true;
  13.     }
          当成功链接的时候，会走如下的回调，然后实现具体的profile对象的实例化. 
   
   
  1.     @Override
  2.     public void onServiceConnected(int profile, BluetoothProfile proxy) {
  3.         synchronized (mLock) {
  4.             switch (profile) {
  5.                 case BluetoothProfile.HEADSET:
  6.                     mHeadset = (BluetoothHeadset) proxy;
  7.                     if (mA2dp != null) {
  8.                         mHandler.sendEmptyMessage(MSG_NEXT_STEP);
  9.                     }
  10.                     break;
  11.                 case BluetoothProfile.A2DP:
  12.                     mA2dp = (BluetoothA2dp) proxy;
  13.                     if (mHeadset != null) {
  14.                         mHandler.sendEmptyMessage(MSG_NEXT_STEP);
  15.                     }
  16.                     break;
  17.                 case BluetoothProfile.INPUT_DEVICE:
  18.                     mInput = (BluetoothInputDevice) proxy;
  19.                     if (mInput != null) {
  20.                         mHandler.sendEmptyMessage(MSG_NEXT_STEP);
  21.                     }
  22.                     break;
  23.             }
  24.         }
  25.     }
         并且在实例化完毕后会，往外发送MSG_NEXT_STEP信息。这个信息被如下Handler处理。 
   
   
  1.     final Handler mHandler = new Handler() {
  2.         @Override
  3.         public void handleMessage(Message msg) {
  4.             switch (msg.what) {
  5.                 case MSG_TIMEOUT:
  6.                     ......
  7.                     break;
  8.                 case MSG_NEXT_STEP:
  9.                     //可以看到重新调用了nextStep.
  10.                     nextStep();
  11.                     break;
  12.                 case MSG_RETRY:
  13.                     ......
  14.                     break;
  15.             }
  16.         }
  17.     };
          但注意此时mAction == ACTION_INIT，但mState = STATE_WAITING_FOR_PROXIES.所以会调用到nextStepInit中的
STATE_WAITING_FOR_PROXIES这个选项当中。去看前面的对应的case中的代码。可以看到就是修改了mAction = XXX;然后
就是又去进行下一个操作了。
          此时又来到了nextStep(),但是mAction == ACTION_CONNECT或者mAction == ACTION_DISCONNECT我们先分析ACTI
ON_CONNECT对应的就是方法nextStepConnect。 
   
   
  1.     void nextStepConnect() {
  2.         switch (mState) {
  3.             //此时的state是STATE_INIT_COMPLETE走到如下
  4.             case STATE_INIT_COMPLETE:
  5.                 //如果未配对就会去调用requestPairConfirmation.
  6.                 if (mDevice.getBondState() != BluetoothDevice.BOND_BONDED) {
  7.                     requestPairConfirmation();
  8.                     mState = STATE_WAITING_FOR_BOND_CONFIRMATION;
  9.                     break;
  10.                 }
  11.                 ......
  12.             //到这一步的时候是用户根据弹框选择了确认配对
  13.             case STATE_WAITING_FOR_BOND_CONFIRMATION:
  14.                 if (mDevice.getBondState() != BluetoothDevice.BOND_BONDED) {
  15.                     startBonding();
  16.                     break;
  17.                 }
  18.             //到这一步的时候已经配对完毕了，要对不同的profile进行不同的connecte.
  19.             //且会按照顺序通过判断依次进行链接.
  20.             case STATE_BONDING:
  21.                 //状态改为正在连接.
  22.                 mState = STATE_CONNECTING;
  23.                 synchronized (mLock) {
  24.                     //如果是input设备如蓝牙键盘。
  25.                     if (mIsHidCapability) {
  26.                         if (mInput.getConnectionState(mDevice)
  27.                                 != BluetoothProfile.STATE_CONNECTED) {
  28.                             mHidResult = RESULT_PENDING;
  29.                             //直接调用对应的proflie对象进行Connect
  30.                             mInput.connect(mDevice);
  31.                             toast(mContext.getString(R.string.nfc_strings_toast_connecting_txt),
  32.                                     Toast.LENGTH_LONG);
  33.                             break;
  34.                         } else {
  35.                             mHidResult = RESULT_CONNECTED;
  36.                         }
  37.                     } else if (mTransport != BluetoothDevice.TRANSPORT_LE) {
  38.                         //只要不是input设备，就常尝试用mHeadset、mA2dp两个profile进行了链接
  39.                         //注意此处还会retry几次。
  40.                         if (mHeadset.getConnectionState(mDevice) !=
  41.                                 BluetoothProfile.STATE_CONNECTED) {
  42.                             if (mIsHeadsetAvailable) {
  43.                                 mHfpResult = RESULT_PENDING;
  44.                                 mHeadset.connect(mDevice);
  45.                             } else {
  46.                                 mHfpResult = RESULT_DISCONNECTED;
  47.                             }
  48.                         } else {
  49.                             mHfpResult = RESULT_CONNECTED;
  50.                         }
  51.                         if (mA2dp.getConnectionState(mDevice) != BluetoothProfile.STATE_CONNECTED) {
  52.                             if (mIsA2dpAvailable) {
  53.                                 mA2dpResult = RESULT_PENDING;
  54.                                 mA2dp.connect(mDevice);
  55.                             } else {
  56.                                 mA2dpResult = RESULT_DISCONNECTED;
  57.                             }
  58.                         } else {
  59.                             mA2dpResult = RESULT_CONNECTED;
  60.                         }
  61.                         if (mA2dpResult == RESULT_PENDING || mHfpResult == RESULT_PENDING) {
  62.                             if (mRetryCount == 0) {
  63.                                 toast(mContext.getString(R.string.nfc_strings_toast_connecting_txt),
  64.                                         Toast.LENGTH_LONG);
  65.                             }
  66.                             if (mRetryCount < MAX_RETRY_COUNT) {
  67.                                 sendRetryMessage(RETRY_CONNECT_WAIT_TIME_MS);
  68.                                 break;
  69.                             }
  70.                         }
  71.                     }
  72.                 }
  73.             //当连接完毕的时候，无论成功与否。
  74.             case STATE_CONNECTING:
  75.                 if (mIsHidCapability) {
  76.                     //输入设备根据连接的结果来做相应的赋值和提示操作
  77.                     if (mHidResult == RESULT_PENDING) {
  78.                         break;
  79.                     } else if (mHidResult == RESULT_CONNECTED) {
  80.                         toast(mContext.getString(R.string.nfc_strings_toast_connected_txt, mName));
  81.                         mDevice.setAlias(mName);
  82.                         complete(true);
  83.                     } else {
  84.                         toast(mContext.getString(
  85.                                 R.string.nfc_strings_toast_sht_connection_failed_txt));
  86.                         complete(false);
  87.                     }
  88.                 } else if (mTransport != BluetoothDevice.TRANSPORT_LE) {
  89.                     //处理A2DP和HeadSet的，基本同Hid
  90.                     ......
  91.                     if (mA2dpResult == RESULT_CONNECTED || mHfpResult == RESULT_CONNECTED) {
  92.                         ......
  93.                     } else {
  94.                         ......
  95.                     }
  96.                 }
  97.                 break;
  98.         }
  99.     }
         接下来我们具体看看nextStepConnect这个方法内部的几个重要实现。
         首先是requestPairConfirmation，如下可以看到就是启动了一个Activity提示用户是否要进行配对， 
   
   
  1.     void requestPairConfirmation() {
  2.         Intent dialogIntent = new Intent(mContext, ConfirmConnectActivity.class);
  3.         dialogIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
  4.         dialogIntent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice);
  5.         dialogIntent.putExtra(BluetoothDevice.EXTRA_NAME, mName);
  6.         mContext.startActivity(dialogIntent);
  7.     }
          我们进入到Activity中观察： 
   
   
  1. public class ConfirmConnectActivity extends Activity {
  2.     BluetoothDevice mDevice;
  3.     AlertDialog mAlert = null;
  4.     @Override
  5.     protected void onCreate(Bundle savedInstanceState) {
  6.         super.onCreate(savedInstanceState);
  7.         AlertDialog.Builder builder = new AlertDialog.Builder(this,
  8.                 AlertDialog.THEME_DEVICE_DEFAULT_LIGHT);
  9.         ...
  10.         builder.setMessage(confirmString)
  11.                .setCancelable(false)
  12.                .setPositiveButton(res.getString(R.string.pair_yes),
  13.                        new DialogInterface.OnClickListener() {
  14.                    public void onClick(DialogInterface dialog, int id) {
  15.                         //当用户确认配对的时候往外发送BluetoothPeripheralHandover.ACTION_ALLOW_CONNECT的广播
  16.                         Intent allowIntent = new Intent(BluetoothPeripheralHandover.ACTION_ALLOW_CONNECT);
  17.                         allowIntent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice);
  18.                         sendBroadcast(allowIntent);
  19.                         ...
  20.                    }
  21.                })
  22.                .setNegativeButton(res.getString(R.string.pair_no),
  23.                        new DialogInterface.OnClickListener() {
  24.                    public void onClick(DialogInterface dialog, int id) {
  25.                         //当用户取消配对的时候往外发送BluetoothPeripheralHandover.ACTION_ALLOW_CONNECT的广播
  26.                        Intent denyIntent = new Intent(BluetoothPeripheralHandover.ACTION_DENY_CONNECT);
  27.                        denyIntent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice);
  28.                        sendBroadcast(denyIntent);
  29.                        ...
  30.                    }
  31.                });
  32.         mAlert = builder.create();
  33.         mAlert.show();
  34.         ...
  35.     }
  36. }
          而如上的两个广播都是BluetoothPeripheralHandover在它的start()中进行注册的，最终由mReceiver处理 
   
   
  1.     final BroadcastReceiver mReceiver = new BroadcastReceiver() {
  2.         @Override
  3.         public void onReceive(Context context, Intent intent) {
  4.             handleIntent(intent);
  5.         }
  6.     };
  7.     void handleIntent(Intent intent) {
  8.         String action = intent.getAction();
  9.         ...
  10.         //配对的Action
  11.         if (ACTION_ALLOW_CONNECT.equals(action)) {
  12.             //执行配对前再次发送延时信息，因为不确定配对多长时间完成，以及有没有成功
  13.             mHandler.removeMessages(MSG_TIMEOUT);
  14.             mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_TIMEOUT), TIMEOUT_MS);
  15.             nextStepConnect();
  16.         //下面是取消配对的action
  17.         } else if (ACTION_DENY_CONNECT.equals(action)) {
  18.             complete(false);
  19.         //下面是配对状态变化的action
  20.         } else if (BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(action)
  21.                 && mState == STATE_BONDING) {
  22.             int bond = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE,
  23.                     BluetoothAdapter.ERROR);
  24.             if (bond == BluetoothDevice.BOND_BONDED) {
  25.                 mRetryCount = 0;
  26.                 nextStepConnect();
  27.             } else if (bond == BluetoothDevice.BOND_NONE) {
  28.                 if (mRetryCount < MAX_RETRY_COUNT) {
  29.                     sendRetryMessage(RETRY_PAIRING_WAIT_TIME_MS);
  30.                 } else {
  31.                     toast(getToastString(R.string.pairing_peripheral_failed));
  32.                     complete(false);
  33.                 }
  34.             }
  35.         //下面是BluetoothHeadset profile链接状态变化的action
  36.         } else if (BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED.equals(action) &&
  37.                 (mState == STATE_CONNECTING || mState == STATE_DISCONNECTING)) {
  38.             ...
  39.         //下面是BluetoothA2dp profile链接状态变化的action
  40.         } else if (BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED.equals(action) &&
  41.                 (mState == STATE_CONNECTING || mState == STATE_DISCONNECTING)) {
  42.             ...
  43.         //下面是BluetoothInputDevice profile链接状态变化的action
  44.         } else if (BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED.equals(action) &&
  45.                 (mState == STATE_CONNECTING || mState == STATE_DISCONNECTING)) {
  46.             int state = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, BluetoothAdapter.ERROR);
  47.             if (state == BluetoothProfile.STATE_CONNECTED) {
  48.                 //链接成功的时候
  49.                 mHidResult = RESULT_CONNECTED;
  50.                 nextStep();
  51.             } else if (state == BluetoothProfile.STATE_DISCONNECTED) {
  52.                 //连接失败的时候
  53.                 mHidResult = RESULT_DISCONNECTED;
  54.                 nextStep();
  55.             }
  56.         }
  57.     }
         此时假如我们选择的是和蓝牙键盘进行配对那么会走到nextStepConnect()，但此时的state是STATE_WAITING_FOR_BO
ND _ CO NFI RMATION
         参照前面的代码，最终走到startBonding方法 
   
   
  1.     void startBonding() {
  2.         //显示修改状态
  3.         mState = STATE_BONDING;
  4.         //直接调用BluetoothDevice的不同的Bond方法进行配对，暂不清楚这两个的具体区别？？？
  5.         if (mOobData != null) {
  6.             if (!mDevice.createBondOutOfBand(mTransport, mOobData)) {
  7.                 toast(mContext.getString(R.string.nfc_strings_toast_sht_paring_failed_txt));
  8.                 complete(false);
  9.             }
  10.         } else if (!mDevice.createBond(mTransport)) {
  11.                 toast(mContext.getString(R.string.nfc_strings_toast_sht_paring_failed_txt));
  12.                 complete(false);
  13.         }
  14.     }
          无论我们配对成功与否，当配对状态发生改变的时候，就会走到前面说的handleIntent中对应的判断。ACTION_BOND_S
TATE_CHANGED，并且此时的state为STATE_BONDING.查看上面代码，在配对成功的时候调用nextStepConnect，失败的时
候根据判断重试或者直接做最后的赋值操作。
          在nextStepConnect()当中此时的state状态时STATE_BONDING，注意此时已经是配对成功了，但是state还没改变，处于
正在配对状态，那么我们进去case STATE_BONDING。然后先把状态改为：mState = STATE_CONNECTING;正在链接接着就
开始真正的connect。根据不同的profile调用不同的connect。在连接成功后BT那边会往外发送广播，会被 handleIntent进行处理，
此处我们是以链接蓝牙键盘为例子，那么就会走到BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED 然后又去
调用nextStep(),又会走到nextStepConnect()。但此时的状态时是state为STATE_CONNECTING.进入到 对应的判断中做最后的通
知处理即可，调用complete。
         //成功的时候true，失败的时候false. 
   
   
  1.     void complete(boolean connected) {
  2.         reportBluetoothPeripheralHandoverComplete(connected);
  3.         mState = STATE_COMPLETE;
  4.         mContext.unregisterReceiver(mReceiver);
  5.         mHandler.removeMessages(MSG_TIMEOUT);
  6.         mHandler.removeMessages(MSG_RETRY);
  7.         synchronized (mLock) {
  8.             if (mA2dp != null) {
  9.                 mBluetoothAdapter.closeProfileProxy(BluetoothProfile.A2DP, mA2dp);
  10.             }
  11.             if (mHeadset != null) {
  12.                 mBluetoothAdapter.closeProfileProxy(BluetoothProfile.HEADSET, mHeadset);
  13.             }
  15.             if (mInput != null) {
  16.                 mBluetoothAdapter.closeProfileProxy(BluetoothProfile.INPUT_DEVICE, mInput);
  17.             }
  19.             mA2dp = null;
  20.             mHeadset = null;
  21.             mInput = null;
  22.         }
  23.         mCallback.onBluetoothPeripheralHandoverComplete(connected);
  24.     }
         至此完成了类似于读取Tag的分发流程，把每个外设都看成是一个Nfc的Tag.

2、当是P2P模式最终以蓝牙传输的时候。
      此处直接从P2P模式已经确认要发送开始，此时用户已经点击屏幕，开始回调发送事件。对应的HandoverClient和Handover
Se rver已经启动。(前面的文章有分析) 就是P2pLinkManager类的SendTask内部类开始分析，且只分析handover的 
  
  
  1.     final class SendTask extends AsyncTask<Void, Void, Void> {
  2.         ...
  3.         HandoverClient handoverClient;
  4.         //需要通过BT传输的操作
  5.         int doHandover(Uri[] uris, UserHandle userHandle) throws IOException {
  6.             NdefMessage response = null;
  7.             //先实例化BeamManager，用于管理从开始到结束的传输的动作。
  8.             BeamManager beamManager = BeamManager.getInstance();
  9.             //判断是不是有一个传输正在进行。
  10.             if (beamManager.isBeamInProgress()) {
  11.                 return HANDOVER_BUSY;
  12.             }
  13.             //如下是客户端根据协议把要请求的信息如蓝牙地址等，封装成NDEF格式的信息用于往外发送给
  14.             //另一个手机也就是服务端，然后服务端开启自己的BT进行配对等等的操作，暂不分析此处的是现实细节
  15.             NdefMessage request = mHandoverDataParser.createHandoverRequestMessage();
  16.             //如果成功封装成Ndef信息
  17.             if (request != null) {
  18.                 if (handoverClient != null) {
  19.                     //通过Client想客户端发送请求，内部就是往指定的服务器地址发送Ndef请求信息，请求试用handover来传输
  20.                     //此处的信息还是通过Nfc来发送的。
  21.                     response = handoverClient.sendHandoverRequest(request);
  22.                 }
  23.                 //如果远端的手机不支持handover，那么改用别的方式.
  24.                 if (response == null && snepClient != null) {
  25.                     SnepMessage snepResponse = snepClient.get(request);
  26.                     response = snepResponse.getNdefMessage();
  27.                 }
  28.                 if (response == null) {
  29.                     if (snepClient != null)
  30.                         return HANDOVER_UNSUPPORTED;
  31.                     else
  32.                         return HANDOVER_FAILURE;
  33.                 }
  34.             } else {
  35.                 return HANDOVER_UNSUPPORTED;
  36.             }
  37.             //走到这里的时候证明远端的Handover是成功，打算开始调用BT进行真正的数据的传输。
  38.             //mHandoverDataParser.getOutgoingHandoverData(response)，来把HandoverServer传过来的
  39.             //Ndef数据解析，并且赋值给我们需要的变量，就是比如把蓝牙地址、名称、数据配对信息等，赋值给了BeamManager
  40.             //的一些变量，此处暂不深入分析，因为的对照协议解析，暂时不太清楚？？？
  41.             if (!beamManager.startBeamSend(mContext,
  42.                     mHandoverDataParser.getOutgoingHandoverData(response), uris, userHandle)) {
  43.                 return HANDOVER_BUSY;
  44.             }
  45.             return HANDOVER_SUCCESS;
  46.         }
  48.         int doSnepProtocol(NdefMessage msg) throws IOException {
  49.             ...
  50.         }
  52.         @Override
  53.         public Void doInBackground(Void... args) {
  54.             ......
  55.             //当解析传过来的数据发现需要使用handover的时候，uris被设置值，此时进入到doHandover
  56.             if (uris != null) {
  57.                 try {
  58.                     int handoverResult = doHandover(uris, userHandle);
  59.                     switch (handoverResult) {
  60.                         case HANDOVER_SUCCESS:
  61.                             result = true;
  62.                             break;
  63.                         case HANDOVER_FAILURE:
  64.                             result = false;
  65.                             break;
  66.                         case HANDOVER_UNSUPPORTED:
  67.                             result = false;
  68.                             onHandoverUnsupported();
  69.                             break;
  70.                         case HANDOVER_BUSY:
  71.                             result = false;
  72.                             onHandoverBusy();
  73.                             break;
  74.                     }
  75.                 } catch (IOException e) {
  76.                     result = false;
  77.                 }
  78.             }
  79.             ......
  80.             if (result) {
  81.                 onSendComplete(m, time);
  82.             }
  84.             return null;
  85.         }
  86.     }
          接下来我们就来看看BeamManager的简单介绍 
   
   
  1. public class BeamManager implements Handler.Callback {
  2.     ...//省略成员变量显示
  3.     //获取实例，单例模式
  4.     private static final class Singleton {
  5.         public static final BeamManager INSTANCE = new BeamManager();
  6.     }
  8.     private BeamManager() {
  9.         mLock = new Object();
  10.         mBeamInProgress = false;
  11.         mCallback = new Handler(Looper.getMainLooper(), this);
  12.         mNfcService = NfcService.getInstance();
  13.     }
  15.     public static BeamManager getInstance() {
  16.         return Singleton.INSTANCE;
  17.     }
  19.     public boolean isBeamInProgress() {
  20.         synchronized (mLock) {
  21.             return mBeamInProgress;
  22.         }
  23.     }
  24.     public boolean startBeamReceive(Context context,
  25.                                  HandoverDataParser.BluetoothHandoverData handoverData) {
  26.         synchronized (mLock) {
  27.             if (mBeamInProgress) {
  28.                 return false;
  29.             } else {
  30.                 mBeamInProgress = true;
  31.             }
  32.         }
  34.         BeamTransferRecord transferRecord =
  35.                 BeamTransferRecord.forBluetoothDevice(
  36.                         handoverData.device, handoverData.carrierActivating, null);
  38.         Intent receiveIntent = new Intent(context.getApplicationContext(),
  39.                 BeamReceiveService.class);
  40.         receiveIntent.putExtra(BeamReceiveService.EXTRA_BEAM_TRANSFER_RECORD, transferRecord);
  41.         receiveIntent.putExtra(BeamReceiveService.EXTRA_BEAM_COMPLETE_CALLBACK,
  42.                 new Messenger(mCallback));
  44.         if (CtaUtils.showCtaBtDialogIfNeeded(context, mCallback,
  45.                 receiveIntent, handoverData.device)) {
  46.             return true;
  47.         }
  49.         whitelistOppDevice(context, handoverData.device);
  50.         context.startServiceAsUser(receiveIntent, UserHandle.CURRENT);
  51.         return true;
  52.     }
  53.     
  54.     //已经收到回应开始尝试使用handover模式也称之为Beam模式
  55.     //注意第二个参数就是远端的Handoverserver给出的回应，进一步封装的数据
  56.     public boolean startBeamSend(Context context,
  57.                                HandoverDataParser.BluetoothHandoverData outgoingHandoverData,
  58.                                Uri[] uris, UserHandle userHandle) {
  59.         //只能执行一个传输.
  60.         synchronized (mLock) {
  61.             if (mBeamInProgress) {
  62.                 return false;
  63.             } else {
  64.                 mBeamInProgress = true;
  65.             }
  66.         }
  67.         //这个Record如其名字，就是记录了remoteDevice(远端的device)、uris(存放的要传输的数据的uri)等
  68.         BeamTransferRecord transferRecord = BeamTransferRecord.forBluetoothDevice(
  69.                 outgoingHandoverData.device, outgoingHandoverData.carrierActivating,
  70.                 uris);
  71.         //启动BeamReceiveService来通过service进一步完成正真的传输.
  72.         Intent sendIntent = new Intent(context.getApplicationContext(),
  73.                 BeamSendService.class);
  74.         sendIntent.putExtra(BeamSendService.EXTRA_BEAM_TRANSFER_RECORD, transferRecord);
  75.         sendIntent.putExtra(BeamSendService.EXTRA_BEAM_COMPLETE_CALLBACK,
  76.                 new Messenger(mCallback));
  77.         ......
  79.         context.startServiceAsUser(sendIntent, userHandle);
  80.         return true;
  81.     }
  83.     @Override
  84.     public boolean handleMessage(Message msg) {
  85.         if (msg.what == MSG_BEAM_COMPLETE) {
  86.             synchronized (mLock) {
  87.                 mBeamInProgress = false;
  88.             }
  90.             boolean success = msg.arg1 == 1;
  91.             if (success) {
  92.                 mNfcService.playSound(NfcService.SOUND_END);
  93.             }
  94.             return true;
  95.         }
  96.         return false;
  97.     }
  99.     void whitelistOppDevice(Context context, BluetoothDevice device) {
  100.         if (DBG) Log.d(TAG, "Whitelisting " + device + " for BT OPP");
  101.         Intent intent = new Intent(ACTION_WHITELIST_DEVICE);
  102.         intent.setPackage(BLUETOOTH_PACKAGE);
  103.         intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
  104.         context.sendBroadcastAsUser(intent, UserHandle.CURRENT);
  105.     }
  106. }
          此时是调用到了startBeamSend进而启动BeamSendService来完成进一步的操作。 
   
   
  1. public class BeamSendService extends Service implements BeamTransferManager.Callback{
  2.     ......
  3.     private final BroadcastReceiver mBluetoothStateReceiver = new BroadcastReceiver() {
  4.         @Override
  5.         public void onReceive(Context context, Intent intent) {
  6.             String action = intent.getAction();
  7.             if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
  8.                 handleBluetoothStateChanged(intent);
  9.             }
  10.         }
  11.     };
  13.     //构造很简单只是得到了BluetoothAdapter
  14.     public BeamSendService() {
  15.         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
  16.     }
  18.     @Override
  19.     public void onCreate() {
  20.         super.onCreate();
  22.         IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
  23.         registerReceiver(mBluetoothStateReceiver, filter);
  24.     }
  26.     @Override
  27.     public int onStartCommand(Intent intent, int flags, int startId) {
  28.         ......
  29.         //调用doTransfer开始往外发送.
  30.         if (doTransfer(transferRecord)) {
  31.             return START_STICKY;
  32.         } else {
  33.             //异常处理
  34.             ......
  35.         }
  36.     }
  38.     boolean doTransfer(BeamTransferRecord transferRecord) {
  39.         if (createBeamTransferManager(transferRecord)) {
  40.             //下面这个receiver我们后面在解释。
  41.             mBeamStatusReceiver = new BeamStatusReceiver(this, mTransferManager);
  42.             registerReceiver(mBeamStatusReceiver, mBeamStatusReceiver.getIntentFilter(),
  43.                     BeamStatusReceiver.BEAM_STATUS_PERMISSION, new Handler());
  44.             //Ndef信息中携带的是蓝牙的传输链接的时候才进行传输。
  45.             if (transferRecord.dataLinkType == BeamTransferRecord.DATA_LINK_TYPE_BLUETOOTH) {
  46.                 //如果已经打开
  47.                 if (mBluetoothAdapter.isEnabled()) {
  48.                     // 直接调用TransferManager的start开始传送，
  49.                     mTransferManager.start();
  50.                 } else {
  51.                     //调用BT相关的接口去打开蓝牙，打开成功后会发送蓝牙状态改变你的广播，
  52.                     if (!mBluetoothAdapter.enableNoAutoConnect()) {
  53.                         Log.e(TAG, "Error enabling Bluetooth.");
  54.                         mTransferManager = null;
  55.                         return false;
  56.                     }
  57.                     //用来标记是Nfc打开的BT
  58.                     mBluetoothEnabledByNfc = true;
  59.                     ...
  60.                 }
  61.             }
  62.             return true;
  63.         }
  64.         return false;
  65.     }
  67.     boolean createBeamTransferManager(BeamTransferRecord transferRecord) {
  68.         ......
  69.         //如下的实例化很关键
  70.         //实例化BeamTransferManager来管理传输中的流程显示等，关于BeamTransferManager下面详解
  71.         mTransferManager = new BeamTransferManager(this, this, transferRecord, false);
  72.         //第一个notification！
  73.         mTransferManager.updateNotification();
  74.         return true;
  75.     }
  77.     //收到BT开启的广播以后开始准备传送.
  78.     private void handleBluetoothStateChanged(Intent intent) {
  79.         int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE,
  80.                 BluetoothAdapter.ERROR);
  81.         if (state == BluetoothAdapter.STATE_ON) {
  82.             if (mTransferManager != null &&
  83.                     mTransferManager.mDataLinkType == BeamTransferRecord.DATA_LINK_TYPE_BLUETOOTH) {
  84.                 //收到广播以后同样是调用TransferManager的start开始传输.
  85.                 mTransferManager.start();
  86.             }
  87.         }
  88.     }
  89.     ......
  91.     //传输完成的回调.
  92.     @Override
  93.     public void onTransferComplete(BeamTransferManager transfer, boolean success) {
  94.         // Play success sound
  95.         ......
  96.         if (mBluetoothEnabledByNfc) {
  97.             mBluetoothEnabledByNfc = false;
  98.             mBluetoothAdapter.disable();
  99.         }
  100.         //    
  101.         invokeCompleteCallback(success);
  102.         stopSelf(mStartId);
  103.     }
  104.     ......
  105. }
          可以看到如上的很多的工作都是在BeamTransferManager中完成的！BeamTransferManager代码较多此处就一点点分析
先从实例化看起。
           构造中实例化的变量很多，我们只看比较重要的。 
   
   
  1.    public BeamTransferManager(Context context, Callback callback,
  2.                                BeamTransferRecord pendingTransfer, boolean incoming) {
  3.         ...
  4.         mRemoteDevice = pendingTransfer.remoteDevice;
  5.         //往外发送的时候是false.
  6.         mIncoming = incoming;
  7.         mTransferId = pendingTransfer.id;
  8.         mDataLinkType = pendingTransfer.dataLinkType;
  9.         mRemoteActivating = pendingTransfer.remoteActivating;
  10.         mTotalCount = (pendingTransfer.uris != null) ? pendingTransfer.uris.length : 0;
  11.         mProgress = 0.0f;
  12.         mState = STATE_NEW;
  13.         mUris = pendingTransfer.uris == null
  14.                 ? new ArrayList<Uri>()
  15.                 : new ArrayList<Uri>(Arrays.asList(pendingTransfer.uris));
  16.         ......
  17.         //将要往外发送的uris
  18.         mOutgoingUris = pendingTransfer.uris;
  19.     }
          接下来就是第一个通知updateNotification，借此我们来分析一下此方法。 
   
   
  1.     void updateNotification() {
  2.         Builder notBuilder = new Notification.Builder(mContext, BEAM_NOTIFICATION_CHANNEL);
  3.         notBuilder.setXXX;
  4.         ...
  5.         String beamString;
  6.         //下面判断是往外发送还是接受的，此处我们分析的是发送的。（接受的是不是从HandoverServer开始分析？）
  7.         if (mIncoming) {
  8.             beamString = mContext.getString(R.string.beam_progress);
  9.         } else {
  10.             beamString = mContext.getString(R.string.beam_outgoing);
  11.         }
  12.         //第一次的时候mState == STATE_NEW在构造中进行的实例化
  13.         if (mState == STATE_NEW || mState == STATE_IN_PROGRESS ||
  14.                 mState == STATE_W4_NEXT_TRANSFER || mState == STATE_W4_MEDIA_SCANNER) {
  15.             notBuilder.setXXX;
  16.             ...
  17.             //下面就是处理进度条显示的问题
  18.             float progress = 0;
  19.             if (mTotalCount > 0) {
  20.                 float progressUnit = 1.0f / mTotalCount;
  21.                 progress = (float) mCurrentCount * progressUnit + mProgress * progressUnit;
  22.             }
  23.             if (mTotalCount > 0 && progress > 0) {
  24.                 notBuilder.setProgress(100, (int) (100 * progress), false);
  25.             } else {
  26.                 notBuilder.setProgress(100, 0, true);
  27.             }
  28.         //下面是当传输成功的时候
  29.         } else if (mState == STATE_SUCCESS) {
  30.             notBuilder.setAutoCancel(true);
  31.             ...
  32.         //下面是当传输失败的时候
  33.         } else if (mState == STATE_FAILED) {
  34.             notBuilder.setAutoCancel(false);
  35.             ...
  36.         //取消传输的时候
  37.         } else if (mState == STATE_CANCELLED || mState == STATE_CANCELLING) {
  38.             notBuilder.setAutoCancel(false);
  39.             ...
  40.         } else {
  41.             return;
  42.         }
  43.         //把不同的显示内容notify出去即可。
  44.         mNotificationManager.notify(null, mTransferId, notBuilder.build());
  45.     }
          再往下就是start()开始传输的函数了。 
   
   
  1.     public void start() {
  2.         ......
  3.         //当是往外传输的时候
  4.         if (!mIncoming
  5.             //当是通过蓝牙往外传输的时候
  6.             if (mDataLinkType == BeamTransferRecord.DATA_LINK_TYPE_BLUETOOTH) {
  7.                 //传入Handoverserver返回回来的Ndef消息用于和本地蓝牙配对链接等。
  8.                 new BluetoothOppHandover(mContext, mRemoteDevice, mUris, mRemoteActivating).start();
  9.             }
  10.         }
  11.     }
          BluetoothOppHandover用于完成和本地蓝牙的交互操作，start如下： 
   
   
  1.     public void start() {
  2.         if (mRemoteActivating) {
  3.             Long timeElapsed = SystemClock.elapsedRealtime() - mCreateTime;
  4.             if (timeElapsed < REMOTE_BT_ENABLE_DELAY_MS) {
  5.                 //此处左中也是调用sendIntent().
  6.                 mHandler.sendEmptyMessageDelayed(MSG_START_SEND,
  7.                         REMOTE_BT_ENABLE_DELAY_MS - timeElapsed);
  8.             } else {
  9.                 sendIntent();
  10.             }
  11.         } else {
  12.             // Remote BT enabled already, start send immediately
  13.             sendIntent();
  14.         }
  15.     }
          那么我们就看一下BluetoothOppHandover当中的sendIntent 
   
   
  1.     void sendIntent() {
  2.         Intent intent = new Intent();
  3.         intent.setPackage("com.android.bluetooth");
  4.         String mimeType = MimeTypeUtil.getMimeTypeForUri(mContext, mUris.get(0));
  5.         intent.setType(mimeType);
  6.         intent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice);
  7.         ......
  8.         //而如下两个广播那在Bluetooth.apk的应用中的BluetoothOppHandoverReceiver
  9.         //进行了处理，最终由Bluetooth去完成发送文件的操作。
  10.         if (mUris.size() == 1) {
  11.             intent.setAction(ACTION_HANDOVER_SEND);
  12.             intent.putExtra(Intent.EXTRA_STREAM, mUris.get(0));
  13.         } else {
  14.             intent.setAction(ACTION_HANDOVER_SEND_MULTIPLE);
  15.             intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, mUris);
  16.         }
  17.         if (DBG) Log.d(TAG, "Handing off outging transfer to BT");
  18.         intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
  19.         mContext.sendBroadcast(intent);
  20.         complete();//状态置为complete
  21.     }
          到此我们就完成了Nfc端的发送广播和BT通信去完成最终的数据传输，一旦开始传输，蓝牙就会在每个传输的阶段发送广
播给Nfc的应用以便Nfc应用可以更新通知的显示。这些操作也是在BeamTransferManager当中实现的。我们也应该意识到有个
receiver去接受来自BT的广播，进而完成更新操作。这就是前面在SendService中的doTransfer()进行实例化的BeamStatusRece
iver，它用于我们上面所说的操作，我们去看一下。 
   
   
  2. public class BeamStatusReceiver extends BroadcastReceiver {
  3.     ...//各种成员变量的广播我们就省略了，代码中直接看即可
  5.     //构造
  6.     BeamStatusReceiver(Context context, BeamTransferManager transferManager) {
  7.         mContext = context;
  8.         mTransferManager = transferManager;
  9.     }
  11.     @Override
  12.     public void onReceive(Context context, Intent intent) {
  13.         String action = intent.getAction();
  14.         int dataLinkType = intent.getIntExtra(EXTRA_HANDOVER_DATA_LINK_TYPE,
  15.                 BeamTransferManager.DATA_LINK_TYPE_BLUETOOTH);
  17.         if (ACTION_CANCEL_HANDOVER_TRANSFER.equals(action)) {
  18.             if (mTransferManager != null) {
  19.                 mTransferManager.cancel();
  20.             }
  21.         } else if (ACTION_TRANSFER_PROGRESS.equals(action) ||
  22.                 ACTION_TRANSFER_DONE.equals(action) ||
  23.                 ACTION_HANDOVER_STARTED.equals(action)) {
  24.             handleTransferEvent(intent, dataLinkType);
  25.         }
  26.     }
  28.     //感兴趣的广播
  29.     public IntentFilter getIntentFilter() {
  30.         IntentFilter filter = new IntentFilter(ACTION_TRANSFER_DONE);
  31.         filter.addAction(ACTION_TRANSFER_PROGRESS);
  32.         filter.addAction(ACTION_CANCEL_HANDOVER_TRANSFER);
  33.         filter.addAction(ACTION_HANDOVER_STARTED);
  34.         return filter;
  35.     }
  37.     private void handleTransferEvent(Intent intent, int deviceType) {
  38.         String action = intent.getAction();
  39.         int id = intent.getIntExtra(EXTRA_TRANSFER_ID, -1);
  41.         String sourceAddress = intent.getStringExtra(EXTRA_ADDRESS);
  42.         ......
  43.         mTransferManager.setBluetoothTransferId(id);
  45.         //接收到BT传输完成，发过来的对应广播以后更新，最终还是更新notification.
  46.         //这个广播在传输完成后20s还不发，就会出现发送失败的显示.
  47.         if (action.equals(ACTION_TRANSFER_DONE)) {
  48.             int handoverStatus = intent.getIntExtra(EXTRA_TRANSFER_STATUS,
  49.                     HANDOVER_TRANSFER_STATUS_FAILURE);
  50.             if (handoverStatus == HANDOVER_TRANSFER_STATUS_SUCCESS) {
  51.                 ......
  52.                 mTransferManager.finishTransfer(true, uri, mimeType);
  53.             } else {
  54.                 mTransferManager.finishTransfer(false, null, null);
  55.             }
  56.         //传输的过程中BT发过来的广播，这个的实现就是在BluetoothOppNotification类中
  57.         //嵌入到了蓝牙的通知中，就好比改更新蓝牙传输的进度的时候，隐藏了不更新，转而发送
  58.         //这个notification然后Nfc来更新进度！
  59.         } else if (action.equals(ACTION_TRANSFER_PROGRESS)) {
  60.             float progress = intent.getFloatExtra(EXTRA_TRANSFER_PROGRESS, 0.0f);
  61.             mTransferManager.updateFileProgress(progress);
  62.         //用于开始Handover的处理
  63.         } else if (action.equals(ACTION_HANDOVER_STARTED)) {
  64.             int count = intent.getIntExtra(EXTRA_OBJECT_COUNT, 0);
  65.             if (count > 0) {
  66.                 mTransferManager.setObjectCount(count);
  67.             }
  68.         }
  69.     }
  70. }
          通过上面可以大概的总结一下，在传输的过程中的时候是一直在调用mTransferManager.updateFileProgress(progress)而在
传输完毕后调用mTransferManager.finishTransfer(true, uri, mimeType);看起来并没有更新Notification啊别急，继续分析这两个的
实现。
     先看updateFileProgress 
  
  
  1.     public void updateFileProgress(float progress) {
  2.         ......
  3.         this.mProgress = progress;
  4.         //用于接受的时候
  5.         if (mIncoming && mRemoteDevice != null) whitelistOppDevice(mRemoteDevice);
  7.         updateStateAndNotification(STATE_IN_PROGRESS);
  8.     }
  9.     //调用到了updateStateAndNotification，并且传入state = STATE_IN_PROGRESS
  10.     void updateStateAndNotification(int newState) {
  11.         this.mState = newState;
  12.         ......
  13.         //终于看到这个了，去更新Notification，如我们前面所分析。
  14.         updateNotification();
  15.         ......
  16.     }
           再看一下finishTransfer 
   
   
  1.     public void finishTransfer(boolean success, Uri uri, String mimeType) {
  2.         ......
  3.         if (success && uri != null) {
  4.             ...
  5.             //重新初始化进度
  6.             mProgress = 0.0f;
  7.             if (mimeType == null) {
  8.                 mimeType = MimeTypeUtil.getMimeTypeForUri(mContext, uri);
  9.             }
  10.             if (mimeType != null) {
  11.                 mUris.add(uri);
  12.                 mTransferMimeTypes.add(mimeType);
  13.             } 
  14.             ...
  15.         } else {
  16.             Log.e(TAG, "Handover transfer failed");
  17.         }
  18.         mHandler.removeMessages(MSG_NEXT_TRANSFER_TIMER);
  19.         if (mCurrentCount == mTotalCount) {
  20.             if (mIncoming) {
  21.                 //当是接受的时候还回去做进一步处理，如把这个收到的数据放到那里等
  22.                 processFiles();
  23.             } else {
  24.                 ......
  25.                 //发送的时候，根据发送成功的文件数量来调用updateStateAndNotification
  26.                 updateStateAndNotification(mSuccessCount > 0 ? STATE_SUCCESS : STATE_FAILED);
  27.             }
  28.         } else {
  29.             //不止一个图的时候
  30.             mHandler.sendEmptyMessageDelayed(MSG_NEXT_TRANSFER_TIMER, WAIT_FOR_NEXT_TRANSFER_MS);
  31.             updateStateAndNotification(STATE_W4_NEXT_TRANSFER);
  32.         }
  33.     }
          对于发送而言也是调用到updateStateAndNotification，进而进入到updateNotification更新通知栏。至此我们分析完毕 往外
发送数据的时候的流程，接下来简单看一下接受数据的时候。 理所应当的就想到了接受的地方肯定跑不了HandoverServer当中
啊，然后是在内部类ServerThread中接受然请求的handover信息，
         发送完respond以后调用到ConnectionThread中的run的如下代码： 
   
   
  1.      if (!beamManager.startBeamReceive(mContext, handoverData.handoverData)) {
  2.           mCallback.onHandoverBusy();
  3.           break;
  4.      }
        调用到BeamTransferManager中的startBeamReceive,前面那我们已经列过其代码，此处再单独列出来分析一下。 
   
   
  1.     public boolean startBeamReceive(Context context,
  2.                                  HandoverDataParser.BluetoothHandoverData handoverData) {
  3.         ...
  4.         //同样也是实例化一个transferRecord
  5.         BeamTransferRecord transferRecord =
  6.                 BeamTransferRecord.forBluetoothDevice(
  7.                         handoverData.device, handoverData.carrierActivating, null);
  8.         //期初的service就不同了，这块要启动的是BeamReceiveService.
  9.         Intent receiveIntent = new Intent(context.getApplicationContext(),
  10.                 BeamReceiveService.class);
  11.         receiveIntent.putExtra(BeamReceiveService.EXTRA_BEAM_TRANSFER_RECORD, transferRecord);
  12.         receiveIntent.putExtra(BeamReceiveService.EXTRA_BEAM_COMPLETE_CALLBACK,
  13.                 new Messenger(mCallback));
  14.         //接收数据的device的白名单的
  15.         whitelistOppDevice(context, handoverData.device);
  16.         context.startServiceAsUser(receiveIntent, UserHandle.CURRENT);
  17.         return true;
  18.     }
         下面列出BeamReceiveService的简单介绍。 
   
   
  1. public class BeamReceiveService extends Service implements BeamTransferManager.Callback{
  2.     ......
  3.     private final BroadcastReceiver mBluetoothStateReceiver = new BroadcastReceiver() {
  4.         @Override
  5.         public void onReceive(Context context, Intent intent) {
  6.             String action = intent.getAction();
  7.             if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(action)) {
  8.                 int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE,
  9.                         BluetoothAdapter.ERROR);
  10.                 if (state == BluetoothAdapter.STATE_OFF) {
  11.                     //源码就什么也没写，看来是在关闭的时候不作操作。
  12.                 }
  13.             }
  14.         }
  15.     };
  16.     //构造
  17.     public BeamReceiveService() {
  18.         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
  19.     }
  21.     @Override
  22.     public int onStartCommand(Intent intent, int flags, int startId) {
  23.         ......
  24.         //同理发送的时候的设计形式，只不过此处调用的是prepareToReceive.
  25.         if (prepareToReceive(transferRecord)) {
  26.             if (DBG) Log.i(TAG, "Ready for incoming Beam transfer");
  27.             return START_STICKY;
  28.         } else {
  29.             ......//异常处理
  30.         }
  31.     }
  33.     // TODO: figure out a way to not duplicate this code
  34.     @Override
  35.     public void onCreate() {
  36.         ......
  37.         IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
  38.         registerReceiver(mBluetoothStateReceiver, filter);
  39.     }
  41.     ......
  43.     boolean prepareToReceive(BeamTransferRecord transferRecord) {
  44.         ......
  45.         //没有开启的时候
  46.         if (!mBluetoothAdapter.isEnabled()) {
  47.             //开启蓝牙下面的标志已经见过好多次了。
  48.             if (!mBluetoothAdapter.enableNoAutoConnect()) {
  49.                 Log.e(TAG, "Error enabling Bluetooth.");
  50.                 return false;
  51.             }
  52.             mBluetoothEnabledByNfc = true;
  53.         }
  54.         //同样接受的时候在这里实例化BeamTransferManager.
  55.         mTransferManager = new BeamTransferManager(this, this, transferRecord, true);
  57.         //也需要更新进度条，同样实例化BeamStatusReceiver
  58.         mBeamStatusReceiver = new BeamStatusReceiver(this, mTransferManager);
  59.         registerReceiver(mBeamStatusReceiver, mBeamStatusReceiver.getIntentFilter(),
  60.                 BeamStatusReceiver.BEAM_STATUS_PERMISSION, new Handler());
  62.         mTransferManager.start();
  63.         mTransferManager.updateNotification();
  64.         return true;
  65.     }
  66.     ......
  68.     @Override
  69.     public void onTransferComplete(BeamTransferManager transfer, boolean success) {
  70.         ......
  71.     }
  72.     ......
  73. }
  74.     //可以看到start对接受没什么实质性的操作
  75.     public void start() {
  76.         ......
  77.         if (!mIncoming) {
  78.             if (mDataLinkType == BeamTransferRecord.DATA_LINK_TYPE_BLUETOOTH) {
  79.                 new BluetoothOppHandover(mContext, mRemoteDevice, mUris, mRemoteActivating).start();
  80.             }
  81.         }
  82.     }
         接下来就是根据BT放接受的成都以及传过来的广播来更新Notification了，注意一下mIncoming的值就行。
        至此简单的分析了一下NFC和Handover(也成Beam)协同工作的流程，还有一些断开连接等流程未继续分析，不过代码都是
在这 一块了。

hostapd_cli命令源码分析
viewsky11的专栏
02-15 7608
hostapd提供了控制命令hostapd_cli，使用方法可以查看usage。源码中的main函数：int main(int argc, char *argv[]) { int warning_displayed = 0; int c; int daemonize = 0; if (os_program_init())//不同操作体统平台下执行不同的环境初始化
[NFC]NFC启动流程2
Paul专栏
03-27 7073
正式进入NFCService.java，开始NFC framework探索， jiu～～～～
NFC Connection Handover规范
06-28
NFC Connection Handover规范定义了NFC如何使用Connection Handover技术传输文件。
NFC源码分析之R/W工作模式
宇你有缘
05-04 5834
文章整理总结NFC读取和写入Tag的java层的流程，至于一些native层的接入点，暂记住。后续持续更新。 1、读取Tag的流程            NfcService启动完成后，会进入到NfcService中的applyRouting方法持续的监听是否有Tag靠近，它会使Nfc的RF工作在 polling模式，polling模式下会检测那个Tag进入到了自己的射频厂，进而
NFC源码分析之初始化流程
宇你有缘
12-21 7495
Nfc的app代码位于：     android/package/apps/Nfc/... 编译生成Nfc的apk和libnfc_nci_jni.so Nfc的协议栈和Hal相关的代码位于：     system/nfc/... (原生的应该是位于/external/libnfc-nci)编译生成libnfc-nci.so     在Nfc的app的Andr
Android蓝牙完全学习手册
热门推荐
eyelike的专栏
05-17 1万+
1.前言市面上关于Android的技术书籍很多，几乎每本书也都会涉及到蓝牙开发，但均是上层应用级别的，而且篇幅也普遍短小。对于手机行业的开发者，要进行蓝牙模块的维护，就必须从Android系统底层，至少框架层开始，了解蓝牙的结构和代码实现原理。这方面的文档、网上的各个论坛的相关资料却少之又少。分析原因，大概因为虽然蓝牙协议是完整的，但是并没有具体的实现。蓝牙芯片公司只负责提供最底层的API，与上层的
Android NFC技术解析，附Demo源码
weixin_34349320的博客
04-17 254
近期由于项目需求，对Android NFC 技术进行了一定的了解和深入，整合了一些网络、书籍资料，此文章仅作为自己的学习笔记。源码请看文末提供了一种简单、触控式的解决方案，可以让消费者简单直观地交换信息、访问内容与服务。NFC技术允许电子设备之间进行非接触式点对点数据传输，在十厘米(3.9英吋)内，交换数据，其传输速度有106Kbit/秒、212Kbit/秒或者424Kbit/秒三种。接下来我们更...
NFC(Near Field Communication，近场通信)相关
brucelyu的专栏
01-05 2078
摘自《深入理解Android：WiFi模块 NFC和GPS卷 - 邓凡平》 以前的读书笔记贴一下，Android 版本演进，源码相关的一些内容可能有很大变化。 NFC(Near Field Communication，近场通信)相关 NFC Forum 制定NFC相关的技术标准 NFC认证测试 NFC基础知识 NFC是从多种不同技术基础上综合发展而来 RFID技...
WCOPY nfcPro_20210071401最新版
07-17
WCOPY nfcPro acr122u全加密/半加密解码程序，小巧耐用
NFC概述
Utopia
11-19 2400
1. NFC技术框架 Applications层NFC有三种运行模式（operation mode）： 1）Reader/Write模式：简称R/W，和NFC Tag/NFC Reader相关。 2）Peer-to-Peer模式：简称P2P，它支持两个NFC设备交互。 3）NFC Card Emulation模式：简称CE，它能把携带NFC功能的设备模拟成SmartCard，这样就能实现诸如手机支付、门禁卡之类的功能。 NFC使用的是无线射频技术。在RF层，与之相关的规范是..
android蓝牙模块IBluetooth与IBluetoothManager详解
DamonMasty的博客
05-11 3252
IBluetooth与IBluetoothManager介绍，了解过程
带你解锁蓝牙skill（三）
fanfan
06-21 6456
本文授权微信公众号fanfan程序媛独家发布 转载请注明出处，本文出自fanfan的带你解锁蓝牙skill系列 蓝牙这块儿算是系统中的一个大块儿，刚开始分析确实很容易没有头绪，所以在进入庞大的源码之前先确定一个分析顺序，也好避免越学越乱。 对于源码的分析不外乎whw（what—how—why）对于蓝牙各协议的功能以及如何演示都已经分析完了，具体可以参考 带你解锁蓝牙skill(一)以及带你解锁
wpa_cli工具的使用方法及分析
li_liuliu的博客
10-18 6583
wpa_cli 的使用方法 在Android中有wpa_cli工具能够直接可wpa_supplicant通讯。能够查看一些wifi的信息。 使用方法：wpa_cli -i wlan0 -p /data/misc/wifi/sockets wpa_cli源码分析 int main(int argc, char *argv[]) { ··· for (;;) { c = getopt(argc,...
Android Beam文件分享失败问题单处理
红旺永福
11-23 5001
nfc beam文件分享失败的问题单处理，有在源码中加自己的日志，查找问题的日志也提供给大家，方便查看
Android4.2蓝牙Enable完全分析
鱼塘鱼汤的专栏
10-14 1万+
这应该只会是唯一的一篇从头到尾的调用关系都分析一遍的文章，目的是为了帮助初学者从上往下一层一层分析代码，对大量的代码不再害怕。如果是对阅读Android代码很熟悉的人可以略过这一篇。 蓝牙Enable Android的蓝牙Enable是由BluetoothAdapter提供的。只需要调用BluetoothAdapter.enable()即可启动蓝牙。下面我就分析这一个过程。由于Andr
Android 蓝牙（一） Bluetooth Settings 开启流程详解
liu362732346的博客
08-17 1万+
Bluedroid框架 Java +--------------------------------+ ...
[转载]NFC源码分析之R/W工作模式
刚刚好的博客
09-24 930
https://blog.youkuaiyun.com/zy00000000001/article/details/71183262 文章整理总结java层，NFC读取和写入Tag的流程。 整体的时序图： 1、读取Tag的流程     NfcService启动完成后，会通过NfcService中的applyRouting方法设置对应的Di
Android -- Bluetooth framework启动过程简析
To be or not to be, it's a question
01-14 3142
Android -- Bluetooth framework启动过程简析 蓝牙是Android设备中非常常见的一个feature，设备厂家可以用BT来做RC、连接音箱、设备本身做Sink等常见功能。如果一些设备不需要BT功能，Android也可以通过配置来disable此模块，方便厂家为自己的设备做客制化。APP操作设备的蓝牙功能，一...
android蓝牙开机自动回连,android Bluetooth开机启动流程分析
weixin_42526415的博客
05-25 1831
用到的代码文件frameworks/base/services/core/java/com/android/server/BluetoothManagerService.javacom/android/server/SystemServiceManager.javacom/android/server/BluetoothService.javacom/android/server/SystemSe...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值