1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.settings.wifi.p2p; 18 19 import android.app.ActionBar; 20 import android.app.Activity; 21 import android.app.AlertDialog; 22 import android.app.Dialog; 23 import android.content.BroadcastReceiver; 24 import android.content.Context; 25 import android.content.DialogInterface; 26 import android.content.DialogInterface.OnClickListener; 27 import android.content.Intent; 28 import android.content.IntentFilter; 29 import android.net.NetworkInfo; 30 import android.net.wifi.p2p.WifiP2pConfig; 31 import android.net.wifi.p2p.WifiP2pInfo; 32 import android.net.wifi.p2p.WifiP2pDevice; 33 import android.net.wifi.p2p.WifiP2pDeviceList; 34 import android.net.wifi.p2p.WifiP2pGroup; 35 import android.net.wifi.p2p.WifiP2pGroupList; 36 import android.net.wifi.p2p.WifiP2pManager; 37 import android.net.wifi.p2p.WifiP2pManager.GroupInfoListener; 38 import android.net.wifi.p2p.WifiP2pManager.PersistentGroupInfoListener; 39 import android.net.wifi.WpsInfo; 40 import android.os.Bundle; 41 import android.os.Handler; 42 import android.os.SystemProperties; 43 import android.preference.Preference; 44 import android.preference.PreferenceActivity; 45 import android.preference.PreferenceCategory; 46 import android.preference.PreferenceGroup; 47 import android.preference.PreferenceScreen; 48 import android.text.InputFilter; 49 import android.text.TextUtils; 50 import android.util.Log; 51 import android.view.Gravity; 52 import android.view.Menu; 53 import android.view.MenuInflater; 54 import android.view.MenuItem; 55 import android.widget.EditText; 56 import android.widget.Switch; 57 import android.widget.Toast; 58 59 import com.android.settings.R; 60 import com.android.settings.SettingsPreferenceFragment; 61 62 import java.util.Arrays; 63 import java.util.List; 64 import java.util.Collection; 65 66 /* 67 * Displays Wi-fi p2p settings UI 68 */ 69 public class WifiP2pSettings extends SettingsPreferenceFragment 70 implements PersistentGroupInfoListener, GroupInfoListener { 71 72 private static final String TAG = "WifiP2pSettings"; 73 private static final boolean DBG = false; 74 private static final int MENU_ID_SEARCH = Menu.FIRST; 75 private static final int MENU_ID_RENAME = Menu.FIRST + 1; 76 77 private final IntentFilter mIntentFilter = new IntentFilter(); 78 private WifiP2pManager mWifiP2pManager; 79 private WifiP2pManager.Channel mChannel; 80 private OnClickListener mRenameListener; 81 private OnClickListener mDisconnectListener; 82 private OnClickListener mCancelConnectListener; 83 private OnClickListener mDeleteGroupListener; 84 private WifiP2pPeer mSelectedWifiPeer; 85 private WifiP2pPersistentGroup mSelectedGroup; 86 private EditText mDeviceNameText; 87 88 private boolean mWifiP2pEnabled; 89 private boolean mWifiP2pSearching; 90 private int mConnectedDevices; 91 private WifiP2pGroup mConnectedGroup; 92 private boolean mLastGroupFormed = false; 93 94 private PreferenceGroup mPeersGroup; 95 private PreferenceGroup mPersistentGroup; 96 private Preference mThisDevicePref; 97 98 private static final int DIALOG_DISCONNECT = 1; 99 private static final int DIALOG_CANCEL_CONNECT = 2; 100 private static final int DIALOG_RENAME = 3; 101 private static final int DIALOG_DELETE_GROUP = 4; 102 103 private static final String SAVE_DIALOG_PEER = "PEER_STATE"; 104 private static final String SAVE_DEVICE_NAME = "DEV_NAME"; 105 106 private WifiP2pDevice mThisDevice; 107 private WifiP2pDeviceList mPeers = new WifiP2pDeviceList(); 108 109 private String mSavedDeviceName; 110 111 private final BroadcastReceiver mReceiver = new BroadcastReceiver() { 112 @Override 113 public void onReceive(Context context, Intent intent) { 114 String action = intent.getAction(); 115 116 if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) { 117 mWifiP2pEnabled = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, 118 WifiP2pManager.WIFI_P2P_STATE_DISABLED) == WifiP2pManager.WIFI_P2P_STATE_ENABLED; 119 handleP2pStateChanged(); 120 } else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) { 121 mPeers = (WifiP2pDeviceList) intent.getParcelableExtra( 122 WifiP2pManager.EXTRA_P2P_DEVICE_LIST); 123 handlePeersChanged(); 124 } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) { 125 if (mWifiP2pManager == null) return; 126 NetworkInfo networkInfo = (NetworkInfo) intent.getParcelableExtra( 127 WifiP2pManager.EXTRA_NETWORK_INFO); 128 WifiP2pInfo wifip2pinfo = (WifiP2pInfo) intent.getParcelableExtra( 129 WifiP2pManager.EXTRA_WIFI_P2P_INFO); 130 if (mWifiP2pManager != null) { 131 mWifiP2pManager.requestGroupInfo(mChannel, WifiP2pSettings.this); 132 } 133 if (networkInfo.isConnected()) { 134 if (DBG) Log.d(TAG, "Connected"); 135 } else if (mLastGroupFormed != true) { 136 //start a search when we are disconnected 137 //but not on group removed broadcast event 138 startSearch(); 139 } 140 mLastGroupFormed = wifip2pinfo.groupFormed; 141 } else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) { 142 mThisDevice = (WifiP2pDevice) intent.getParcelableExtra( 143 WifiP2pManager.EXTRA_WIFI_P2P_DEVICE); 144 if (DBG) Log.d(TAG, "Update device info: " + mThisDevice); 145 updateDevicePref(); 146 } else if (WifiP2pManager.WIFI_P2P_DISCOVERY_CHANGED_ACTION.equals(action)) { 147 int discoveryState = intent.getIntExtra(WifiP2pManager.EXTRA_DISCOVERY_STATE, 148 WifiP2pManager.WIFI_P2P_DISCOVERY_STOPPED); 149 if (DBG) Log.d(TAG, "Discovery state changed: " + discoveryState); 150 if (discoveryState == WifiP2pManager.WIFI_P2P_DISCOVERY_STARTED) { 151 updateSearchMenu(true); 152 } else { 153 updateSearchMenu(false); 154 } 155 } else if (WifiP2pManager.WIFI_P2P_PERSISTENT_GROUPS_CHANGED_ACTION.equals(action)) { 156 if (mWifiP2pManager != null) { 157 mWifiP2pManager.requestPersistentGroupInfo(mChannel, WifiP2pSettings.this); 158 } 159 } 160 } 161 }; 162 163 @Override 164 public void onActivityCreated(Bundle savedInstanceState) { 165 addPreferencesFromResource(R.xml.wifi_p2p_settings); 166 167 mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION); 168 mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION); 169 mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION); 170 mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION); 171 mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_DISCOVERY_CHANGED_ACTION); 172 mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_PERSISTENT_GROUPS_CHANGED_ACTION); 173 174 final Activity activity = getActivity(); 175 mWifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE); 176 if (mWifiP2pManager != null) { 177 mChannel = mWifiP2pManager.initialize(activity, getActivity().getMainLooper(), null); 178 if (mChannel == null) { 179 //Failure to set up connection 180 Log.e(TAG, "Failed to set up connection with wifi p2p service"); 181 mWifiP2pManager = null; 182 } 183 } else { 184 Log.e(TAG, "mWifiP2pManager is null !"); 185 } 186 187 if (savedInstanceState != null && savedInstanceState.containsKey(SAVE_DIALOG_PEER)) { 188 WifiP2pDevice device = savedInstanceState.getParcelable(SAVE_DIALOG_PEER); 189 mSelectedWifiPeer = new WifiP2pPeer(getActivity(), device); 190 } 191 if (savedInstanceState != null && savedInstanceState.containsKey(SAVE_DEVICE_NAME)) { 192 mSavedDeviceName = savedInstanceState.getString(SAVE_DEVICE_NAME); 193 } 194 195 mRenameListener = new OnClickListener() { 196 @Override 197 public void onClick(DialogInterface dialog, int which) { 198 if (which == DialogInterface.BUTTON_POSITIVE) { 199 if (mWifiP2pManager != null) { 200 mWifiP2pManager.setDeviceName(mChannel, 201 mDeviceNameText.getText().toString(), 202 new WifiP2pManager.ActionListener() { 203 public void onSuccess() { 204 if (DBG) Log.d(TAG, " device rename success"); 205 } 206 public void onFailure(int reason) { 207 Toast.makeText(getActivity(), 208 R.string.wifi_p2p_failed_rename_message, 209 Toast.LENGTH_LONG).show(); 210 } 211 }); 212 } 213 } 214 } 215 }; 216 217 //disconnect dialog listener 218 mDisconnectListener = new OnClickListener() { 219 @Override 220 public void onClick(DialogInterface dialog, int which) { 221 if (which == DialogInterface.BUTTON_POSITIVE) { 222 if (mWifiP2pManager != null) { 223 mWifiP2pManager.removeGroup(mChannel, new WifiP2pManager.ActionListener() { 224 public void onSuccess() { 225 if (DBG) Log.d(TAG, " remove group success"); 226 } 227 public void onFailure(int reason) { 228 if (DBG) Log.d(TAG, " remove group fail " + reason); 229 } 230 }); 231 } 232 } 233 } 234 }; 235 236 //cancel connect dialog listener 237 mCancelConnectListener = new OnClickListener() { 238 @Override 239 public void onClick(DialogInterface dialog, int which) { 240 if (which == DialogInterface.BUTTON_POSITIVE) { 241 if (mWifiP2pManager != null) { 242 mWifiP2pManager.cancelConnect(mChannel, 243 new WifiP2pManager.ActionListener() { 244 public void onSuccess() { 245 if (DBG) Log.d(TAG, " cancel connect success"); 246 } 247 public void onFailure(int reason) { 248 if (DBG) Log.d(TAG, " cancel connect fail " + reason); 249 } 250 }); 251 } 252 } 253 } 254 }; 255 256 //delete persistent group dialog listener 257 mDeleteGroupListener = new OnClickListener() { 258 @Override 259 public void onClick(DialogInterface dialog, int which) { 260 if (which == DialogInterface.BUTTON_POSITIVE) { 261 if (mWifiP2pManager != null) { 262 mWifiP2pManager.deletePersistentGroup(mChannel, 263 mSelectedGroup.getNetworkId(), 264 new WifiP2pManager.ActionListener() { 265 public void onSuccess() { 266 if (DBG) Log.d(TAG, " delete group success"); 267 } 268 public void onFailure(int reason) { 269 if (DBG) Log.d(TAG, " delete group fail " + reason); 270 } 271 }); 272 } 273 } 274 } 275 }; 276 277 setHasOptionsMenu(true); 278 279 final PreferenceScreen preferenceScreen = getPreferenceScreen(); 280 preferenceScreen.removeAll(); 281 282 preferenceScreen.setOrderingAsAdded(true); 283 mThisDevicePref = new Preference(getActivity()); 284 preferenceScreen.addPreference(mThisDevicePref); 285 286 mPeersGroup = new PreferenceCategory(getActivity()); 287 mPeersGroup.setTitle(R.string.wifi_p2p_peer_devices); 288 289 mPersistentGroup = new PreferenceCategory(getActivity()); 290 mPersistentGroup.setTitle(R.string.wifi_p2p_remembered_groups); 291 292 super.onActivityCreated(savedInstanceState); 293 } 294 295 @Override 296 public void onResume() { 297 super.onResume(); 298 getActivity().registerReceiver(mReceiver, mIntentFilter); 299 } 300 301 @Override 302 public void onPause() { 303 super.onPause(); 304 mWifiP2pManager.stopPeerDiscovery(mChannel, null); 305 getActivity().unregisterReceiver(mReceiver); 306 } 307 308 @Override 309 public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { 310 int textId = mWifiP2pSearching ? R.string.wifi_p2p_menu_searching : 311 R.string.wifi_p2p_menu_search; 312 menu.add(Menu.NONE, MENU_ID_SEARCH, 0, textId) 313 .setEnabled(mWifiP2pEnabled) 314 .setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM); 315 menu.add(Menu.NONE, MENU_ID_RENAME, 0, R.string.wifi_p2p_menu_rename) 316 .setEnabled(mWifiP2pEnabled) 317 .setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM); 318 super.onCreateOptionsMenu(menu, inflater); 319 } 320 321 @Override 322 public void onPrepareOptionsMenu(Menu menu) { 323 MenuItem searchMenu = menu.findItem(MENU_ID_SEARCH); 324 MenuItem renameMenu = menu.findItem(MENU_ID_RENAME); 325 if (mWifiP2pEnabled) { 326 searchMenu.setEnabled(true); 327 renameMenu.setEnabled(true); 328 } else { 329 searchMenu.setEnabled(false); 330 renameMenu.setEnabled(false); 331 } 332 333 if (mWifiP2pSearching) { 334 searchMenu.setTitle(R.string.wifi_p2p_menu_searching); 335 } else { 336 searchMenu.setTitle(R.string.wifi_p2p_menu_search); 337 } 338 } 339 340 @Override 341 public boolean onOptionsItemSelected(MenuItem item) { 342 switch (item.getItemId()) { 343 case MENU_ID_SEARCH: 344 startSearch(); 345 return true; 346 case MENU_ID_RENAME: 347 showDialog(DIALOG_RENAME); 348 return true; 349 } 350 return super.onOptionsItemSelected(item); 351 } 352 353 @Override 354 public boolean onPreferenceTreeClick(PreferenceScreen screen, Preference preference) { 355 if (preference instanceof WifiP2pPeer) { 356 mSelectedWifiPeer = (WifiP2pPeer) preference; 357 if (mSelectedWifiPeer.device.status == WifiP2pDevice.CONNECTED) { 358 showDialog(DIALOG_DISCONNECT); 359 } else if (mSelectedWifiPeer.device.status == WifiP2pDevice.INVITED) { 360 showDialog(DIALOG_CANCEL_CONNECT); 361 } else { 362 WifiP2pConfig config = new WifiP2pConfig(); 363 config.deviceAddress = mSelectedWifiPeer.device.deviceAddress; 364 365 int forceWps = SystemProperties.getInt("wifidirect.wps", -1); 366 367 if (forceWps != -1) { 368 config.wps.setup = forceWps; 369 } else { 370 if (mSelectedWifiPeer.device.wpsPbcSupported()) { 371 config.wps.setup = WpsInfo.PBC; 372 } else if (mSelectedWifiPeer.device.wpsKeypadSupported()) { 373 config.wps.setup = WpsInfo.KEYPAD; 374 } else { 375 config.wps.setup = WpsInfo.DISPLAY; 376 } 377 } 378 379 mWifiP2pManager.connect(mChannel, config, 380 new WifiP2pManager.ActionListener() { 381 public void onSuccess() { 382 if (DBG) Log.d(TAG, " connect success"); 383 } 384 public void onFailure(int reason) { 385 Log.e(TAG, " connect fail " + reason); 386 Toast.makeText(getActivity(), 387 R.string.wifi_p2p_failed_connect_message, 388 Toast.LENGTH_SHORT).show(); 389 } 390 }); 391 } 392 } else if (preference instanceof WifiP2pPersistentGroup) { 393 mSelectedGroup = (WifiP2pPersistentGroup) preference; 394 showDialog(DIALOG_DELETE_GROUP); 395 } 396 return super.onPreferenceTreeClick(screen, preference); 397 } 398 399 @Override 400 public Dialog onCreateDialog(int id) { 401 if (id == DIALOG_DISCONNECT) { 402 String deviceName = TextUtils.isEmpty(mSelectedWifiPeer.device.deviceName) ? 403 mSelectedWifiPeer.device.deviceAddress : 404 mSelectedWifiPeer.device.deviceName; 405 String msg; 406 if (mConnectedDevices > 1) { 407 msg = getActivity().getString(R.string.wifi_p2p_disconnect_multiple_message, 408 deviceName, mConnectedDevices - 1); 409 } else { 410 msg = getActivity().getString(R.string.wifi_p2p_disconnect_message, deviceName); 411 } 412 AlertDialog dialog = new AlertDialog.Builder(getActivity()) 413 .setTitle(R.string.wifi_p2p_disconnect_title) 414 .setMessage(msg) 415 .setPositiveButton(getActivity().getString(R.string.dlg_ok), mDisconnectListener) 416 .setNegativeButton(getActivity().getString(R.string.dlg_cancel), null) 417 .create(); 418 return dialog; 419 } else if (id == DIALOG_CANCEL_CONNECT) { 420 int stringId = R.string.wifi_p2p_cancel_connect_message; 421 String deviceName = TextUtils.isEmpty(mSelectedWifiPeer.device.deviceName) ? 422 mSelectedWifiPeer.device.deviceAddress : 423 mSelectedWifiPeer.device.deviceName; 424 425 AlertDialog dialog = new AlertDialog.Builder(getActivity()) 426 .setTitle(R.string.wifi_p2p_cancel_connect_title) 427 .setMessage(getActivity().getString(stringId, deviceName)) 428 .setPositiveButton(getActivity().getString(R.string.dlg_ok), mCancelConnectListener) 429 .setNegativeButton(getActivity().getString(R.string.dlg_cancel), null) 430 .create(); 431 return dialog; 432 } else if (id == DIALOG_RENAME) { 433 mDeviceNameText = new EditText(getActivity()); 434 mDeviceNameText.setFilters(new InputFilter[] {new InputFilter.LengthFilter(30)}); 435 if (mSavedDeviceName != null) { 436 mDeviceNameText.setText(mSavedDeviceName); 437 mDeviceNameText.setSelection(mSavedDeviceName.length()); 438 } else if (mThisDevice != null && !TextUtils.isEmpty(mThisDevice.deviceName)) { 439 mDeviceNameText.setText(mThisDevice.deviceName); 440 mDeviceNameText.setSelection(0, mThisDevice.deviceName.length()); 441 } 442 mSavedDeviceName = null; 443 AlertDialog dialog = new AlertDialog.Builder(getActivity()) 444 .setTitle(R.string.wifi_p2p_menu_rename) 445 .setView(mDeviceNameText) 446 .setPositiveButton(getActivity().getString(R.string.dlg_ok), mRenameListener) 447 .setNegativeButton(getActivity().getString(R.string.dlg_cancel), null) 448 .create(); 449 return dialog; 450 } else if (id == DIALOG_DELETE_GROUP) { 451 int stringId = R.string.wifi_p2p_delete_group_message; 452 453 AlertDialog dialog = new AlertDialog.Builder(getActivity()) 454 .setMessage(getActivity().getString(stringId)) 455 .setPositiveButton(getActivity().getString(R.string.dlg_ok), mDeleteGroupListener) 456 .setNegativeButton(getActivity().getString(R.string.dlg_cancel), null) 457 .create(); 458 return dialog; 459 } 460 return null; 461 } 462 463 @Override 464 public void onSaveInstanceState(Bundle outState) { 465 if (mSelectedWifiPeer != null) { 466 outState.putParcelable(SAVE_DIALOG_PEER, mSelectedWifiPeer.device); 467 } 468 if (mDeviceNameText != null) { 469 outState.putString(SAVE_DEVICE_NAME, mDeviceNameText.getText().toString()); 470 } 471 } 472 473 private void handlePeersChanged() { 474 mPeersGroup.removeAll(); 475 476 mConnectedDevices = 0; 477 if (DBG) Log.d(TAG, "List of available peers"); 478 for (WifiP2pDevice peer: mPeers.getDeviceList()) { 479 if (DBG) Log.d(TAG, "-> " + peer); 480 mPeersGroup.addPreference(new WifiP2pPeer(getActivity(), peer)); 481 if (peer.status == WifiP2pDevice.CONNECTED) mConnectedDevices++; 482 } 483 if (DBG) Log.d(TAG, " mConnectedDevices " + mConnectedDevices); 484 } 485 486 public void onPersistentGroupInfoAvailable(WifiP2pGroupList groups) { 487 mPersistentGroup.removeAll(); 488 489 for (WifiP2pGroup group: groups.getGroupList()) { 490 if (DBG) Log.d(TAG, " group " + group); 491 mPersistentGroup.addPreference(new WifiP2pPersistentGroup(getActivity(), group)); 492 } 493 } 494 495 public void onGroupInfoAvailable(WifiP2pGroup group) { 496 if (DBG) Log.d(TAG, " group " + group); 497 mConnectedGroup = group; 498 updateDevicePref(); 499 } 500 501 private void handleP2pStateChanged() { 502 updateSearchMenu(false); 503 if (mWifiP2pEnabled) { 504 final PreferenceScreen preferenceScreen = getPreferenceScreen(); 505 preferenceScreen.removeAll(); 506 507 preferenceScreen.setOrderingAsAdded(true); 508 preferenceScreen.addPreference(mThisDevicePref); 509 510 mPeersGroup.setEnabled(true); 511 preferenceScreen.addPreference(mPeersGroup); 512 513 mPersistentGroup.setEnabled(true); 514 preferenceScreen.addPreference(mPersistentGroup); 515 } 516 } 517 518 private void updateSearchMenu(boolean searching) { 519 mWifiP2pSearching = searching; 520 Activity activity = getActivity(); 521 if (activity != null) activity.invalidateOptionsMenu(); 522 } 523 524 private void startSearch() { 525 if (mWifiP2pManager != null && !mWifiP2pSearching) { 526 mWifiP2pManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() { 527 public void onSuccess() { 528 } 529 public void onFailure(int reason) { 530 if (DBG) Log.d(TAG, " discover fail " + reason); 531 } 532 }); 533 } 534 } 535 536 private void updateDevicePref() { 537 if (mThisDevice != null) { 538 if (TextUtils.isEmpty(mThisDevice.deviceName)) { 539 mThisDevicePref.setTitle(mThisDevice.deviceAddress); 540 } else { 541 mThisDevicePref.setTitle(mThisDevice.deviceName); 542 } 543 544 mThisDevicePref.setPersistent(false); 545 mThisDevicePref.setEnabled(true); 546 mThisDevicePref.setSelectable(false); 547 } 548 } 549 } 550