USB Tethering always displays grey when USB tethering type is Linux(EEM)

USB Tethering always displays grey when USB tethering type is Linux(EEM)

1.Problem DESCRIPTION

• USB Tethering always displays grey when USB tethering type is Linux(EEM)

• Precondition:
  
  MS connects wifi

• REPRODUCING PROCEDURES:
  
  1.Go to Settings-More-Tethering&mobile hotspot,select USB tethering type as Linux(EEM)
  
  2.Use usb cable connect MS to PC,and enable USB tethering,tethering is enable,but the item always displays grey
  
  3.Disconnect the MS to PC,check the Tethering&mobile hotspot,tethering is off,but the USB tethering type item displays grey
  
  

2.Analysis

控制usb tethering type这个preference是否可用的方法在文件TetherSettingsExt.java中，具体实现如下所示：

1. publicvoid updateUsbTypeListState(boolean state){
2. if(mUsbTetherType !=null){
3. Log.d(TAG,"set USB Tether Type state = "+ state);
4. mUsbTetherType.setEnabled(state);
5. }
6. }

在正常情况下有如下状态：

1. 在未通过usb连接电脑时，usb tethering type这个preference为黑色(state为true)，usb tethering 这个preference为灰色(state为false)。
2. 在通过usb连接电脑时，usb tethering type这个preference为黑色(state为true)，usb tethering 这个preference为黑色(state为true)。
3. 在通过usb连接电脑时，打开usb tethering ，这时该preference为黑色(state为true)，usb tethering type这个preference为灰色(state为false)。
4. 拔出usb连接线，首先，usb tethering 这个preference和usb tethering type这个preference都为灰色(state为false)，过几秒钟后usb tethering type这个preference会转为黑色(state为true)。

而现在测试的实际情况是，在拔出usb连接线后，usb tethering 这个preference和usb tethering type这个preference都为灰色(state为false)且，usb tethering type这个preference一直为灰色(state为false)。

然后找到监控usb连接状态监听，其代码具体如下所示：

1. privateclassTetherChangeReceiverextendsBroadcastReceiver{
2. @Override
3. publicvoid onReceive(Context content,Intent intent){
4. String action = intent.getAction();
5. /// M:
6. Log.d(TAG,"TetherChangeReceiver - onReceive, action is "+ action);
8. if(action.equals(ConnectivityManager.ACTION_TETHER_STATE_CHANGED)){
9. // TODO - this should understand the interface types
10. ArrayList<String> available = intent.getStringArrayListExtra(
11. ConnectivityManager.EXTRA_AVAILABLE_TETHER);
12. ArrayList<String> active = intent.getStringArrayListExtra(
13. ConnectivityManager.EXTRA_ACTIVE_TETHER);
14. ArrayList<String> errored = intent.getStringArrayListExtra(
15. ConnectivityManager.EXTRA_ERRORED_TETHER);
17. /** M: for bug solving, ALPS00331223 */
18. mUsbUnTetherDone = intent.getBooleanExtra("UnTetherDone",false);
19. mUsbTetherDone = intent.getBooleanExtra("TetherDone",false);
20. mUsbTetherFail = intent.getBooleanExtra("TetherFail",false);
22. /// M: print log
23. Log.d(TAG,"mUsbUnTetherDone? :"+ mUsbUnTetherDone +" , mUsbTetherDonel? :"+
24. mUsbTetherDone +" , tether fail? :"+ mUsbTetherFail);
25. updateState(available.toArray(newString[available.size()]),
26. active.toArray(newString[active.size()]),
27. errored.toArray(newString[errored.size()]));
28. if(mWifiManager.getWifiApState()==WifiManager.WIFI_AP_STATE_DISABLED
29. && mRestartWifiApAfterConfigChange){
30. mRestartWifiApAfterConfigChange =false;
31. Log.d(TAG,"Restarting WifiAp due to prior config change.");
32. startTethering(TETHERING_WIFI);
33. }
34. }elseif(action.equals(WifiManager.WIFI_AP_STATE_CHANGED_ACTION)){
35. int state = intent.getIntExtra(WifiManager.EXTRA_WIFI_AP_STATE,0);
36. if(state ==WifiManager.WIFI_AP_STATE_DISABLED
37. && mRestartWifiApAfterConfigChange){
38. mRestartWifiApAfterConfigChange =false;
39. Log.d(TAG,"Restarting WifiAp due to prior config change.");
40. startTethering(TETHERING_WIFI);
41. }
42. }elseif(action.equals(Intent.ACTION_MEDIA_SHARED)){
43. mMassStorageActive =true;
44. updateState();
45. }elseif(action.equals(Intent.ACTION_MEDIA_UNSHARED)){
46. mMassStorageActive =false;
47. updateState();
48. /*此处就是 usb状态的监听部分*/
49. }elseif(action.equals(UsbManager.ACTION_USB_STATE)){
50. /*应该是活动usb连接状态，默认为false*/
51. mUsbConnected = intent.getBooleanExtra(UsbManager.USB_CONNECTED,false);
52. /// M: @{
53. mUsbConfigured = intent.getBooleanExtra(UsbManager.USB_CONFIGURED,false);
54. mUsbHwDisconnected = intent.getBooleanExtra("USB_HW_DISCONNECTED",false);
55. mIsPcKnowMe = intent.getBooleanExtra("USB_IS_PC_KNOW_ME",true);
56. /* 最后拔出usb时的log如下：
57. TetheringSettings: TetherChangeReceiver - ACTION_USB_STATE mUsbConnected: false, mUsbConfigured: false, mUsbHwDisconnected: true
58. */
59. Log.d(TAG,"TetherChangeReceiver - ACTION_USB_STATE mUsbConnected: "
60. + mUsbConnected +
61. ", mUsbConfigured: "+ mUsbConfigured +", mUsbHwDisconnected: "
62. + mUsbHwDisconnected);
63. /// @}
64. /*重点是updateState()方法来设置这2个perference 的enabled状态*/
65. updateState();
66. }elseif(action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)){
67. if(mBluetoothEnableForTether){
68. switch(intent
69. .getIntExtra(BluetoothAdapter.EXTRA_STATE,BluetoothAdapter.ERROR)){
70. caseBluetoothAdapter.STATE_ON:
71. startTethering(TETHERING_BLUETOOTH);
72. mBluetoothEnableForTether =false;
73. /// M: @{
74. BluetoothDun bluetoothDun = mTetherSettingsExt.BluetoothDunGetProxy();
75. if(bluetoothDun !=null){
76. bluetoothDun.setBluetoothTethering(true);
77. mBluetoothEnableForTether =false;
78. }
79. /// @}
80. break;
82. caseBluetoothAdapter.STATE_OFF:
83. caseBluetoothAdapter.ERROR:
84. mBluetoothEnableForTether =false;
85. break;
87. default:
88. // ignore transition states
89. }
90. }
91. updateState();
92. }
93. /// M: add
94. onReceiveExt(action, intent);
95. }
96. }

在这个监听中，通过ACTION_USB_STATE这个action来监听usb状态的改变，从它的定义可以知道：

1. publicstaticfinalString ACTION_USB_STATE =
2. "android.hardware.usb.action.USB_STATE";
3. /**
4. * Broadcast Action: A broadcast for USB port changes.
5. *
6. * This intent is sent when a USB port is added, removed, or changes state.
7. * <ul>
8. * <li> {@link #EXTRA_PORT} containing the {@link android.hardware.usb.UsbPort}
9. * for the port.
10. * <li> {@link #EXTRA_PORT_STATUS} containing the {@link android.hardware.usb.UsbPortStatus}
11. * for the port, or null if the port has been removed
12. * </ul>
13. *
14. * @hide
15. */

然后看看 updateState()方法，具体实现如下：

1. privatevoid updateState(){
2. /* */
3. String[] available = mCm.getTetherableIfaces();
4. String[] tethered = mCm.getTetheredIfaces();
5. String[] errored = mCm.getTetheringErroredIfaces();
6. updateState(available, tethered, errored);
7. }
8. privatevoid updateState(String[] available,String[] tethered,
9. String[] errored){
10. /// M: need put firstly @{
11. if(updateStateExt(available, tethered, errored)){
12. return;
13. }
14. // @}
15. updateUsbState(available, tethered, errored);
16. updateBluetoothState(available, tethered, errored);
17. /// M: resolve JE
18. if(!Utils.isMonkeyRunning()){
19. mTetherSettingsExt.updateIpv6Preference(mUsbTether, mBluetoothTether, mWifiManager);
20. }
21. // @}
22. }

在updateState方法中首先执行updateStateExt方法，该方法放回固定值false。？？有什么用呢

1. privateboolean updateStateExt(String[] available,String[] tethered,
2. String[] errored){
3. /*
4. TetheringSettings: =======> updateState - mUsbConnected: false, mUsbConfigured: false, mUsbHwDisconnected: true, checked: true, mUsbUnTetherDone: true, mUsbTetherDone: false, tetherfail: false, mIsPcKnowMe: true
5. */
6. Log.d(TAG,"=======> updateState - mUsbConnected: "+ mUsbConnected +
7. ", mUsbConfigured: "+ mUsbConfigured +", mUsbHwDisconnected: "+
8. mUsbHwDisconnected +", checked: "+ mUsbTether.isChecked()+
9. ", mUsbUnTetherDone: "+ mUsbUnTetherDone +", mUsbTetherDone: "+
10. mUsbTetherDone +", tetherfail: "+ mUsbTetherFail +
11. ", mIsPcKnowMe: "+ mIsPcKnowMe);
12. /** M: for bug solving, ALPS00331223 */
13. // turn on tethering case
14. if(mUsbTether.isChecked()){
15. /*
16. 进入if逻辑
17. */
18. if(mUsbConnected && mUsbConfigured &&!mUsbHwDisconnected){
19. if(mUsbTetherFail || mUsbTetherDone ||!mIsPcKnowMe){
20. mUsbTetherCheckEnable =true;
21. }
22. }else{
23. /* 将属性mUsbTetherCheckEnable置为false。？？？什么用？
24. */
25. mUsbTetherCheckEnable =false;
26. }
27. }else{// turn off tethering case or first launch case
28. if(mUsbConnected &&!mUsbHwDisconnected){
29. if(mUsbUnTetherDone || mUsbTetherFail){
30. mUsbTetherCheckEnable =true;
31. }
32. }else{
33. mUsbTetherCheckEnable =false;
34. }
35. }
36. returnfalse;
37. }

然后具体控制usb tethering type这个preference是否可用的逻辑在updateUsbState方法中，其代码如下：

1. privatevoid updateUsbState(String[] available,String[] tethered,
2. String[] errored){
3. /*控制usb tethering这个perfernece是否可用*/
4. boolean usbAvailable = mUsbConnected &&!mMassStorageActive;
5. int usbError =ConnectivityManager.TETHER_ERROR_NO_ERROR;
6. /**/
7. for(String s : available){
8. for(String regex : mUsbRegexs){
9. if(s.matches(regex)){
10. if(usbError ==ConnectivityManager.TETHER_ERROR_NO_ERROR){
11. usbError = mCm.getLastTetherError(s);
12. }
13. }
14. }
15. }
16. boolean usbTethered =false;
17. for(String s : tethered){
18. for(String regex : mUsbRegexs){
19. if(s.matches(regex)) usbTethered =true;
20. }
21. }
22. boolean usbErrored =false;
23. for(String s: errored){
24. for(String regex : mUsbRegexs){
25. if(s.matches(regex)) usbErrored =true;
26. }
27. }
29. // M: add for IPV4/IPV6 , must return the usbError
30. usbError = mTetherSettingsExt.getUSBErrorCode(available, tethered,
31. mUsbRegexs);
32. /* log如下：
33. TetheringSettings: updateUsbState - usbTethered : false usbErrored: false usbAvailable: false
34. */
35. Log.d(TAG,"updateUsbState - usbTethered : "+ usbTethered +" usbErrored: "+
36. usbErrored +" usbAvailable: "+ usbAvailable);
37. /*从log看 usbTethered : false 不走该逻辑*/
38. if(usbTethered){
39. /** M: Google original code removed to adapt to our feature
40. mUsbTether.setSummary(R.string.usb_tethering_active_subtext);
41. */
42. Log.d(TAG,"updateUsbState: usbTethered ! mUsbTether checkbox setEnabled & checked ");
43. mUsbTether.setEnabled(!mDataSaverEnabled);
44. mUsbTether.setChecked(true);
45. /// M: set usb tethering to false @{
46. finalString summary = getString(R.string.usb_tethering_active_subtext);
47. mTetherSettingsExt.updateUSBPrfSummary(mUsbTether, summary, usbTethered, usbAvailable);
48. mUsbTethering =false;
49. mTetherSettingsExt.updateUsbTypeListState(false);
50. Log.d(TAG,"updateUsbState - usbTethered - mUsbTetherCheckEnable: "
51. + mUsbTetherCheckEnable);
52. /// @}
53. /*从log看usbAvailable: false 也不走该逻辑*/
54. }elseif(usbAvailable){
55. if(usbError ==ConnectivityManager.TETHER_ERROR_NO_ERROR){
56. mUsbTether.setSummary(R.string.usb_tethering_available_subtext);
57. }else{
58. mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
59. }
60. mTetherSettingsExt.updateUSBPrfSummary(mUsbTether,null, usbTethered, usbAvailable);
61. if(mUsbTetherCheckEnable){
62. Log.d(TAG,"updateUsbState - mUsbTetherCheckEnable, "+
63. "mUsbTether checkbox setEnabled, and set unchecked ");
64. mUsbTether.setEnabled(!mDataSaverEnabled);
65. mUsbTether.setChecked(false);
66. /// M:
67. mUsbTethering =false;
68. mTetherSettingsExt.updateUsbTypeListState(true);
69. }
70. Log.d(TAG,"updateUsbState - usbAvailable - mUsbConfigured: "+ mUsbConfigured +
71. " mUsbTethering: "+ mUsbTethering +
72. " mUsbTetherCheckEnable: "+ mUsbTetherCheckEnable);
73. /*usbErrored: false 不进入该逻辑
74. */
75. }elseif(usbErrored){
76. mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
77. mUsbTether.setEnabled(false);
78. mUsbTether.setChecked(false);
79. /// M: set usb tethering to false
80. mUsbTethering =false;
81. /**/
82. }elseif(mMassStorageActive){
83. mUsbTether.setSummary(R.string.usb_tethering_storage_active_subtext);
84. mUsbTether.setEnabled(false);
85. mUsbTether.setChecked(false);
86. /// M: set usb tethering to false
87. mUsbTethering =false;
88. }else{
89. if(mUsbHwDisconnected ||(!mUsbHwDisconnected &&!mUsbConnected &&!mUsbConfigured)){
90. /*在打开usb tethering时强制拔出usb，并想要在此时设置usb tethering type为可操作(黑色state为true)
91. */
92. mUsbTether.setSummary(R.string.usb_tethering_unavailable_subtext);
93. mUsbTether.setEnabled(false);
94. mUsbTether.setChecked(false);
95. mUsbTethering =false;
96. }else{
97. /*
98. 用来更新usb state状态，如在连接usb时打开或者关闭usb tethering
99. */
100. /// M: update usb state @{
101. Log.d(TAG,"updateUsbState - else, "+
102. "mUsbTether checkbox setEnabled, and set unchecked ");
103. mUsbTether.setSummary(R.string.usb_tethering_available_subtext);
104. mUsbTether.setEnabled(true);
105. mUsbTether.setChecked(false);
106. mUsbTethering =false;
107. mTetherSettingsExt.updateUsbTypeListState(true);
108. /// @}
109. }
110. /*log如下：
111. TetheringSettings: updateUsbState- usbAvailable- mUsbHwDisconnected:true
112. */
113. Log.d(TAG,"updateUsbState- usbAvailable- mUsbHwDisconnected:"+ mUsbHwDisconnected);
114. }
115. }

从如下的log，可以看出在进入updateUsbState方法后的运行流程。

1. 06-0610:33:13.99011456135613 D TetheringSettings:=======> updateState - mUsbConnected:false, mUsbConfigured:false, mUsbHwDisconnected:true,checked:true, mUsbUnTetherDone:true, mUsbTetherDone:false, tetherfail:false, mIsPcKnowMe:true
2. 06-0610:33:13.99017956135613 D TetheringSettings: updateUsbState - usbTethered :false usbErrored:false usbAvailable:false
3. 06-0610:33:13.99137056135613 D TetheringSettings: updateUsbState- usbAvailable- mUsbHwDisconnected:true

usb tethering这个preference对应的点击监听器代码实现如下：

1. publicboolean onPreferenceTreeClick(Preference preference){
2. if(preference == mUsbTether){
3. if(!mUsbTethering){
4. /// M: update usb tethering @{
5. boolean newState = mUsbTether.isChecked();if((getResources().getBoolean(R.bool.def_usb_tethering_on_restraint_data_connect))){
6. WifiManager wifiManager =(WifiManager)getSystemService(Context.WIFI_SERVICE);
7. android.net.wifi.WifiInfo wifiInfo = wifiManager.getConnectionInfo();
8. if(mUsbTether.isChecked()){
9. if(!isNetworkConnected()&&!(wifiManager.isWifiEnabled()&&(null!= wifiInfo)&&(wifiInfo.getNetworkId()!=-1))){
10. initNetworkConnectDialog();
11. mUsbTether.setChecked(false);
12. returnfalse;
13. }
14. }
15. }
16. /*此处就是将usb tethering这个preference置为灰色的逻辑*/
17. mUsbTether.setEnabled(false);
18. /*此处就是将usb tethering type这个preference置为灰色的逻辑*/
19. mTetherSettingsExt.updateUsbTypeListState(false);
20. mUsbTethering =true;
21. mUsbTetherCheckEnable =false;
22. if(newState){
23. mUsbTetherDone =false;
24. }else{
25. mUsbUnTetherDone =false;
26. }
27. mUsbTetherFail =false;
28. Log.d(TAG,"onPreferenceTreeClick - setusbTethering("+ newState +
29. ") mUsbTethering: "+ mUsbTethering);
30. /// @}
31. if(mUsbTether.isChecked()){
32. showDatasetDialog();
33. startTethering(TETHERING_USB);
34. }else{
35. mCm.stopTethering(TETHERING_USB);
36. }
37. }else{
38. returntrue;
39. }
40. }elseif(preference == mBluetoothTether){
41. if(mBluetoothTether.isChecked()){
42. startTethering(TETHERING_BLUETOOTH);
43. }else{
44. mCm.stopTethering(TETHERING_BLUETOOTH);
45. /// M: set bluetooth tethering to false
46. mTetherSettingsExt.updateBtDunTether(false);
47. // No ACTION_TETHER_STATE_CHANGED is fired or bluetooth unless a device is
48. // connected. Need to update state manually.
49. updateState();
50. }
51. if(!Utils.isMonkeyRunning()){
52. mTetherSettingsExt.updateIpv6Preference(mUsbTether, mBluetoothTether, mWifiManager);
53. }
54. }elseif(preference == mCreateNetwork){
55. showDialog(DIALOG_AP_SETTINGS);
56. }
57. returnsuper.onPreferenceTreeClick(preference);
58. }

从上面代码可以看出，就是在点击usb tethering这个item时将usb tethering和usb tethering type preference变为灰色的，然后会通过发送广播重新将它自己变为黑色而并没有对usb tethering type这个preference对象进行操作，所以usb tethering type还是灰色，如果需要将它变成黑色，就需要添加新逻辑来操作。

而通过关闭usb tethering开关的逻辑来enable usb tethering type对象，主要是走的updateUsbState方法的如下部分：

1. }elseif(usbAvailable){
2. if(usbError ==ConnectivityManager.TETHER_ERROR_NO_ERROR){
3. mUsbTether.setSummary(R.string.usb_tethering_available_subtext);
4. }else{
5. mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
6. }
7. mTetherSettingsExt.updateUSBPrfSummary(mUsbTether,null, usbTethered, usbAvailable);
8. if(mUsbTetherCheckEnable){
9. Log.d(TAG,"updateUsbState - mUsbTetherCheckEnable, "+
10. "mUsbTether checkbox setEnabled, and set unchecked ");
11. mUsbTether.setEnabled(!mDataSaverEnabled);
12. mUsbTether.setChecked(false);
13. /// M:
14. mUsbTethering =false;
15. /*将usb tethering type对象enable*/
16. mTetherSettingsExt.updateUsbTypeListState(true);
17. }
18. Log.d(TAG,"updateUsbState - usbAvailable - mUsbConfigured: "+ mUsbConfigured +
19. " mUsbTethering: "+ mUsbTethering +
20. " mUsbTetherCheckEnable: "+ mUsbTetherCheckEnable);
21. }elseif(usbErrored){

3.soluution

根据上面的分析，在文件TetherSettings.java中的updateUsbState方法里调用该usb tethering type item对象的updateUsbTypeListState方法，具体修改如下所示：

1. /// M: set usb tethering to false
2. mUsbTethering =false;
3. }else{
4. Log.d(TAG,"mUsbHwDisconnected: "+ mUsbHwDisconnected +
5. " mUsbHwDisconnected: "+ mUsbHwDisconnected +
6. " mUsbConnected: "+ mUsbConnected+
7. " mUsbConfigured: "+mUsbConfigured);
8. if(mUsbHwDisconnected ||(!mUsbHwDisconnected &&!mUsbConnected &&!mUsbConfigured)){
9. mUsbTether.setSummary(R.string.usb_tethering_unavailable_subtext);
10. mUsbTether.setEnabled(false);
11. mUsbTether.setChecked(false);
12. /*add for enable the object of the usb Tether type when disconnect the MS to PC*/
13. mTetherSettingsExt.updateUsbTypeListState(true);
14. /*add for enable the object of the usb Tether type when disconnect the MS to PC */
15. mUsbTethering =false;
16. }else{
17. /// M: update usb state @{
18. Log.d(TAG,"updateUsbState - else, "+
19. "mUsbTether checkbox setEnabled, and set unchecked ");
20. mUsbTether.setSummary(R.string.usb_tethering_available_subtext);
21. mUsbTether.setEnabled(true);
22. mUsbTether.setChecked(false);
23. mUsbTethering =false;
24. mTetherSettingsExt.updateUsbTypeListState(true);
25. /// @}
26. }
27. Log.d(TAG,"updateUsbState- usbAvailable- mUsbHwDisconnected:"+ mUsbHwDisconnected);
28. }
29. }

4.summary

这个问题主要是需要找到该preference相关的监听，看时在什么地方有调用。对应第一个问题的描述，因为测试后一直没有复现，所以没有进行修改。而第二个问题成功复现，看代码应该是平台就这样设计的。其实在打开usb tethering时强制拔出usb情况，该usb tethering type一直是灰色对整个功能的影响不是很大，因为在下次插入usb时，通过usb状态广播，是会将该item置为enable的。但是也发现，在对手机旋转操作后，会调用onstarte方法来重新初始化当前界面，usb tethering type这个preference会被变为可用(黑色)，所以这也算一个小bug吧。因为整个行为都是由是否插入usb状态来决定该preference是否enable,具体修改是在广播接收器中,对usb状态监听的逻辑中加入mTetherSettingsExt.updateUsbTypeListState(true);，即在拔出usb时，将usb tethering type这个preferenc对象setEnabled置为true。