WifiDisplaySettings.java revision 9a23adf69dc53126c9858b19760eab5b67c23b97
1/* 2 * Copyright (C) 2012 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 17package com.android.settings.wfd; 18 19import android.app.AlertDialog; 20import android.app.Service; 21import android.content.BroadcastReceiver; 22import android.content.Context; 23import android.content.DialogInterface; 24import android.content.Intent; 25import android.content.IntentFilter; 26import android.database.ContentObserver; 27import android.hardware.display.DisplayManager; 28import android.hardware.display.WifiDisplay; 29import android.hardware.display.WifiDisplayStatus; 30import android.media.MediaRouter; 31import android.media.MediaRouter.RouteInfo; 32import android.net.Uri; 33import android.net.wifi.p2p.WifiP2pManager; 34import android.net.wifi.p2p.WifiP2pManager.ActionListener; 35import android.net.wifi.p2p.WifiP2pManager.Channel; 36import android.net.wifi.WpsInfo; 37import android.os.Bundle; 38import android.os.Handler; 39import android.os.Looper; 40import android.preference.ListPreference; 41import android.preference.Preference; 42import android.preference.PreferenceCategory; 43import android.preference.PreferenceGroup; 44import android.preference.PreferenceScreen; 45import android.preference.SwitchPreference; 46import android.provider.Settings; 47import android.util.Slog; 48import android.util.TypedValue; 49import android.view.LayoutInflater; 50import android.view.Menu; 51import android.view.MenuInflater; 52import android.view.MenuItem; 53import android.view.View; 54import android.view.View.OnClickListener; 55import android.view.ViewGroup; 56import android.widget.Button; 57import android.widget.EditText; 58import android.widget.ImageView; 59import android.widget.TextView; 60 61import com.android.internal.app.MediaRouteDialogPresenter; 62import com.android.settings.R; 63import com.android.settings.SettingsPreferenceFragment; 64 65/** 66 * The Settings screen for WifiDisplay configuration and connection management. 67 * 68 * The wifi display routes are integrated together with other remote display routes 69 * from the media router. It may happen that wifi display isn't actually available 70 * on the system. In that case, the enable option will not be shown but other 71 * remote display routes will continue to be made available. 72 */ 73public final class WifiDisplaySettings extends SettingsPreferenceFragment { 74 private static final String TAG = "WifiDisplaySettings"; 75 private static final boolean DEBUG = false; 76 77 private static final int MENU_ID_ENABLE_WIFI_DISPLAY = Menu.FIRST; 78 79 private static final int CHANGE_SETTINGS = 1 << 0; 80 private static final int CHANGE_ROUTES = 1 << 1; 81 private static final int CHANGE_WIFI_DISPLAY_STATUS = 1 << 2; 82 private static final int CHANGE_ALL = -1; 83 84 private static final int ORDER_CERTIFICATION = 1; 85 private static final int ORDER_CONNECTED = 2; 86 private static final int ORDER_AVAILABLE = 3; 87 private static final int ORDER_UNAVAILABLE = 4; 88 89 private final Handler mHandler; 90 91 private MediaRouter mRouter; 92 private DisplayManager mDisplayManager; 93 94 private boolean mStarted; 95 private int mPendingChanges; 96 97 private boolean mWifiDisplayOnSetting; 98 private WifiDisplayStatus mWifiDisplayStatus; 99 100 private TextView mEmptyView; 101 102 /* certification */ 103 private boolean mWifiDisplayCertificationOn; 104 private WifiP2pManager mWifiP2pManager; 105 private Channel mWifiP2pChannel; 106 private PreferenceGroup mCertCategory; 107 private boolean mListen; 108 private boolean mAutoGO; 109 private int mWpsConfig = WpsInfo.INVALID; 110 private int mListenChannel; 111 private int mOperatingChannel; 112 113 public WifiDisplaySettings() { 114 mHandler = new Handler(); 115 } 116 117 @Override 118 public void onCreate(Bundle icicle) { 119 super.onCreate(icicle); 120 121 final Context context = getActivity(); 122 mRouter = (MediaRouter)context.getSystemService(Context.MEDIA_ROUTER_SERVICE); 123 mDisplayManager = (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE); 124 mWifiP2pManager = (WifiP2pManager)context.getSystemService(Context.WIFI_P2P_SERVICE); 125 mWifiP2pChannel = mWifiP2pManager.initialize(context, Looper.getMainLooper(), null); 126 127 addPreferencesFromResource(R.xml.wifi_display_settings); 128 setHasOptionsMenu(true); 129 } 130 131 @Override 132 protected int getHelpResource() { 133 return R.string.help_url_remote_display; 134 } 135 136 @Override 137 public void onActivityCreated(Bundle savedInstanceState) { 138 super.onActivityCreated(savedInstanceState); 139 140 mEmptyView = (TextView) getView().findViewById(android.R.id.empty); 141 mEmptyView.setText(R.string.wifi_display_no_devices_found); 142 getListView().setEmptyView(mEmptyView); 143 } 144 145 @Override 146 public void onStart() { 147 super.onStart(); 148 mStarted = true; 149 150 final Context context = getActivity(); 151 IntentFilter filter = new IntentFilter(); 152 filter.addAction(DisplayManager.ACTION_WIFI_DISPLAY_STATUS_CHANGED); 153 context.registerReceiver(mReceiver, filter); 154 155 getContentResolver().registerContentObserver(Settings.Global.getUriFor( 156 Settings.Global.WIFI_DISPLAY_ON), false, mSettingsObserver); 157 getContentResolver().registerContentObserver(Settings.Global.getUriFor( 158 Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON), false, mSettingsObserver); 159 getContentResolver().registerContentObserver(Settings.Global.getUriFor( 160 Settings.Global.WIFI_DISPLAY_WPS_CONFIG), false, mSettingsObserver); 161 162 mRouter.addCallback(MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY, mRouterCallback, 163 MediaRouter.CALLBACK_FLAG_PERFORM_ACTIVE_SCAN); 164 165 update(CHANGE_ALL); 166 } 167 168 @Override 169 public void onStop() { 170 super.onStop(); 171 mStarted = false; 172 173 final Context context = getActivity(); 174 context.unregisterReceiver(mReceiver); 175 176 getContentResolver().unregisterContentObserver(mSettingsObserver); 177 178 mRouter.removeCallback(mRouterCallback); 179 180 unscheduleUpdate(); 181 } 182 183 @Override 184 public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { 185 if (mWifiDisplayStatus != null && mWifiDisplayStatus.getFeatureState() 186 != WifiDisplayStatus.FEATURE_STATE_UNAVAILABLE) { 187 MenuItem item = menu.add(Menu.NONE, MENU_ID_ENABLE_WIFI_DISPLAY, 0, 188 R.string.wifi_display_enable_menu_item); 189 item.setCheckable(true); 190 item.setChecked(mWifiDisplayOnSetting); 191 } 192 super.onCreateOptionsMenu(menu, inflater); 193 } 194 195 @Override 196 public boolean onOptionsItemSelected(MenuItem item) { 197 switch (item.getItemId()) { 198 case MENU_ID_ENABLE_WIFI_DISPLAY: 199 mWifiDisplayOnSetting = !item.isChecked(); 200 item.setChecked(mWifiDisplayOnSetting); 201 Settings.Global.putInt(getContentResolver(), 202 Settings.Global.WIFI_DISPLAY_ON, mWifiDisplayOnSetting ? 1 : 0); 203 return true; 204 } 205 return super.onOptionsItemSelected(item); 206 } 207 208 private void scheduleUpdate(int changes) { 209 if (mStarted) { 210 if (mPendingChanges == 0) { 211 mHandler.post(mUpdateRunnable); 212 } 213 mPendingChanges |= changes; 214 } 215 } 216 217 private void unscheduleUpdate() { 218 if (mPendingChanges != 0) { 219 mPendingChanges = 0; 220 mHandler.removeCallbacks(mUpdateRunnable); 221 } 222 } 223 224 private void update(int changes) { 225 boolean invalidateOptions = false; 226 227 // Update settings. 228 if ((changes & CHANGE_SETTINGS) != 0) { 229 mWifiDisplayOnSetting = Settings.Global.getInt(getContentResolver(), 230 Settings.Global.WIFI_DISPLAY_ON, 0) != 0; 231 mWifiDisplayCertificationOn = Settings.Global.getInt(getContentResolver(), 232 Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON, 0) != 0; 233 mWpsConfig = Settings.Global.getInt(getContentResolver(), 234 Settings.Global.WIFI_DISPLAY_WPS_CONFIG, WpsInfo.INVALID); 235 236 // The wifi display enabled setting may have changed. 237 invalidateOptions = true; 238 } 239 240 // Update wifi display state. 241 if ((changes & CHANGE_WIFI_DISPLAY_STATUS) != 0) { 242 mWifiDisplayStatus = mDisplayManager.getWifiDisplayStatus(); 243 244 // The wifi display feature state may have changed. 245 invalidateOptions = true; 246 } 247 248 // Rebuild the routes. 249 final PreferenceScreen preferenceScreen = getPreferenceScreen(); 250 preferenceScreen.removeAll(); 251 252 // Add all known remote display routes. 253 final int routeCount = mRouter.getRouteCount(); 254 for (int i = 0; i < routeCount; i++) { 255 MediaRouter.RouteInfo route = mRouter.getRouteAt(i); 256 if (route.matchesTypes(MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY)) { 257 preferenceScreen.addPreference(createRoutePreference(route)); 258 } 259 } 260 261 // Additional features for wifi display routes. 262 if (mWifiDisplayStatus != null 263 && mWifiDisplayStatus.getFeatureState() == WifiDisplayStatus.FEATURE_STATE_ON) { 264 // Add all unpaired wifi displays. 265 for (WifiDisplay display : mWifiDisplayStatus.getDisplays()) { 266 if (!display.isRemembered() && display.isAvailable() 267 && !display.equals(mWifiDisplayStatus.getActiveDisplay())) { 268 preferenceScreen.addPreference(new UnpairedWifiDisplayPreference( 269 getActivity(), display)); 270 } 271 } 272 273 // Add the certification menu if enabled in developer options. 274 if (mWifiDisplayCertificationOn) { 275 buildCertificationMenu(preferenceScreen); 276 } 277 } 278 279 // Invalidate menu options if needed. 280 if (invalidateOptions) { 281 getActivity().invalidateOptionsMenu(); 282 } 283 } 284 285 private RoutePreference createRoutePreference(MediaRouter.RouteInfo route) { 286 WifiDisplay display = findWifiDisplay(route.getDeviceAddress()); 287 if (display != null) { 288 return new WifiDisplayRoutePreference(getActivity(), route, display); 289 } else { 290 return new RoutePreference(getActivity(), route); 291 } 292 } 293 294 private WifiDisplay findWifiDisplay(String deviceAddress) { 295 if (mWifiDisplayStatus != null && deviceAddress != null) { 296 for (WifiDisplay display : mWifiDisplayStatus.getDisplays()) { 297 if (display.getDeviceAddress().equals(deviceAddress)) { 298 return display; 299 } 300 } 301 } 302 return null; 303 } 304 305 private void buildCertificationMenu(final PreferenceScreen preferenceScreen) { 306 if (mCertCategory == null) { 307 mCertCategory = new PreferenceCategory(getActivity()); 308 mCertCategory.setTitle(R.string.wifi_display_certification_heading); 309 mCertCategory.setOrder(ORDER_CERTIFICATION); 310 } else { 311 mCertCategory.removeAll(); 312 } 313 preferenceScreen.addPreference(mCertCategory); 314 315 // display session info if there is an active p2p session 316 if (!mWifiDisplayStatus.getSessionInfo().getGroupId().isEmpty()) { 317 Preference p = new Preference(getActivity()); 318 p.setTitle(R.string.wifi_display_session_info); 319 p.setSummary(mWifiDisplayStatus.getSessionInfo().toString()); 320 mCertCategory.addPreference(p); 321 322 // show buttons for Pause/Resume when a WFD session is established 323 if (mWifiDisplayStatus.getSessionInfo().getSessionId() != 0) { 324 mCertCategory.addPreference(new Preference(getActivity()) { 325 @Override 326 public View getView(View convertView, ViewGroup parent) { 327 final View v; 328 if (convertView == null) { 329 LayoutInflater li = (LayoutInflater) getActivity(). 330 getSystemService(Service.LAYOUT_INFLATER_SERVICE); 331 v = li.inflate(R.layout.two_buttons_panel, null); 332 } else { 333 v = convertView; 334 } 335 336 Button b = (Button)v.findViewById(R.id.left_button); 337 b.setText(R.string.wifi_display_pause); 338 b.setOnClickListener(new OnClickListener() { 339 @Override 340 public void onClick(View v) { 341 mDisplayManager.pauseWifiDisplay(); 342 } 343 }); 344 345 b = (Button)v.findViewById(R.id.right_button); 346 b.setText(R.string.wifi_display_resume); 347 b.setOnClickListener(new OnClickListener() { 348 @Override 349 public void onClick(View v) { 350 mDisplayManager.resumeWifiDisplay(); 351 } 352 }); 353 354 return v; 355 } 356 }); 357 } 358 } 359 360 // switch for Listen Mode 361 SwitchPreference pref = new SwitchPreference(getActivity()) { 362 @Override 363 protected void onClick() { 364 mListen = !mListen; 365 setListenMode(mListen); 366 setChecked(mListen); 367 } 368 }; 369 pref.setTitle(R.string.wifi_display_listen_mode); 370 pref.setChecked(mListen); 371 mCertCategory.addPreference(pref); 372 373 // switch for Autonomous GO 374 pref = new SwitchPreference(getActivity()) { 375 @Override 376 protected void onClick() { 377 mAutoGO = !mAutoGO; 378 if (mAutoGO) { 379 startAutoGO(); 380 } else { 381 stopAutoGO(); 382 } 383 setChecked(mAutoGO); 384 } 385 }; 386 pref.setTitle(R.string.wifi_display_autonomous_go); 387 pref.setChecked(mAutoGO); 388 mCertCategory.addPreference(pref); 389 390 // Drop down list for choosing WPS method (PBC/KEYPAD/DISPLAY) 391 ListPreference lp = new ListPreference(getActivity()) { 392 @Override 393 protected void onDialogClosed(boolean positiveResult) { 394 super.onDialogClosed(positiveResult); 395 if (positiveResult) { 396 mWpsConfig = Integer.parseInt(getValue()); 397 setSummary("%1$s"); 398 getActivity().invalidateOptionsMenu(); 399 Settings.Global.putInt(getActivity().getContentResolver(), 400 Settings.Global.WIFI_DISPLAY_WPS_CONFIG, mWpsConfig); 401 } 402 } 403 }; 404 mWpsConfig = Settings.Global.getInt(getActivity().getContentResolver(), 405 Settings.Global.WIFI_DISPLAY_WPS_CONFIG, WpsInfo.INVALID); 406 String[] wpsEntries = { "Default", "PBC", "KEYPAD", "DISPLAY" }; 407 String[] wpsValues = { 408 "" + WpsInfo.INVALID, 409 "" + WpsInfo.PBC, 410 "" + WpsInfo.KEYPAD, 411 "" + WpsInfo.DISPLAY }; 412 lp.setTitle(R.string.wifi_display_wps_config); 413 lp.setEntries(wpsEntries); 414 lp.setEntryValues(wpsValues); 415 lp.setValue("" + mWpsConfig); 416 lp.setSummary("%1$s"); 417 mCertCategory.addPreference(lp); 418 419 // Drop down list for choosing listen channel 420 lp = new ListPreference(getActivity()) { 421 @Override 422 protected void onDialogClosed(boolean positiveResult) { 423 super.onDialogClosed(positiveResult); 424 if (positiveResult) { 425 mListenChannel = Integer.parseInt(getValue()); 426 setSummary("%1$s"); 427 getActivity().invalidateOptionsMenu(); 428 setWifiP2pChannels(mListenChannel, mOperatingChannel); 429 } 430 } 431 }; 432 String[] lcEntries = { "Auto", "1", "6", "11" }; 433 String[] lcValues = { "0", "1", "6", "11" }; 434 lp.setTitle(R.string.wifi_display_listen_channel); 435 lp.setEntries(lcEntries); 436 lp.setEntryValues(lcValues); 437 lp.setValue("" + mListenChannel); 438 lp.setSummary("%1$s"); 439 mCertCategory.addPreference(lp); 440 441 // Drop down list for choosing operating channel 442 lp = new ListPreference(getActivity()) { 443 @Override 444 protected void onDialogClosed(boolean positiveResult) { 445 super.onDialogClosed(positiveResult); 446 if (positiveResult) { 447 mOperatingChannel = Integer.parseInt(getValue()); 448 setSummary("%1$s"); 449 getActivity().invalidateOptionsMenu(); 450 setWifiP2pChannels(mListenChannel, mOperatingChannel); 451 } 452 } 453 }; 454 String[] ocEntries = { "Auto", "1", "6", "11", "36" }; 455 String[] ocValues = { "0", "1", "6", "11", "36" }; 456 lp.setTitle(R.string.wifi_display_operating_channel); 457 lp.setEntries(ocEntries); 458 lp.setEntryValues(ocValues); 459 lp.setValue("" + mOperatingChannel); 460 lp.setSummary("%1$s"); 461 mCertCategory.addPreference(lp); 462 } 463 464 private void startAutoGO() { 465 if (DEBUG) { 466 Slog.d(TAG, "Starting Autonomous GO..."); 467 } 468 mWifiP2pManager.createGroup(mWifiP2pChannel, new ActionListener() { 469 @Override 470 public void onSuccess() { 471 if (DEBUG) { 472 Slog.d(TAG, "Successfully started AutoGO."); 473 } 474 } 475 476 @Override 477 public void onFailure(int reason) { 478 Slog.e(TAG, "Failed to start AutoGO with reason " + reason + "."); 479 } 480 }); 481 } 482 483 private void stopAutoGO() { 484 if (DEBUG) { 485 Slog.d(TAG, "Stopping Autonomous GO..."); 486 } 487 mWifiP2pManager.removeGroup(mWifiP2pChannel, new ActionListener() { 488 @Override 489 public void onSuccess() { 490 if (DEBUG) { 491 Slog.d(TAG, "Successfully stopped AutoGO."); 492 } 493 } 494 495 @Override 496 public void onFailure(int reason) { 497 Slog.e(TAG, "Failed to stop AutoGO with reason " + reason + "."); 498 } 499 }); 500 } 501 502 private void setListenMode(final boolean enable) { 503 if (DEBUG) { 504 Slog.d(TAG, "Setting listen mode to: " + enable); 505 } 506 mWifiP2pManager.listen(mWifiP2pChannel, enable, new ActionListener() { 507 @Override 508 public void onSuccess() { 509 if (DEBUG) { 510 Slog.d(TAG, "Successfully " + (enable ? "entered" : "exited") 511 +" listen mode."); 512 } 513 } 514 515 @Override 516 public void onFailure(int reason) { 517 Slog.e(TAG, "Failed to " + (enable ? "entered" : "exited") 518 +" listen mode with reason " + reason + "."); 519 } 520 }); 521 } 522 523 private void setWifiP2pChannels(final int lc, final int oc) { 524 if (DEBUG) { 525 Slog.d(TAG, "Setting wifi p2p channel: lc=" + lc + ", oc=" + oc); 526 } 527 mWifiP2pManager.setWifiP2pChannels(mWifiP2pChannel, 528 lc, oc, new ActionListener() { 529 @Override 530 public void onSuccess() { 531 if (DEBUG) { 532 Slog.d(TAG, "Successfully set wifi p2p channels."); 533 } 534 } 535 536 @Override 537 public void onFailure(int reason) { 538 Slog.e(TAG, "Failed to set wifi p2p channels with reason " + reason + "."); 539 } 540 }); 541 } 542 543 private void toggleRoute(MediaRouter.RouteInfo route) { 544 if (route.isSelected()) { 545 MediaRouteDialogPresenter.showDialogFragment(getActivity(), 546 MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY, null); 547 } else { 548 route.select(); 549 } 550 } 551 552 private void pairWifiDisplay(WifiDisplay display) { 553 if (display.canConnect()) { 554 mDisplayManager.connectWifiDisplay(display.getDeviceAddress()); 555 } 556 } 557 558 private void showWifiDisplayOptionsDialog(final WifiDisplay display) { 559 View view = getActivity().getLayoutInflater().inflate(R.layout.wifi_display_options, null); 560 final EditText nameEditText = (EditText)view.findViewById(R.id.name); 561 nameEditText.setText(display.getFriendlyDisplayName()); 562 563 DialogInterface.OnClickListener done = new DialogInterface.OnClickListener() { 564 @Override 565 public void onClick(DialogInterface dialog, int which) { 566 String name = nameEditText.getText().toString().trim(); 567 if (name.isEmpty() || name.equals(display.getDeviceName())) { 568 name = null; 569 } 570 mDisplayManager.renameWifiDisplay(display.getDeviceAddress(), name); 571 } 572 }; 573 DialogInterface.OnClickListener forget = new DialogInterface.OnClickListener() { 574 @Override 575 public void onClick(DialogInterface dialog, int which) { 576 mDisplayManager.forgetWifiDisplay(display.getDeviceAddress()); 577 } 578 }; 579 580 AlertDialog dialog = new AlertDialog.Builder(getActivity()) 581 .setCancelable(true) 582 .setTitle(R.string.wifi_display_options_title) 583 .setView(view) 584 .setPositiveButton(R.string.wifi_display_options_done, done) 585 .setNegativeButton(R.string.wifi_display_options_forget, forget) 586 .create(); 587 dialog.show(); 588 } 589 590 private final Runnable mUpdateRunnable = new Runnable() { 591 @Override 592 public void run() { 593 final int changes = mPendingChanges; 594 mPendingChanges = 0; 595 update(changes); 596 } 597 }; 598 599 private final BroadcastReceiver mReceiver = new BroadcastReceiver() { 600 @Override 601 public void onReceive(Context context, Intent intent) { 602 String action = intent.getAction(); 603 if (action.equals(DisplayManager.ACTION_WIFI_DISPLAY_STATUS_CHANGED)) { 604 scheduleUpdate(CHANGE_WIFI_DISPLAY_STATUS); 605 } 606 } 607 }; 608 609 private final ContentObserver mSettingsObserver = new ContentObserver(new Handler()) { 610 @Override 611 public void onChange(boolean selfChange, Uri uri) { 612 scheduleUpdate(CHANGE_SETTINGS); 613 } 614 }; 615 616 private final MediaRouter.Callback mRouterCallback = new MediaRouter.SimpleCallback() { 617 @Override 618 public void onRouteAdded(MediaRouter router, RouteInfo info) { 619 scheduleUpdate(CHANGE_ROUTES); 620 } 621 622 @Override 623 public void onRouteChanged(MediaRouter router, RouteInfo info) { 624 scheduleUpdate(CHANGE_ROUTES); 625 } 626 627 @Override 628 public void onRouteRemoved(MediaRouter router, RouteInfo info) { 629 scheduleUpdate(CHANGE_ROUTES); 630 } 631 632 @Override 633 public void onRouteSelected(MediaRouter router, int type, RouteInfo info) { 634 scheduleUpdate(CHANGE_ROUTES); 635 } 636 637 @Override 638 public void onRouteUnselected(MediaRouter router, int type, RouteInfo info) { 639 scheduleUpdate(CHANGE_ROUTES); 640 } 641 }; 642 643 private class RoutePreference extends Preference 644 implements Preference.OnPreferenceClickListener { 645 private final MediaRouter.RouteInfo mRoute; 646 647 public RoutePreference(Context context, MediaRouter.RouteInfo route) { 648 super(context); 649 650 mRoute = route; 651 setTitle(route.getName()); 652 setSummary(route.getDescription()); 653 setEnabled(route.isEnabled()); 654 if (route.isSelected()) { 655 setOrder(ORDER_CONNECTED); 656 if (route.isConnecting()) { 657 setSummary(R.string.wifi_display_status_connecting); 658 } else { 659 setSummary(R.string.wifi_display_status_connected); 660 } 661 } else { 662 if (isEnabled()) { 663 setOrder(ORDER_AVAILABLE); 664 } else { 665 setOrder(ORDER_UNAVAILABLE); 666 if (route.getStatusCode() == MediaRouter.RouteInfo.STATUS_IN_USE) { 667 setSummary(R.string.wifi_display_status_in_use); 668 } else { 669 setSummary(R.string.wifi_display_status_not_available); 670 } 671 } 672 } 673 setOnPreferenceClickListener(this); 674 } 675 676 @Override 677 public boolean onPreferenceClick(Preference preference) { 678 toggleRoute(mRoute); 679 return true; 680 } 681 } 682 683 private class WifiDisplayRoutePreference extends RoutePreference 684 implements View.OnClickListener { 685 private final WifiDisplay mDisplay; 686 687 public WifiDisplayRoutePreference(Context context, MediaRouter.RouteInfo route, 688 WifiDisplay display) { 689 super(context, route); 690 691 mDisplay = display; 692 setWidgetLayoutResource(R.layout.wifi_display_preference); 693 } 694 695 @Override 696 protected void onBindView(View view) { 697 super.onBindView(view); 698 699 ImageView deviceDetails = (ImageView) view.findViewById(R.id.deviceDetails); 700 if (deviceDetails != null) { 701 deviceDetails.setOnClickListener(this); 702 if (!isEnabled()) { 703 TypedValue value = new TypedValue(); 704 getContext().getTheme().resolveAttribute(android.R.attr.disabledAlpha, 705 value, true); 706 deviceDetails.setImageAlpha((int)(value.getFloat() * 255)); 707 deviceDetails.setEnabled(true); // always allow button to be pressed 708 } 709 } 710 } 711 712 @Override 713 public void onClick(View v) { 714 showWifiDisplayOptionsDialog(mDisplay); 715 } 716 } 717 718 private class UnpairedWifiDisplayPreference extends Preference 719 implements Preference.OnPreferenceClickListener { 720 private final WifiDisplay mDisplay; 721 722 public UnpairedWifiDisplayPreference(Context context, WifiDisplay display) { 723 super(context); 724 725 mDisplay = display; 726 setTitle(display.getFriendlyDisplayName()); 727 setSummary(com.android.internal.R.string.wireless_display_route_description); 728 setEnabled(display.canConnect()); 729 if (isEnabled()) { 730 setOrder(ORDER_AVAILABLE); 731 } else { 732 setOrder(ORDER_UNAVAILABLE); 733 setSummary(R.string.wifi_display_status_in_use); 734 } 735 setOnPreferenceClickListener(this); 736 } 737 738 @Override 739 public boolean onPreferenceClick(Preference preference) { 740 pairWifiDisplay(mDisplay); 741 return true; 742 } 743 } 744} 745