| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.net.wifi.p2p; |
| |
| import android.app.AlertDialog; |
| import android.app.Notification; |
| import android.app.NotificationManager; |
| import android.app.PendingIntent; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.DialogInterface.OnClickListener; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.pm.PackageManager; |
| import android.content.res.Resources; |
| import android.net.IConnectivityManager; |
| import android.net.ConnectivityManager; |
| import android.net.DhcpInfoInternal; |
| import android.net.DhcpStateMachine; |
| import android.net.InterfaceConfiguration; |
| import android.net.LinkAddress; |
| import android.net.LinkProperties; |
| import android.net.NetworkInfo; |
| import android.net.NetworkUtils; |
| import android.net.wifi.WifiManager; |
| import android.net.wifi.WifiMonitor; |
| import android.net.wifi.WifiNative; |
| import android.net.wifi.WifiStateMachine; |
| import android.net.wifi.WpsInfo; |
| import android.os.Binder; |
| import android.os.IBinder; |
| import android.os.INetworkManagementService; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.Message; |
| import android.os.Messenger; |
| import android.os.ServiceManager; |
| import android.os.SystemProperties; |
| import android.provider.Settings; |
| import android.util.Slog; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.view.WindowManager; |
| import android.widget.EditText; |
| |
| import com.android.internal.R; |
| import com.android.internal.telephony.TelephonyIntents; |
| import com.android.internal.util.AsyncChannel; |
| import com.android.internal.util.Protocol; |
| import com.android.internal.util.State; |
| import com.android.internal.util.StateMachine; |
| |
| import java.io.FileDescriptor; |
| import java.io.PrintWriter; |
| import java.util.Collection; |
| |
| /** |
| * WifiP2pService inclues a state machine to perform Wi-Fi p2p operations. Applications |
| * communicate with this service to issue device discovery and connectivity requests |
| * through the WifiP2pManager interface. The state machine communicates with the wifi |
| * driver through wpa_supplicant and handles the event responses through WifiMonitor. |
| * |
| * Note that the term Wifi when used without a p2p suffix refers to the client mode |
| * of Wifi operation |
| * @hide |
| */ |
| public class WifiP2pService extends IWifiP2pManager.Stub { |
| private static final String TAG = "WifiP2pService"; |
| private static final boolean DBG = false; |
| private static final String NETWORKTYPE = "WIFI_P2P"; |
| |
| private Context mContext; |
| private String mInterface; |
| private Notification mNotification; |
| |
| INetworkManagementService mNwService; |
| private DhcpStateMachine mDhcpStateMachine; |
| |
| //Tracked to notify the user about wifi client/hotspot being shut down |
| //during p2p bring up |
| private int mWifiState = WifiManager.WIFI_STATE_DISABLED; |
| private int mWifiApState = WifiManager.WIFI_AP_STATE_DISABLED; |
| |
| private P2pStateMachine mP2pStateMachine; |
| private AsyncChannel mReplyChannel = new AsyncChannel(); |
| private AsyncChannel mWifiChannel; |
| |
| /* Two minutes comes from the wpa_supplicant setting */ |
| private static final int GROUP_NEGOTIATION_WAIT_TIME_MS = 120 * 1000; |
| private static int mGroupNegotiationTimeoutIndex = 0; |
| |
| /** |
| * Delay between restarts upon failure to setup connection with supplicant |
| */ |
| private static final int P2P_RESTART_INTERVAL_MSECS = 5000; |
| |
| /** |
| * Number of times we attempt to restart p2p |
| */ |
| private static final int P2P_RESTART_TRIES = 5; |
| |
| private int mP2pRestartCount = 0; |
| |
| private static final int BASE = Protocol.BASE_WIFI_P2P_SERVICE; |
| |
| /* Message sent to WifiStateMachine to indicate p2p enable is pending */ |
| public static final int P2P_ENABLE_PENDING = BASE + 1; |
| /* Message sent to WifiStateMachine to indicate Wi-Fi client/hotspot operation can proceed */ |
| public static final int WIFI_ENABLE_PROCEED = BASE + 2; |
| |
| /* Delayed message to timeout of group negotiation */ |
| public static final int GROUP_NEGOTIATION_TIMED_OUT = BASE + 3; |
| |
| /* User accepted to disable Wi-Fi in order to enable p2p */ |
| private static final int WIFI_DISABLE_USER_ACCEPT = BASE + 4; |
| /* User rejected to disable Wi-Fi in order to enable p2p */ |
| private static final int WIFI_DISABLE_USER_REJECT = BASE + 5; |
| |
| /* User accepted a group negotiation request */ |
| private static final int GROUP_NEGOTIATION_USER_ACCEPT = BASE + 6; |
| /* User rejected a group negotiation request */ |
| private static final int GROUP_NEGOTIATION_USER_REJECT = BASE + 7; |
| |
| /* User accepted a group invitation request */ |
| private static final int GROUP_INVITATION_USER_ACCEPT = BASE + 8; |
| /* User rejected a group invitation request */ |
| private static final int GROUP_INVITATION_USER_REJECT = BASE + 9; |
| |
| /* Airplane mode changed */ |
| private static final int AIRPLANE_MODE_CHANGED = BASE + 10; |
| /* Emergency callback mode */ |
| private static final int EMERGENCY_CALLBACK_MODE = BASE + 11; |
| private static final int WPS_PBC = BASE + 12; |
| private static final int WPS_PIN = BASE + 13; |
| |
| private final boolean mP2pSupported; |
| |
| private WifiP2pDevice mThisDevice = new WifiP2pDevice(); |
| |
| /* When a group has been explicitly created by an app, we persist the group |
| * even after all clients have been disconnected until an explicit remove |
| * is invoked */ |
| private boolean mPersistGroup; |
| |
| private NetworkInfo mNetworkInfo; |
| |
| /* Is chosen as a unique range to avoid conflict with |
| the range defined in Tethering.java */ |
| private static final String[] DHCP_RANGE = {"192.168.49.2", "192.168.49.254"}; |
| private static final String SERVER_ADDRESS = "192.168.49.1"; |
| |
| public WifiP2pService(Context context) { |
| mContext = context; |
| |
| mInterface = SystemProperties.get("wifi.interface", "wlan0"); |
| mNetworkInfo = new NetworkInfo(ConnectivityManager.TYPE_WIFI_P2P, 0, NETWORKTYPE, ""); |
| |
| mP2pSupported = mContext.getPackageManager().hasSystemFeature( |
| PackageManager.FEATURE_WIFI_DIRECT); |
| |
| mThisDevice.primaryDeviceType = mContext.getResources().getString( |
| com.android.internal.R.string.config_wifi_p2p_device_type); |
| mThisDevice.deviceName = getDefaultDeviceName(); |
| |
| mP2pStateMachine = new P2pStateMachine(TAG, mP2pSupported); |
| mP2pStateMachine.start(); |
| |
| // broadcasts |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION); |
| filter.addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED); |
| filter.addAction(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED); |
| filter.addAction(WifiManager.WIFI_AP_STATE_CHANGED_ACTION); |
| mContext.registerReceiver(new WifiStateReceiver(), filter); |
| |
| } |
| |
| public void connectivityServiceReady() { |
| IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE); |
| mNwService = INetworkManagementService.Stub.asInterface(b); |
| } |
| |
| private class WifiStateReceiver extends BroadcastReceiver { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| String action = intent.getAction(); |
| if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) { |
| mWifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, |
| WifiManager.WIFI_STATE_DISABLED); |
| } else if (action.equals(WifiManager.WIFI_AP_STATE_CHANGED_ACTION)) { |
| mWifiApState = intent.getIntExtra(WifiManager.EXTRA_WIFI_AP_STATE, |
| WifiManager.WIFI_AP_STATE_DISABLED); |
| } else if (action.equals(Intent.ACTION_AIRPLANE_MODE_CHANGED)) { |
| mP2pStateMachine.sendMessage(AIRPLANE_MODE_CHANGED); |
| } else if (action.equals(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED)) { |
| if (intent.getBooleanExtra("phoneinECMState", false) == true) { |
| mP2pStateMachine.sendMessage(EMERGENCY_CALLBACK_MODE); |
| } |
| } |
| } |
| } |
| |
| private void enforceAccessPermission() { |
| mContext.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_WIFI_STATE, |
| "WifiP2pService"); |
| } |
| |
| private void enforceChangePermission() { |
| mContext.enforceCallingOrSelfPermission(android.Manifest.permission.CHANGE_WIFI_STATE, |
| "WifiP2pService"); |
| } |
| |
| /* We use the 4 digits of the ANDROID_ID to have a friendly |
| * default that has low likelihood of collision with a peer */ |
| private String getDefaultDeviceName() { |
| String id = Settings.Secure.getString(mContext.getContentResolver(), |
| Settings.Secure.ANDROID_ID); |
| return "Android_" + id.substring(0,4); |
| } |
| |
| /** |
| * Get a reference to handler. This is used by a client to establish |
| * an AsyncChannel communication with WifiP2pService |
| */ |
| public Messenger getMessenger() { |
| enforceAccessPermission(); |
| enforceChangePermission(); |
| return new Messenger(mP2pStateMachine.getHandler()); |
| } |
| |
| @Override |
| protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { |
| if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) |
| != PackageManager.PERMISSION_GRANTED) { |
| pw.println("Permission Denial: can't dump WifiP2pService from from pid=" |
| + Binder.getCallingPid() |
| + ", uid=" + Binder.getCallingUid()); |
| return; |
| } |
| } |
| |
| |
| /** |
| * Handles interaction with WifiStateMachine |
| */ |
| private class P2pStateMachine extends StateMachine { |
| |
| private DefaultState mDefaultState = new DefaultState(); |
| private P2pNotSupportedState mP2pNotSupportedState = new P2pNotSupportedState(); |
| private P2pDisablingState mP2pDisablingState = new P2pDisablingState(); |
| private P2pDisabledState mP2pDisabledState = new P2pDisabledState(); |
| private WaitForUserActionState mWaitForUserActionState = new WaitForUserActionState(); |
| private WaitForWifiDisableState mWaitForWifiDisableState = new WaitForWifiDisableState(); |
| private P2pEnablingState mP2pEnablingState = new P2pEnablingState(); |
| private P2pEnabledState mP2pEnabledState = new P2pEnabledState(); |
| // Inactive is when p2p is enabled with no connectivity |
| private InactiveState mInactiveState = new InactiveState(); |
| private UserAuthorizingGroupNegotiationState mUserAuthorizingGroupNegotiationState |
| = new UserAuthorizingGroupNegotiationState(); |
| private UserAuthorizingGroupInvitationState mUserAuthorizingGroupInvitationState |
| = new UserAuthorizingGroupInvitationState(); |
| private GroupNegotiationState mGroupNegotiationState = new GroupNegotiationState(); |
| private GroupCreatedState mGroupCreatedState = new GroupCreatedState(); |
| |
| private WifiMonitor mWifiMonitor = new WifiMonitor(this); |
| |
| private WifiP2pDeviceList mPeers = new WifiP2pDeviceList(); |
| private WifiP2pInfo mWifiP2pInfo = new WifiP2pInfo(); |
| private WifiP2pGroup mGroup; |
| |
| // Saved WifiP2pConfig from GO negotiation request |
| private WifiP2pConfig mSavedGoNegotiationConfig; |
| |
| // Saved WifiP2pConfig from connect request |
| private WifiP2pConfig mSavedConnectConfig; |
| |
| // Saved WifiP2pGroup from invitation request |
| private WifiP2pGroup mSavedP2pGroup; |
| |
| P2pStateMachine(String name, boolean p2pSupported) { |
| super(name); |
| |
| addState(mDefaultState); |
| addState(mP2pNotSupportedState, mDefaultState); |
| addState(mP2pDisablingState, mDefaultState); |
| addState(mP2pDisabledState, mDefaultState); |
| addState(mWaitForUserActionState, mP2pDisabledState); |
| addState(mWaitForWifiDisableState, mP2pDisabledState); |
| addState(mP2pEnablingState, mDefaultState); |
| addState(mP2pEnabledState, mDefaultState); |
| addState(mInactiveState, mP2pEnabledState); |
| addState(mUserAuthorizingGroupNegotiationState, mInactiveState); |
| addState(mUserAuthorizingGroupInvitationState, mInactiveState); |
| addState(mGroupNegotiationState, mP2pEnabledState); |
| addState(mGroupCreatedState, mP2pEnabledState); |
| |
| if (p2pSupported) { |
| setInitialState(mP2pDisabledState); |
| } else { |
| setInitialState(mP2pNotSupportedState); |
| } |
| } |
| |
| class DefaultState extends State { |
| @Override |
| public boolean processMessage(Message message) { |
| if (DBG) logd(getName() + message.toString()); |
| switch (message.what) { |
| case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: |
| if (message.arg1 == AsyncChannel.STATUS_SUCCESSFUL) { |
| if (DBG) logd("Full connection with WifiStateMachine established"); |
| mWifiChannel = (AsyncChannel) message.obj; |
| } else { |
| loge("Full connection failure, error = " + message.arg1); |
| mWifiChannel = null; |
| } |
| break; |
| |
| case AsyncChannel.CMD_CHANNEL_DISCONNECTED: |
| if (message.arg1 == AsyncChannel.STATUS_SEND_UNSUCCESSFUL) { |
| loge("Send failed, client connection lost"); |
| } else { |
| loge("Client connection lost with reason: " + message.arg1); |
| } |
| mWifiChannel = null; |
| break; |
| |
| case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: |
| AsyncChannel ac = new AsyncChannel(); |
| ac.connect(mContext, getHandler(), message.replyTo); |
| break; |
| case WifiStateMachine.WIFI_ENABLE_PENDING: |
| // Disable p2p operation before we can respond |
| sendMessage(WifiP2pManager.DISABLE_P2P); |
| deferMessage(message); |
| break; |
| case WifiP2pManager.ENABLE_P2P: |
| replyToMessage(message, WifiP2pManager.ENABLE_P2P_FAILED, |
| WifiP2pManager.BUSY); |
| break; |
| case WifiP2pManager.DISABLE_P2P: |
| replyToMessage(message, WifiP2pManager.DISABLE_P2P_FAILED, |
| WifiP2pManager.BUSY); |
| break; |
| case WifiP2pManager.DISCOVER_PEERS: |
| replyToMessage(message, WifiP2pManager.DISCOVER_PEERS_FAILED, |
| WifiP2pManager.BUSY); |
| break; |
| case WifiP2pManager.CONNECT: |
| replyToMessage(message, WifiP2pManager.CONNECT_FAILED, |
| WifiP2pManager.BUSY); |
| break; |
| case WifiP2pManager.CANCEL_CONNECT: |
| replyToMessage(message, WifiP2pManager.CANCEL_CONNECT_FAILED, |
| WifiP2pManager.BUSY); |
| break; |
| case WifiP2pManager.CREATE_GROUP: |
| replyToMessage(message, WifiP2pManager.CREATE_GROUP_FAILED, |
| WifiP2pManager.BUSY); |
| break; |
| case WifiP2pManager.REMOVE_GROUP: |
| replyToMessage(message, WifiP2pManager.REMOVE_GROUP_FAILED, |
| WifiP2pManager.BUSY); |
| break; |
| case WifiP2pManager.REQUEST_PEERS: |
| replyToMessage(message, WifiP2pManager.RESPONSE_PEERS, mPeers); |
| break; |
| case WifiP2pManager.REQUEST_CONNECTION_INFO: |
| replyToMessage(message, WifiP2pManager.RESPONSE_CONNECTION_INFO, mWifiP2pInfo); |
| break; |
| case WifiP2pManager.REQUEST_GROUP_INFO: |
| replyToMessage(message, WifiP2pManager.RESPONSE_GROUP_INFO, mGroup); |
| break; |
| case AIRPLANE_MODE_CHANGED: |
| if (isAirplaneModeOn()) sendMessage(WifiP2pManager.DISABLE_P2P); |
| break; |
| case EMERGENCY_CALLBACK_MODE: |
| sendMessage(WifiP2pManager.DISABLE_P2P); |
| break; |
| // Ignore |
| case WIFI_DISABLE_USER_ACCEPT: |
| case WIFI_DISABLE_USER_REJECT: |
| case GROUP_NEGOTIATION_USER_ACCEPT: |
| case GROUP_NEGOTIATION_USER_REJECT: |
| case GROUP_INVITATION_USER_ACCEPT: |
| case GROUP_INVITATION_USER_REJECT: |
| case GROUP_NEGOTIATION_TIMED_OUT: |
| break; |
| default: |
| loge("Unhandled message " + message); |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class P2pNotSupportedState extends State { |
| @Override |
| public boolean processMessage(Message message) { |
| switch (message.what) { |
| // Allow Wi-Fi to proceed |
| case WifiStateMachine.WIFI_ENABLE_PENDING: |
| replyToMessage(message, WIFI_ENABLE_PROCEED); |
| break; |
| case WifiP2pManager.ENABLE_P2P: |
| replyToMessage(message, WifiP2pManager.ENABLE_P2P_FAILED, |
| WifiP2pManager.P2P_UNSUPPORTED); |
| break; |
| case WifiP2pManager.DISABLE_P2P: |
| replyToMessage(message, WifiP2pManager.DISABLE_P2P_FAILED, |
| WifiP2pManager.P2P_UNSUPPORTED); |
| break; |
| case WifiP2pManager.DISCOVER_PEERS: |
| replyToMessage(message, WifiP2pManager.DISCOVER_PEERS_FAILED, |
| WifiP2pManager.P2P_UNSUPPORTED); |
| break; |
| case WifiP2pManager.CONNECT: |
| replyToMessage(message, WifiP2pManager.CONNECT_FAILED, |
| WifiP2pManager.P2P_UNSUPPORTED); |
| break; |
| case WifiP2pManager.CANCEL_CONNECT: |
| replyToMessage(message, WifiP2pManager.CANCEL_CONNECT_FAILED, |
| WifiP2pManager.P2P_UNSUPPORTED); |
| break; |
| case WifiP2pManager.CREATE_GROUP: |
| replyToMessage(message, WifiP2pManager.CREATE_GROUP_FAILED, |
| WifiP2pManager.P2P_UNSUPPORTED); |
| break; |
| case WifiP2pManager.REMOVE_GROUP: |
| replyToMessage(message, WifiP2pManager.REMOVE_GROUP_FAILED, |
| WifiP2pManager.P2P_UNSUPPORTED); |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class P2pDisablingState extends State { |
| @Override |
| public void enter() { |
| if (DBG) logd(getName()); |
| logd("stopping supplicant"); |
| if (!WifiNative.stopSupplicant()) { |
| loge("Failed to stop supplicant, issue kill"); |
| WifiNative.killSupplicant(); |
| } |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| if (DBG) logd(getName() + message.toString()); |
| switch (message.what) { |
| case WifiMonitor.SUP_DISCONNECTION_EVENT: |
| logd("Supplicant connection lost"); |
| WifiNative.closeSupplicantConnection(); |
| transitionTo(mP2pDisabledState); |
| break; |
| case WifiP2pManager.ENABLE_P2P: |
| case WifiP2pManager.DISABLE_P2P: |
| deferMessage(message); |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| |
| class P2pDisabledState extends State { |
| @Override |
| public void enter() { |
| if (DBG) logd(getName()); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| if (DBG) logd(getName() + message.toString()); |
| switch (message.what) { |
| case WifiP2pManager.ENABLE_P2P: |
| OnClickListener listener = new OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| if (which == DialogInterface.BUTTON_POSITIVE) { |
| sendMessage(WIFI_DISABLE_USER_ACCEPT); |
| } else { |
| sendMessage(WIFI_DISABLE_USER_REJECT); |
| } |
| } |
| }; |
| |
| // Show a user request dialog if we know Wi-Fi client/hotspot is in operation |
| if (mWifiState != WifiManager.WIFI_STATE_DISABLED || |
| mWifiApState != WifiManager.WIFI_AP_STATE_DISABLED) { |
| Resources r = Resources.getSystem(); |
| AlertDialog dialog = new AlertDialog.Builder(mContext) |
| .setTitle(r.getString(R.string.wifi_p2p_dialog_title)) |
| .setMessage(r.getString(R.string.wifi_p2p_turnon_message)) |
| .setPositiveButton(r.getString(R.string.ok), listener) |
| .setNegativeButton(r.getString(R.string.cancel), listener) |
| .create(); |
| dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); |
| dialog.show(); |
| transitionTo(mWaitForUserActionState); |
| } else { |
| mWifiChannel.sendMessage(P2P_ENABLE_PENDING); |
| transitionTo(mWaitForWifiDisableState); |
| } |
| replyToMessage(message, WifiP2pManager.ENABLE_P2P_SUCCEEDED); |
| break; |
| case WifiP2pManager.DISABLE_P2P: |
| replyToMessage(message, WifiP2pManager.DISABLE_P2P_SUCCEEDED); |
| break; |
| case WifiStateMachine.WIFI_ENABLE_PENDING: |
| replyToMessage(message, WIFI_ENABLE_PROCEED); |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class WaitForUserActionState extends State { |
| @Override |
| public void enter() { |
| if (DBG) logd(getName()); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| if (DBG) logd(getName() + message.toString()); |
| switch (message.what) { |
| case WIFI_DISABLE_USER_ACCEPT: |
| mWifiChannel.sendMessage(P2P_ENABLE_PENDING); |
| transitionTo(mWaitForWifiDisableState); |
| break; |
| case WIFI_DISABLE_USER_REJECT: |
| logd("User rejected enabling p2p"); |
| sendP2pStateChangedBroadcast(false); |
| transitionTo(mP2pDisabledState); |
| break; |
| case WifiP2pManager.ENABLE_P2P: |
| case WifiP2pManager.DISABLE_P2P: |
| deferMessage(message); |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class WaitForWifiDisableState extends State { |
| @Override |
| public void enter() { |
| if (DBG) logd(getName()); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| if (DBG) logd(getName() + message.toString()); |
| switch (message.what) { |
| case WifiStateMachine.P2P_ENABLE_PROCEED: |
| try { |
| mNwService.wifiFirmwareReload(mInterface, "P2P"); |
| } catch (Exception e) { |
| loge("Failed to reload p2p firmware " + e); |
| // continue |
| } |
| |
| //A runtime crash can leave the interface up and |
| //this affects p2p when supplicant starts up. |
| //Ensure interface is down before a supplicant start. |
| try { |
| mNwService.setInterfaceDown(mInterface); |
| } catch (Exception e) { |
| if (DBG) Slog.w(TAG, "Unable to bring down wlan interface: " + e); |
| } |
| |
| if (WifiNative.startP2pSupplicant()) { |
| mWifiMonitor.startMonitoring(); |
| transitionTo(mP2pEnablingState); |
| } else { |
| notifyP2pEnableFailure(); |
| transitionTo(mP2pDisabledState); |
| } |
| break; |
| case WifiP2pManager.ENABLE_P2P: |
| case WifiP2pManager.DISABLE_P2P: |
| deferMessage(message); |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class P2pEnablingState extends State { |
| @Override |
| public void enter() { |
| if (DBG) logd(getName()); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| if (DBG) logd(getName() + message.toString()); |
| switch (message.what) { |
| case WifiMonitor.SUP_CONNECTION_EVENT: |
| logd("P2p start successful"); |
| transitionTo(mInactiveState); |
| break; |
| case WifiMonitor.SUP_DISCONNECTION_EVENT: |
| if (++mP2pRestartCount <= P2P_RESTART_TRIES) { |
| loge("Failed to start p2p, retry"); |
| WifiNative.killSupplicant(); |
| sendMessageDelayed(WifiP2pManager.ENABLE_P2P, P2P_RESTART_INTERVAL_MSECS); |
| } else { |
| loge("Failed " + mP2pRestartCount + " times to start p2p, quit "); |
| mP2pRestartCount = 0; |
| } |
| transitionTo(mP2pDisabledState); |
| break; |
| case WifiP2pManager.ENABLE_P2P: |
| case WifiP2pManager.DISABLE_P2P: |
| deferMessage(message); |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class P2pEnabledState extends State { |
| @Override |
| public void enter() { |
| if (DBG) logd(getName()); |
| sendP2pStateChangedBroadcast(true); |
| mNetworkInfo.setIsAvailable(true); |
| initializeP2pSettings(); |
| showNotification(); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| if (DBG) logd(getName() + message.toString()); |
| switch (message.what) { |
| case WifiP2pManager.ENABLE_P2P: |
| replyToMessage(message, WifiP2pManager.ENABLE_P2P_SUCCEEDED); |
| break; |
| case WifiP2pManager.DISABLE_P2P: |
| if (mPeers.clear()) sendP2pPeersChangedBroadcast(); |
| replyToMessage(message, WifiP2pManager.DISABLE_P2P_SUCCEEDED); |
| transitionTo(mP2pDisablingState); |
| break; |
| case WifiP2pManager.DISCOVER_PEERS: |
| int timeout = message.arg1; |
| if (WifiNative.p2pFind(timeout)) { |
| replyToMessage(message, WifiP2pManager.DISCOVER_PEERS_SUCCEEDED); |
| } else { |
| replyToMessage(message, WifiP2pManager.DISCOVER_PEERS_FAILED, |
| WifiP2pManager.ERROR); |
| } |
| break; |
| case WifiMonitor.P2P_DEVICE_FOUND_EVENT: |
| WifiP2pDevice device = (WifiP2pDevice) message.obj; |
| if (mThisDevice.deviceAddress.equals(device.deviceAddress)) break; |
| mPeers.update(device); |
| sendP2pPeersChangedBroadcast(); |
| break; |
| case WifiMonitor.P2P_DEVICE_LOST_EVENT: |
| device = (WifiP2pDevice) message.obj; |
| if (mPeers.remove(device)) sendP2pPeersChangedBroadcast(); |
| break; |
| case WifiP2pManager.CONNECT: |
| if (DBG) logd(getName() + " sending connect"); |
| mSavedConnectConfig = (WifiP2pConfig) message.obj; |
| mPersistGroup = false; |
| int netId = configuredNetworkId(mSavedConnectConfig.deviceAddress); |
| if (netId >= 0) { |
| //TODO: if failure, remove config and do a regular p2pConnect() |
| WifiNative.p2pReinvoke(netId, mSavedConnectConfig.deviceAddress); |
| } else { |
| boolean join = false; |
| if (isGroupOwner(mSavedConnectConfig.deviceAddress)) join = true; |
| String pin = WifiNative.p2pConnect(mSavedConnectConfig, join); |
| try { |
| Integer.parseInt(pin); |
| notifyWpsPin(pin, mSavedConnectConfig.deviceAddress); |
| } catch (NumberFormatException ignore) { |
| // do nothing if p2pConnect did not return a pin |
| } |
| } |
| updateDeviceStatus(mSavedConnectConfig.deviceAddress, WifiP2pDevice.INVITED); |
| sendP2pPeersChangedBroadcast(); |
| replyToMessage(message, WifiP2pManager.CONNECT_SUCCEEDED); |
| transitionTo(mGroupNegotiationState); |
| break; |
| case WifiMonitor.SUP_DISCONNECTION_EVENT: /* Supplicant died */ |
| loge("Connection lost, restart p2p"); |
| WifiNative.killSupplicant(); |
| WifiNative.closeSupplicantConnection(); |
| if (mPeers.clear()) sendP2pPeersChangedBroadcast(); |
| transitionTo(mP2pDisabledState); |
| sendMessageDelayed(WifiP2pManager.ENABLE_P2P, P2P_RESTART_INTERVAL_MSECS); |
| break; |
| case WifiMonitor.P2P_GROUP_STARTED_EVENT: |
| mGroup = (WifiP2pGroup) message.obj; |
| if (DBG) logd(getName() + " group started"); |
| if (mGroup.isGroupOwner()) { |
| startDhcpServer(mGroup.getInterface()); |
| } else { |
| mDhcpStateMachine = DhcpStateMachine.makeDhcpStateMachine(mContext, |
| P2pStateMachine.this, mGroup.getInterface()); |
| mDhcpStateMachine.sendMessage(DhcpStateMachine.CMD_START_DHCP); |
| WifiP2pDevice groupOwner = mGroup.getOwner(); |
| updateDeviceStatus(groupOwner.deviceAddress, WifiP2pDevice.CONNECTED); |
| sendP2pPeersChangedBroadcast(); |
| } |
| transitionTo(mGroupCreatedState); |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| |
| @Override |
| public void exit() { |
| sendP2pStateChangedBroadcast(false); |
| mNetworkInfo.setIsAvailable(false); |
| clearNotification(); |
| } |
| } |
| |
| class InactiveState extends State { |
| @Override |
| public void enter() { |
| if (DBG) logd(getName()); |
| //Start listening every time we get inactive |
| WifiNative.p2pListen(); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| if (DBG) logd(getName() + message.toString()); |
| switch (message.what) { |
| case WifiMonitor.P2P_GO_NEGOTIATION_REQUEST_EVENT: |
| mSavedGoNegotiationConfig = (WifiP2pConfig) message.obj; |
| notifyP2pGoNegotationRequest(mSavedGoNegotiationConfig); |
| transitionTo(mUserAuthorizingGroupNegotiationState); |
| break; |
| case WifiP2pManager.CREATE_GROUP: |
| mPersistGroup = true; |
| if (WifiNative.p2pGroupAdd()) { |
| replyToMessage(message, WifiP2pManager.CREATE_GROUP_SUCCEEDED); |
| } else { |
| replyToMessage(message, WifiP2pManager.CREATE_GROUP_FAILED, |
| WifiP2pManager.ERROR); |
| } |
| transitionTo(mGroupNegotiationState); |
| break; |
| case WifiMonitor.P2P_INVITATION_RECEIVED_EVENT: |
| WifiP2pGroup group = (WifiP2pGroup) message.obj; |
| notifyP2pInvitationReceived(group); |
| transitionTo(mUserAuthorizingGroupInvitationState); |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class UserAuthorizingGroupNegotiationState extends State { |
| @Override |
| public void enter() { |
| if (DBG) logd(getName()); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| if (DBG) logd(getName() + message.toString()); |
| switch (message.what) { |
| case WifiMonitor.P2P_GO_NEGOTIATION_REQUEST_EVENT: |
| case WifiMonitor.P2P_INVITATION_RECEIVED_EVENT: |
| //Ignore additional connection requests |
| break; |
| case GROUP_NEGOTIATION_USER_ACCEPT: |
| sendMessage(WifiP2pManager.CONNECT, mSavedGoNegotiationConfig); |
| mSavedGoNegotiationConfig = null; |
| break; |
| case GROUP_NEGOTIATION_USER_REJECT: |
| if (DBG) logd("User rejected incoming negotiation request"); |
| mSavedGoNegotiationConfig = null; |
| transitionTo(mInactiveState); |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class UserAuthorizingGroupInvitationState extends State { |
| @Override |
| public void enter() { |
| if (DBG) logd(getName()); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| if (DBG) logd(getName() + message.toString()); |
| switch (message.what) { |
| case WifiMonitor.P2P_GO_NEGOTIATION_REQUEST_EVENT: |
| case WifiMonitor.P2P_INVITATION_RECEIVED_EVENT: |
| //Ignore additional connection requests |
| break; |
| case GROUP_INVITATION_USER_ACCEPT: |
| if (DBG) logd(getName() + " connect to invited group"); |
| WifiP2pConfig config = new WifiP2pConfig(); |
| config.deviceAddress = mSavedP2pGroup.getOwner().deviceAddress; |
| sendMessage(WifiP2pManager.CONNECT, config); |
| mSavedP2pGroup = null; |
| break; |
| case GROUP_INVITATION_USER_REJECT: |
| if (DBG) logd("User rejected incoming invitation request"); |
| mSavedP2pGroup = null; |
| transitionTo(mInactiveState); |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| |
| class GroupNegotiationState extends State { |
| @Override |
| public void enter() { |
| if (DBG) logd(getName()); |
| sendMessageDelayed(obtainMessage(GROUP_NEGOTIATION_TIMED_OUT, |
| ++mGroupNegotiationTimeoutIndex, 0), GROUP_NEGOTIATION_WAIT_TIME_MS); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| if (DBG) logd(getName() + message.toString()); |
| switch (message.what) { |
| // We ignore these right now, since we get a GROUP_STARTED notification |
| // afterwards |
| case WifiMonitor.P2P_GO_NEGOTIATION_SUCCESS_EVENT: |
| case WifiMonitor.P2P_GROUP_FORMATION_SUCCESS_EVENT: |
| if (DBG) logd(getName() + " go success"); |
| break; |
| case WifiMonitor.P2P_GO_NEGOTIATION_FAILURE_EVENT: |
| case WifiMonitor.P2P_GROUP_FORMATION_FAILURE_EVENT: |
| if (DBG) logd(getName() + " go failure"); |
| updateDeviceStatus(mSavedConnectConfig.deviceAddress, WifiP2pDevice.FAILED); |
| mSavedConnectConfig = null; |
| sendP2pPeersChangedBroadcast(); |
| transitionTo(mInactiveState); |
| break; |
| case GROUP_NEGOTIATION_TIMED_OUT: |
| if (mGroupNegotiationTimeoutIndex == message.arg1) { |
| if (DBG) logd("Group negotiation timed out"); |
| updateDeviceStatus(mSavedConnectConfig.deviceAddress, WifiP2pDevice.FAILED); |
| mSavedConnectConfig = null; |
| sendP2pPeersChangedBroadcast(); |
| transitionTo(mInactiveState); |
| } |
| break; |
| case WifiP2pManager.DISCOVER_PEERS: |
| /* Discovery will break negotiation */ |
| replyToMessage(message, WifiP2pManager.DISCOVER_PEERS_FAILED, |
| WifiP2pManager.BUSY); |
| break; |
| case WifiP2pManager.CANCEL_CONNECT: |
| if (WifiNative.p2pCancelConnect()) { |
| replyToMessage(message, WifiP2pManager.CANCEL_CONNECT_SUCCEEDED); |
| } else { |
| replyToMessage(message, WifiP2pManager.CANCEL_CONNECT_FAILED, |
| WifiP2pManager.ERROR); |
| } |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class GroupCreatedState extends State { |
| @Override |
| public void enter() { |
| if (DBG) logd(getName()); |
| mNetworkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, null, null); |
| |
| updateThisDevice(WifiP2pDevice.CONNECTED); |
| |
| //DHCP server has already been started if I am a group owner |
| if (mGroup.isGroupOwner()) { |
| setWifiP2pInfoOnGroupFormation(SERVER_ADDRESS); |
| sendP2pConnectionChangedBroadcast(); |
| } |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| if (DBG) logd(getName() + message.toString()); |
| switch (message.what) { |
| case WifiMonitor.AP_STA_CONNECTED_EVENT: |
| //After a GO setup, STA connected event comes with interface address |
| String interfaceAddress = (String) message.obj; |
| String deviceAddress = getDeviceAddress(interfaceAddress); |
| if (deviceAddress != null) { |
| mGroup.addClient(deviceAddress); |
| updateDeviceStatus(deviceAddress, WifiP2pDevice.CONNECTED); |
| if (DBG) logd(getName() + " ap sta connected"); |
| sendP2pPeersChangedBroadcast(); |
| } else { |
| loge("Connect on unknown device address : " + interfaceAddress); |
| } |
| break; |
| case WifiMonitor.AP_STA_DISCONNECTED_EVENT: |
| interfaceAddress = (String) message.obj; |
| deviceAddress = getDeviceAddress(interfaceAddress); |
| if (deviceAddress != null) { |
| updateDeviceStatus(deviceAddress, WifiP2pDevice.AVAILABLE); |
| if (mGroup.removeClient(deviceAddress)) { |
| if (DBG) logd("Removed client " + deviceAddress); |
| if (!mPersistGroup && mGroup.isClientListEmpty()) { |
| Slog.d(TAG, "Client list empty, remove non-persistent p2p group"); |
| WifiNative.p2pGroupRemove(mGroup.getInterface()); |
| } |
| } else { |
| if (DBG) logd("Failed to remove client " + deviceAddress); |
| for (WifiP2pDevice c : mGroup.getClientList()) { |
| if (DBG) logd("client " + c.deviceAddress); |
| } |
| } |
| sendP2pPeersChangedBroadcast(); |
| if (DBG) loge(getName() + " ap sta disconnected"); |
| } else { |
| loge("Disconnect on unknown device address : " + interfaceAddress); |
| } |
| break; |
| case DhcpStateMachine.CMD_POST_DHCP_ACTION: |
| DhcpInfoInternal dhcpInfo = (DhcpInfoInternal) message.obj; |
| if (message.arg1 == DhcpStateMachine.DHCP_SUCCESS && |
| dhcpInfo != null) { |
| if (DBG) logd("DhcpInfo: " + dhcpInfo); |
| setWifiP2pInfoOnGroupFormation(dhcpInfo.serverAddress); |
| sendP2pConnectionChangedBroadcast(); |
| } else { |
| WifiNative.p2pGroupRemove(mGroup.getInterface()); |
| } |
| break; |
| case WifiP2pManager.REMOVE_GROUP: |
| if (DBG) loge(getName() + " remove group"); |
| if (WifiNative.p2pGroupRemove(mGroup.getInterface())) { |
| replyToMessage(message, WifiP2pManager.REMOVE_GROUP_SUCCEEDED); |
| } else { |
| replyToMessage(message, WifiP2pManager.REMOVE_GROUP_FAILED, |
| WifiP2pManager.ERROR); |
| } |
| break; |
| case WifiMonitor.P2P_GROUP_REMOVED_EVENT: |
| if (DBG) loge(getName() + " group removed"); |
| Collection <WifiP2pDevice> devices = mGroup.getClientList(); |
| boolean changed = false; |
| for (WifiP2pDevice d : mPeers.getDeviceList()) { |
| if (devices.contains(d) || mGroup.getOwner().equals(d)) { |
| d.status = WifiP2pDevice.AVAILABLE; |
| changed = true; |
| } |
| } |
| |
| if (mGroup.isGroupOwner()) { |
| stopDhcpServer(); |
| } else { |
| if (DBG) logd("stop DHCP client"); |
| mDhcpStateMachine.sendMessage(DhcpStateMachine.CMD_STOP_DHCP); |
| mDhcpStateMachine.quit(); |
| mDhcpStateMachine = null; |
| } |
| |
| mGroup = null; |
| if (changed) sendP2pPeersChangedBroadcast(); |
| transitionTo(mInactiveState); |
| break; |
| case WifiMonitor.P2P_DEVICE_LOST_EVENT: |
| WifiP2pDevice device = (WifiP2pDevice) message.obj; |
| if (device.equals(mGroup.getOwner())) { |
| logd("Lost the group owner, killing p2p connection"); |
| WifiNative.p2pGroupRemove(mGroup.getInterface()); |
| } else if (mGroup.removeClient(device)) { |
| if (!mPersistGroup && mGroup.isClientListEmpty()) { |
| Slog.d(TAG, "Client list empty, removing a non-persistent p2p group"); |
| WifiNative.p2pGroupRemove(mGroup.getInterface()); |
| } |
| } |
| return NOT_HANDLED; // Do the regular device lost handling |
| case WifiP2pManager.DISABLE_P2P: |
| sendMessage(WifiP2pManager.REMOVE_GROUP); |
| deferMessage(message); |
| break; |
| case WifiP2pManager.CONNECT: |
| WifiP2pConfig config = (WifiP2pConfig) message.obj; |
| logd("Inviting device : " + config.deviceAddress); |
| if (WifiNative.p2pInvite(mGroup, config.deviceAddress)) { |
| updateDeviceStatus(config.deviceAddress, WifiP2pDevice.INVITED); |
| sendP2pPeersChangedBroadcast(); |
| replyToMessage(message, WifiP2pManager.CONNECT_SUCCEEDED); |
| } else { |
| replyToMessage(message, WifiP2pManager.CONNECT_FAILED, |
| WifiP2pManager.ERROR); |
| } |
| // TODO: figure out updating the status to declined when invitation is rejected |
| break; |
| case WifiMonitor.P2P_INVITATION_RESULT_EVENT: |
| logd("===> INVITATION RESULT EVENT : " + message.obj); |
| break; |
| case WifiMonitor.P2P_PROV_DISC_PBC_REQ_EVENT: |
| notifyP2pProvDiscPbcRequest((WifiP2pDevice) message.obj); |
| break; |
| case WifiMonitor.P2P_PROV_DISC_ENTER_PIN_EVENT: |
| notifyP2pProvDiscPinRequest((WifiP2pDevice) message.obj); |
| break; |
| case WifiMonitor.P2P_GROUP_STARTED_EVENT: |
| Slog.e(TAG, "Duplicate group creation event notice, ignore"); |
| break; |
| case WPS_PBC: |
| WifiNative.wpsPbc(); |
| break; |
| case WPS_PIN: |
| WifiNative.wpsPin((String) message.obj); |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| |
| public void exit() { |
| updateThisDevice(WifiP2pDevice.AVAILABLE); |
| setWifiP2pInfoOnGroupTermination(); |
| mNetworkInfo.setDetailedState(NetworkInfo.DetailedState.DISCONNECTED, null, null); |
| sendP2pConnectionChangedBroadcast(); |
| } |
| } |
| |
| private void sendP2pStateChangedBroadcast(boolean enabled) { |
| final Intent intent = new Intent(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION); |
| intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); |
| if (enabled) { |
| intent.putExtra(WifiP2pManager.EXTRA_WIFI_STATE, |
| WifiP2pManager.WIFI_P2P_STATE_ENABLED); |
| } else { |
| intent.putExtra(WifiP2pManager.EXTRA_WIFI_STATE, |
| WifiP2pManager.WIFI_P2P_STATE_DISABLED); |
| } |
| mContext.sendStickyBroadcast(intent); |
| } |
| |
| private void sendThisDeviceChangedBroadcast() { |
| final Intent intent = new Intent(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION); |
| intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); |
| intent.putExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE, new WifiP2pDevice(mThisDevice)); |
| mContext.sendStickyBroadcast(intent); |
| } |
| |
| private void sendP2pPeersChangedBroadcast() { |
| final Intent intent = new Intent(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION); |
| intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); |
| mContext.sendBroadcast(intent); |
| } |
| |
| private void sendP2pConnectionChangedBroadcast() { |
| if (DBG) logd("sending p2p connection changed broadcast"); |
| Intent intent = new Intent(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION); |
| intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT |
| | Intent.FLAG_RECEIVER_REPLACE_PENDING); |
| intent.putExtra(WifiP2pManager.EXTRA_WIFI_P2P_INFO, new WifiP2pInfo(mWifiP2pInfo)); |
| intent.putExtra(WifiP2pManager.EXTRA_NETWORK_INFO, new NetworkInfo(mNetworkInfo)); |
| mContext.sendStickyBroadcast(intent); |
| } |
| |
| private void startDhcpServer(String intf) { |
| InterfaceConfiguration ifcg = null; |
| try { |
| ifcg = mNwService.getInterfaceConfig(intf); |
| ifcg.addr = new LinkAddress(NetworkUtils.numericToInetAddress( |
| SERVER_ADDRESS), 24); |
| ifcg.interfaceFlags = "[up]"; |
| mNwService.setInterfaceConfig(intf, ifcg); |
| /* This starts the dnsmasq server */ |
| mNwService.startTethering(DHCP_RANGE); |
| } catch (Exception e) { |
| loge("Error configuring interface " + intf + ", :" + e); |
| return; |
| } |
| |
| logd("Started Dhcp server on " + intf); |
| } |
| |
| private void stopDhcpServer() { |
| try { |
| mNwService.stopTethering(); |
| } catch (Exception e) { |
| loge("Error stopping Dhcp server" + e); |
| return; |
| } |
| |
| logd("Stopped Dhcp server"); |
| } |
| |
| private void notifyP2pEnableFailure() { |
| Resources r = Resources.getSystem(); |
| AlertDialog dialog = new AlertDialog.Builder(mContext) |
| .setTitle(r.getString(R.string.wifi_p2p_dialog_title)) |
| .setMessage(r.getString(R.string.wifi_p2p_failed_message)) |
| .setPositiveButton(r.getString(R.string.ok), null) |
| .create(); |
| dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); |
| dialog.show(); |
| } |
| |
| private void notifyWpsPin(String pin, String peerAddress) { |
| Resources r = Resources.getSystem(); |
| AlertDialog dialog = new AlertDialog.Builder(mContext) |
| .setTitle(r.getString(R.string.wifi_p2p_dialog_title)) |
| .setMessage(r.getString(R.string.wifi_p2p_pin_display_message, pin, peerAddress)) |
| .setPositiveButton(r.getString(R.string.ok), null) |
| .create(); |
| dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); |
| dialog.show(); |
| } |
| |
| private void notifyP2pGoNegotationRequest(WifiP2pConfig config) { |
| Resources r = Resources.getSystem(); |
| WpsInfo wps = config.wps; |
| final View textEntryView = LayoutInflater.from(mContext) |
| .inflate(R.layout.wifi_p2p_go_negotiation_request_alert, null); |
| final EditText pin = (EditText) textEntryView .findViewById(R.id.wifi_p2p_wps_pin); |
| |
| AlertDialog dialog = new AlertDialog.Builder(mContext) |
| .setTitle(r.getString(R.string.wifi_p2p_dialog_title)) |
| .setView(textEntryView) |
| .setPositiveButton(r.getString(R.string.ok), new OnClickListener() { |
| public void onClick(DialogInterface dialog, int which) { |
| if (DBG) logd(getName() + " connect " + pin.getText()); |
| |
| if (pin.getVisibility() == View.GONE) { |
| mSavedGoNegotiationConfig.wps.setup = WpsInfo.PBC; |
| } else { |
| mSavedGoNegotiationConfig.wps.setup = WpsInfo.KEYPAD; |
| mSavedGoNegotiationConfig.wps.pin = pin.getText().toString(); |
| } |
| sendMessage(GROUP_NEGOTIATION_USER_ACCEPT); |
| } |
| }) |
| .setNegativeButton(r.getString(R.string.cancel), new OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| if (DBG) logd(getName() + " ignore connect"); |
| sendMessage(GROUP_NEGOTIATION_USER_REJECT); |
| } |
| }) |
| .create(); |
| |
| if (wps.setup == WpsInfo.PBC) { |
| pin.setVisibility(View.GONE); |
| dialog.setMessage(r.getString(R.string.wifi_p2p_pbc_go_negotiation_request_message, |
| config.deviceAddress)); |
| } else { |
| dialog.setMessage(r.getString(R.string.wifi_p2p_pin_go_negotiation_request_message, |
| config.deviceAddress)); |
| } |
| |
| dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); |
| dialog.show(); |
| } |
| |
| private void notifyP2pProvDiscPbcRequest(WifiP2pDevice peer) { |
| Resources r = Resources.getSystem(); |
| final View textEntryView = LayoutInflater.from(mContext) |
| .inflate(R.layout.wifi_p2p_go_negotiation_request_alert, null); |
| final EditText pin = (EditText) textEntryView .findViewById(R.id.wifi_p2p_wps_pin); |
| |
| AlertDialog dialog = new AlertDialog.Builder(mContext) |
| .setTitle(r.getString(R.string.wifi_p2p_dialog_title)) |
| .setView(textEntryView) |
| .setPositiveButton(r.getString(R.string.ok), new OnClickListener() { |
| public void onClick(DialogInterface dialog, int which) { |
| if (DBG) logd(getName() + " wps_pbc"); |
| sendMessage(WPS_PBC); |
| } |
| }) |
| .setNegativeButton(r.getString(R.string.cancel), null) |
| .create(); |
| |
| pin.setVisibility(View.GONE); |
| dialog.setMessage(r.getString(R.string.wifi_p2p_pbc_go_negotiation_request_message, |
| peer.deviceAddress)); |
| |
| dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); |
| dialog.show(); |
| } |
| |
| private void notifyP2pProvDiscPinRequest(WifiP2pDevice peer) { |
| Resources r = Resources.getSystem(); |
| final View textEntryView = LayoutInflater.from(mContext) |
| .inflate(R.layout.wifi_p2p_go_negotiation_request_alert, null); |
| final EditText pin = (EditText) textEntryView .findViewById(R.id.wifi_p2p_wps_pin); |
| |
| AlertDialog dialog = new AlertDialog.Builder(mContext) |
| .setTitle(r.getString(R.string.wifi_p2p_dialog_title)) |
| .setView(textEntryView) |
| .setPositiveButton(r.getString(R.string.ok), new OnClickListener() { |
| public void onClick(DialogInterface dialog, int which) { |
| if (DBG) logd(getName() + " wps_pin"); |
| sendMessage(WPS_PIN, pin.getText().toString()); |
| } |
| }) |
| .setNegativeButton(r.getString(R.string.cancel), null) |
| .create(); |
| |
| dialog.setMessage(r.getString(R.string.wifi_p2p_pin_go_negotiation_request_message, |
| peer.deviceAddress)); |
| |
| dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); |
| dialog.show(); |
| } |
| |
| private void notifyP2pInvitationReceived(WifiP2pGroup group) { |
| mSavedP2pGroup = group; |
| Resources r = Resources.getSystem(); |
| final View textEntryView = LayoutInflater.from(mContext) |
| .inflate(R.layout.wifi_p2p_go_negotiation_request_alert, null); |
| final EditText pin = (EditText) textEntryView .findViewById(R.id.wifi_p2p_wps_pin); |
| |
| AlertDialog dialog = new AlertDialog.Builder(mContext) |
| .setTitle(r.getString(R.string.wifi_p2p_dialog_title)) |
| .setView(textEntryView) |
| .setPositiveButton(r.getString(R.string.ok), new OnClickListener() { |
| public void onClick(DialogInterface dialog, int which) { |
| sendMessage(GROUP_INVITATION_USER_ACCEPT); |
| } |
| }) |
| .setNegativeButton(r.getString(R.string.cancel), new OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| if (DBG) logd(getName() + " ignore invite"); |
| sendMessage(GROUP_INVITATION_USER_REJECT); |
| } |
| }) |
| .create(); |
| |
| pin.setVisibility(View.GONE); |
| dialog.setMessage(r.getString(R.string.wifi_p2p_pbc_go_negotiation_request_message, |
| group.getOwner().deviceAddress)); |
| |
| dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); |
| dialog.show(); |
| } |
| |
| private void updateDeviceStatus(String deviceAddress, int status) { |
| for (WifiP2pDevice d : mPeers.getDeviceList()) { |
| if (d.deviceAddress.equals(deviceAddress)) { |
| d.status = status; |
| } |
| } |
| } |
| |
| private boolean isGroupOwner(String deviceAddress) { |
| for (WifiP2pDevice d : mPeers.getDeviceList()) { |
| if (d.deviceAddress.equals(deviceAddress)) { |
| return d.isGroupOwner(); |
| } |
| } |
| return false; |
| } |
| |
| //TODO: implement when wpa_supplicant is fixed |
| private int configuredNetworkId(String deviceAddress) { |
| return -1; |
| } |
| |
| private void setWifiP2pInfoOnGroupFormation(String serverAddress) { |
| mWifiP2pInfo.groupFormed = true; |
| mWifiP2pInfo.isGroupOwner = mGroup.isGroupOwner(); |
| mWifiP2pInfo.groupOwnerAddress = NetworkUtils.numericToInetAddress(serverAddress); |
| } |
| |
| private void setWifiP2pInfoOnGroupTermination() { |
| mWifiP2pInfo.groupFormed = false; |
| mWifiP2pInfo.isGroupOwner = false; |
| mWifiP2pInfo.groupOwnerAddress = null; |
| } |
| |
| private String getDeviceAddress(String interfaceAddress) { |
| for (WifiP2pDevice d : mPeers.getDeviceList()) { |
| if (interfaceAddress.equals(WifiNative.p2pGetInterfaceAddress(d.deviceAddress))) { |
| return d.deviceAddress; |
| } |
| } |
| return null; |
| } |
| |
| private void initializeP2pSettings() { |
| WifiNative.setPersistentReconnect(true); |
| WifiNative.setDeviceName(mThisDevice.deviceName); |
| WifiNative.setDeviceType(mThisDevice.primaryDeviceType); |
| |
| mThisDevice.deviceAddress = WifiNative.p2pGetDeviceAddress(); |
| updateThisDevice(WifiP2pDevice.AVAILABLE); |
| if (DBG) Slog.d(TAG, "DeviceAddress: " + mThisDevice.deviceAddress); |
| } |
| |
| private void updateThisDevice(int status) { |
| mThisDevice.status = status; |
| sendThisDeviceChangedBroadcast(); |
| } |
| |
| //State machine initiated requests can have replyTo set to null indicating |
| //there are no recepients, we ignore those reply actions |
| private void replyToMessage(Message msg, int what) { |
| if (msg.replyTo == null) return; |
| Message dstMsg = obtainMessage(msg); |
| dstMsg.what = what; |
| mReplyChannel.replyToMessage(msg, dstMsg); |
| } |
| |
| private void replyToMessage(Message msg, int what, int arg1) { |
| if (msg.replyTo == null) return; |
| Message dstMsg = obtainMessage(msg); |
| dstMsg.what = what; |
| dstMsg.arg1 = arg1; |
| mReplyChannel.replyToMessage(msg, dstMsg); |
| } |
| |
| private void replyToMessage(Message msg, int what, Object obj) { |
| if (msg.replyTo == null) return; |
| Message dstMsg = obtainMessage(msg); |
| dstMsg.what = what; |
| dstMsg.obj = obj; |
| mReplyChannel.replyToMessage(msg, dstMsg); |
| } |
| |
| /* arg2 on the source message has a hash code that needs to be retained in replies |
| * see WifiP2pManager for details */ |
| private Message obtainMessage(Message srcMsg) { |
| Message msg = Message.obtain(); |
| msg.arg2 = srcMsg.arg2; |
| return msg; |
| } |
| |
| private void logd(String s) { |
| Slog.d(TAG, s); |
| } |
| |
| private void loge(String s) { |
| Slog.e(TAG, s); |
| } |
| |
| private void showNotification() { |
| NotificationManager notificationManager = |
| (NotificationManager)mContext.getSystemService(Context.NOTIFICATION_SERVICE); |
| if (notificationManager == null || mNotification != null) { |
| return; |
| } |
| |
| Intent intent = new Intent(android.provider.Settings.ACTION_WIRELESS_SETTINGS); |
| intent.setFlags(Intent.FLAG_ACTIVITY_NO_HISTORY); |
| |
| PendingIntent pi = PendingIntent.getActivity(mContext, 0, intent, 0); |
| |
| Resources r = Resources.getSystem(); |
| CharSequence title = r.getText(R.string.wifi_p2p_enabled_notification_title); |
| CharSequence message = r.getText(R.string.wifi_p2p_enabled_notification_message); |
| |
| mNotification = new Notification(); |
| mNotification.when = 0; |
| //TODO: might change to be a seperate icon |
| mNotification.icon = R.drawable.stat_sys_tether_wifi; |
| mNotification.defaults &= ~Notification.DEFAULT_SOUND; |
| mNotification.flags = Notification.FLAG_ONGOING_EVENT; |
| mNotification.tickerText = title; |
| mNotification.setLatestEventInfo(mContext, title, message, pi); |
| |
| notificationManager.notify(mNotification.icon, mNotification); |
| } |
| |
| private void clearNotification() { |
| NotificationManager notificationManager = |
| (NotificationManager)mContext.getSystemService(Context.NOTIFICATION_SERVICE); |
| if (notificationManager != null && mNotification != null) { |
| notificationManager.cancel(mNotification.icon); |
| mNotification = null; |
| } |
| } |
| |
| private boolean isAirplaneSensitive() { |
| String airplaneModeRadios = Settings.System.getString(mContext.getContentResolver(), |
| Settings.System.AIRPLANE_MODE_RADIOS); |
| return airplaneModeRadios == null |
| || airplaneModeRadios.contains(Settings.System.RADIO_WIFI); |
| } |
| |
| private boolean isAirplaneModeOn() { |
| return isAirplaneSensitive() && Settings.System.getInt(mContext.getContentResolver(), |
| Settings.System.AIRPLANE_MODE_ON, 0) == 1; |
| } |
| |
| } |
| } |
