in com/android/server/wifi/WifiStateMachine.java [3819:4145]
public boolean processMessage(Message message) {
logStateAndMessage(message, this);
switch (message.what) {
case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: {
AsyncChannel ac = (AsyncChannel) message.obj;
if (ac == mWifiP2pChannel) {
if (message.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
p2pSendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION);
// since the p2p channel is connected, we should enable p2p if we are in
// connect mode. We may not be in connect mode yet, we may have just
// set the operational mode and started to set up for connect mode.
if (mOperationalMode == CONNECT_MODE) {
// This message will only be handled if we are in Connect mode.
// If we are not in connect mode yet, this will be dropped and the
// ConnectMode.enter method will call to enable p2p.
sendMessage(CMD_ENABLE_P2P);
}
} else {
// TODO: We should probably do some cleanup or attempt a retry
// b/34283611
loge("WifiP2pService connection failure, error=" + message.arg1);
}
} else {
loge("got HALF_CONNECTED for unknown channel");
}
break;
}
case AsyncChannel.CMD_CHANNEL_DISCONNECTED: {
AsyncChannel ac = (AsyncChannel) message.obj;
if (ac == mWifiP2pChannel) {
loge("WifiP2pService channel lost, message.arg1 =" + message.arg1);
//TODO: Re-establish connection to state machine after a delay (b/34283611)
// mWifiP2pChannel.connect(mContext, getHandler(),
// mWifiP2pManager.getMessenger());
}
break;
}
case CMD_BLUETOOTH_ADAPTER_STATE_CHANGE:
mBluetoothConnectionActive = (message.arg1 !=
BluetoothAdapter.STATE_DISCONNECTED);
break;
case CMD_ENABLE_NETWORK:
boolean disableOthers = message.arg2 == 1;
int netId = message.arg1;
boolean ok = mWifiConfigManager.enableNetwork(
netId, disableOthers, message.sendingUid);
if (!ok) {
messageHandlingStatus = MESSAGE_HANDLING_STATUS_FAIL;
}
replyToMessage(message, message.what, ok ? SUCCESS : FAILURE);
break;
case CMD_ADD_OR_UPDATE_NETWORK:
WifiConfiguration config = (WifiConfiguration) message.obj;
NetworkUpdateResult result =
mWifiConfigManager.addOrUpdateNetwork(config, message.sendingUid);
if (!result.isSuccess()) {
messageHandlingStatus = MESSAGE_HANDLING_STATUS_FAIL;
}
replyToMessage(message, message.what, result.getNetworkId());
break;
case CMD_SAVE_CONFIG:
replyToMessage(message, message.what, FAILURE);
break;
case CMD_REMOVE_NETWORK:
deleteNetworkConfigAndSendReply(message, false);
break;
case CMD_GET_CONFIGURED_NETWORKS:
replyToMessage(message, message.what, mWifiConfigManager.getSavedNetworks());
break;
case CMD_GET_PRIVILEGED_CONFIGURED_NETWORKS:
replyToMessage(message, message.what,
mWifiConfigManager.getConfiguredNetworksWithPasswords());
break;
case CMD_ENABLE_RSSI_POLL:
mEnableRssiPolling = (message.arg1 == 1);
break;
case CMD_SET_HIGH_PERF_MODE:
if (message.arg1 == 1) {
setSuspendOptimizations(SUSPEND_DUE_TO_HIGH_PERF, false);
} else {
setSuspendOptimizations(SUSPEND_DUE_TO_HIGH_PERF, true);
}
break;
case CMD_INITIALIZE:
ok = mWifiNative.initializeVendorHal(mVendorHalDeathRecipient);
replyToMessage(message, message.what, ok ? SUCCESS : FAILURE);
break;
case CMD_BOOT_COMPLETED:
// get other services that we need to manage
getAdditionalWifiServiceInterfaces();
if (!mWifiConfigManager.loadFromStore()) {
Log.e(TAG, "Failed to load from config store");
}
maybeRegisterNetworkFactory();
maybeRegisterPhoneListener();
break;
case CMD_SCREEN_STATE_CHANGED:
handleScreenStateChanged(message.arg1 != 0);
break;
/* Discard */
case CMD_START_SCAN:
messageHandlingStatus = MESSAGE_HANDLING_STATUS_DISCARD;
break;
case CMD_START_SUPPLICANT:
case CMD_STOP_SUPPLICANT:
case CMD_DRIVER_START_TIMED_OUT:
case CMD_START_AP:
case CMD_START_AP_FAILURE:
case CMD_STOP_AP:
case CMD_AP_STOPPED:
case CMD_DISCONNECT:
case CMD_RECONNECT:
case CMD_REASSOCIATE:
case CMD_RELOAD_TLS_AND_RECONNECT:
case WifiMonitor.SUP_CONNECTION_EVENT:
case WifiMonitor.SUP_DISCONNECTION_EVENT:
case WifiMonitor.NETWORK_CONNECTION_EVENT:
case WifiMonitor.NETWORK_DISCONNECTION_EVENT:
case WifiMonitor.SCAN_RESULTS_EVENT:
case WifiMonitor.SCAN_FAILED_EVENT:
case WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT:
case WifiMonitor.AUTHENTICATION_FAILURE_EVENT:
case WifiMonitor.ASSOCIATION_REJECTION_EVENT:
case WifiMonitor.WPS_OVERLAP_EVENT:
case CMD_SET_OPERATIONAL_MODE:
case CMD_RSSI_POLL:
case DhcpClient.CMD_PRE_DHCP_ACTION:
case DhcpClient.CMD_PRE_DHCP_ACTION_COMPLETE:
case DhcpClient.CMD_POST_DHCP_ACTION:
case CMD_NO_NETWORKS_PERIODIC_SCAN:
case CMD_ENABLE_P2P:
case CMD_DISABLE_P2P_RSP:
case WifiMonitor.SUP_REQUEST_IDENTITY:
case CMD_TEST_NETWORK_DISCONNECT:
case WifiMonitor.SUP_REQUEST_SIM_AUTH:
case CMD_TARGET_BSSID:
case CMD_START_CONNECT:
case CMD_START_ROAM:
case CMD_ASSOCIATED_BSSID:
case CMD_UNWANTED_NETWORK:
case CMD_DISCONNECTING_WATCHDOG_TIMER:
case CMD_ROAM_WATCHDOG_TIMER:
case CMD_DISABLE_P2P_WATCHDOG_TIMER:
case CMD_DISABLE_EPHEMERAL_NETWORK:
case CMD_SELECT_TX_POWER_SCENARIO:
messageHandlingStatus = MESSAGE_HANDLING_STATUS_DISCARD;
break;
case CMD_SET_SUSPEND_OPT_ENABLED:
if (message.arg1 == 1) {
if (message.arg2 == 1) {
mSuspendWakeLock.release();
}
setSuspendOptimizations(SUSPEND_DUE_TO_SCREEN, true);
} else {
setSuspendOptimizations(SUSPEND_DUE_TO_SCREEN, false);
}
break;
case WifiManager.CONNECT_NETWORK:
replyToMessage(message, WifiManager.CONNECT_NETWORK_FAILED,
WifiManager.BUSY);
break;
case WifiManager.FORGET_NETWORK:
deleteNetworkConfigAndSendReply(message, true);
break;
case WifiManager.SAVE_NETWORK:
saveNetworkConfigAndSendReply(message);
break;
case WifiManager.START_WPS:
replyToMessage(message, WifiManager.WPS_FAILED,
WifiManager.BUSY);
break;
case WifiManager.CANCEL_WPS:
replyToMessage(message, WifiManager.CANCEL_WPS_FAILED,
WifiManager.BUSY);
break;
case WifiManager.DISABLE_NETWORK:
replyToMessage(message, WifiManager.DISABLE_NETWORK_FAILED,
WifiManager.BUSY);
break;
case WifiManager.RSSI_PKTCNT_FETCH:
replyToMessage(message, WifiManager.RSSI_PKTCNT_FETCH_FAILED,
WifiManager.BUSY);
break;
case CMD_GET_SUPPORTED_FEATURES:
int featureSet = mWifiNative.getSupportedFeatureSet();
replyToMessage(message, message.what, featureSet);
break;
case CMD_FIRMWARE_ALERT:
if (mWifiDiagnostics != null) {
byte[] buffer = (byte[])message.obj;
int alertReason = message.arg1;
mWifiDiagnostics.captureAlertData(alertReason, buffer);
mWifiMetrics.incrementAlertReasonCount(alertReason);
}
break;
case CMD_GET_LINK_LAYER_STATS:
// Not supported hence reply with error message
replyToMessage(message, message.what, null);
break;
case WifiP2pServiceImpl.P2P_CONNECTION_CHANGED:
NetworkInfo info = (NetworkInfo) message.obj;
mP2pConnected.set(info.isConnected());
break;
case WifiP2pServiceImpl.DISCONNECT_WIFI_REQUEST:
mTemporarilyDisconnectWifi = (message.arg1 == 1);
replyToMessage(message, WifiP2pServiceImpl.DISCONNECT_WIFI_RESPONSE);
break;
/* Link configuration (IP address, DNS, ...) changes notified via netlink */
case CMD_UPDATE_LINKPROPERTIES:
updateLinkProperties((LinkProperties) message.obj);
break;
case CMD_GET_MATCHING_CONFIG:
replyToMessage(message, message.what);
break;
case CMD_GET_MATCHING_OSU_PROVIDERS:
replyToMessage(message, message.what, new ArrayList<OsuProvider>());
break;
case CMD_IP_CONFIGURATION_SUCCESSFUL:
case CMD_IP_CONFIGURATION_LOST:
case CMD_IP_REACHABILITY_LOST:
messageHandlingStatus = MESSAGE_HANDLING_STATUS_DISCARD;
break;
case CMD_GET_CONNECTION_STATISTICS:
replyToMessage(message, message.what, mWifiConnectionStatistics);
break;
case CMD_REMOVE_APP_CONFIGURATIONS:
deferMessage(message);
break;
case CMD_REMOVE_USER_CONFIGURATIONS:
deferMessage(message);
break;
case CMD_START_IP_PACKET_OFFLOAD:
if (mNetworkAgent != null) mNetworkAgent.onPacketKeepaliveEvent(
message.arg1,
ConnectivityManager.PacketKeepalive.ERROR_INVALID_NETWORK);
break;
case CMD_STOP_IP_PACKET_OFFLOAD:
if (mNetworkAgent != null) mNetworkAgent.onPacketKeepaliveEvent(
message.arg1,
ConnectivityManager.PacketKeepalive.ERROR_INVALID_NETWORK);
break;
case CMD_START_RSSI_MONITORING_OFFLOAD:
messageHandlingStatus = MESSAGE_HANDLING_STATUS_DISCARD;
break;
case CMD_STOP_RSSI_MONITORING_OFFLOAD:
messageHandlingStatus = MESSAGE_HANDLING_STATUS_DISCARD;
break;
case CMD_USER_SWITCH:
Set<Integer> removedNetworkIds =
mWifiConfigManager.handleUserSwitch(message.arg1);
if (removedNetworkIds.contains(mTargetNetworkId) ||
removedNetworkIds.contains(mLastNetworkId)) {
// Disconnect and let autojoin reselect a new network
sendMessage(CMD_DISCONNECT);
}
break;
case CMD_USER_UNLOCK:
mWifiConfigManager.handleUserUnlock(message.arg1);
break;
case CMD_USER_STOP:
mWifiConfigManager.handleUserStop(message.arg1);
break;
case CMD_QUERY_OSU_ICON:
case CMD_MATCH_PROVIDER_NETWORK:
/* reply with arg1 = 0 - it returns API failure to the calling app
* (message.what is not looked at)
*/
replyToMessage(message, message.what);
break;
case CMD_ADD_OR_UPDATE_PASSPOINT_CONFIG:
int addResult = mPasspointManager.addOrUpdateProvider(
(PasspointConfiguration) message.obj, message.arg1)
? SUCCESS : FAILURE;
replyToMessage(message, message.what, addResult);
break;
case CMD_REMOVE_PASSPOINT_CONFIG:
int removeResult = mPasspointManager.removeProvider(
(String) message.obj) ? SUCCESS : FAILURE;
replyToMessage(message, message.what, removeResult);
break;
case CMD_GET_PASSPOINT_CONFIGS:
replyToMessage(message, message.what, mPasspointManager.getProviderConfigs());
break;
case CMD_RESET_SIM_NETWORKS:
/* Defer this message until supplicant is started. */
messageHandlingStatus = MESSAGE_HANDLING_STATUS_DEFERRED;
deferMessage(message);
break;
case CMD_INSTALL_PACKET_FILTER:
mWifiNative.installPacketFilter((byte[]) message.obj);
break;
case CMD_SET_FALLBACK_PACKET_FILTERING:
if ((boolean) message.obj) {
mWifiNative.startFilteringMulticastV4Packets();
} else {
mWifiNative.stopFilteringMulticastV4Packets();
}
break;
case CMD_CLIENT_INTERFACE_BINDER_DEATH:
Log.e(TAG, "wificond died unexpectedly. Triggering recovery");
mWifiMetrics.incrementNumWificondCrashes();
mWifiDiagnostics.captureBugReportData(
WifiDiagnostics.REPORT_REASON_WIFICOND_CRASH);
mWifiInjector.getSelfRecovery().trigger(SelfRecovery.REASON_WIFICOND_CRASH);
break;
case CMD_VENDOR_HAL_HWBINDER_DEATH:
Log.e(TAG, "Vendor HAL died unexpectedly. Triggering recovery");
mWifiMetrics.incrementNumHalCrashes();
mWifiDiagnostics.captureBugReportData(WifiDiagnostics.REPORT_REASON_HAL_CRASH);
mWifiInjector.getSelfRecovery().trigger(SelfRecovery.REASON_HAL_CRASH);
break;
case CMD_DIAGS_CONNECT_TIMEOUT:
mWifiDiagnostics.reportConnectionEvent(
(Long) message.obj, BaseWifiDiagnostics.CONNECTION_EVENT_FAILED);
break;
case 0:
// We want to notice any empty messages (with what == 0) that might crop up.
// For example, we may have recycled a message sent to multiple handlers.
Log.wtf(TAG, "Error! empty message encountered");
break;
default:
loge("Error! unhandled message" + message);
break;
}
return HANDLED;
}