/* * Copyright (C) 2012 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 com.android.settings.wfd; import android.app.settings.SettingsEnums; import android.content.BroadcastReceiver; import android.content.Context; import android.content.DialogInterface; import android.content.Intent; import android.content.IntentFilter; import android.content.pm.PackageManager; import android.database.ContentObserver; import android.hardware.display.DisplayManager; import android.hardware.display.WifiDisplay; import android.hardware.display.WifiDisplayStatus; import android.media.MediaRouter; import android.media.MediaRouter.RouteInfo; import android.net.Uri; import android.net.wifi.WpsInfo; import android.net.wifi.p2p.WifiP2pManager; import android.net.wifi.p2p.WifiP2pManager.ActionListener; import android.net.wifi.p2p.WifiP2pManager.Channel; import android.os.Bundle; import android.os.Handler; import android.os.Looper; import android.provider.Settings; import android.text.TextUtils; import android.util.Slog; import android.util.TypedValue; import android.view.Menu; import android.view.MenuInflater; import android.view.MenuItem; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.EditText; import android.widget.ImageView; import android.widget.TextView; import androidx.appcompat.app.AlertDialog; import androidx.preference.ListPreference; import androidx.preference.Preference; import androidx.preference.Preference.OnPreferenceChangeListener; import androidx.preference.PreferenceCategory; import androidx.preference.PreferenceGroup; import androidx.preference.PreferenceScreen; import androidx.preference.PreferenceViewHolder; import androidx.preference.SwitchPreferenceCompat; import androidx.preference.TwoStatePreference; import com.android.internal.app.MediaRouteDialogPresenter; import com.android.settings.R; import com.android.settings.SettingsPreferenceFragment; import com.android.settings.search.BaseSearchIndexProvider; import com.android.settingslib.search.Indexable; import com.android.settingslib.search.SearchIndexable; import com.android.settingslib.widget.TwoTargetPreference; /** * The Settings screen for WifiDisplay configuration and connection management. * * The wifi display routes are integrated together with other remote display routes * from the media router. It may happen that wifi display isn't actually available * on the system. In that case, the enable option will not be shown but other * remote display routes will continue to be made available. */ @SearchIndexable(forTarget = SearchIndexable.ALL & ~SearchIndexable.ARC) public final class WifiDisplaySettings extends SettingsPreferenceFragment implements Indexable { private static final String TAG = "WifiDisplaySettings"; private static final boolean DEBUG = false; private static final int MENU_ID_ENABLE_WIFI_DISPLAY = Menu.FIRST; private static final int CHANGE_SETTINGS = 1 << 0; private static final int CHANGE_ROUTES = 1 << 1; private static final int CHANGE_WIFI_DISPLAY_STATUS = 1 << 2; private static final int CHANGE_ALL = -1; private static final int ORDER_CERTIFICATION = 1; private static final int ORDER_CONNECTED = 2; private static final int ORDER_AVAILABLE = 3; private static final int ORDER_UNAVAILABLE = 4; private final Handler mHandler; private MediaRouter mRouter; private DisplayManager mDisplayManager; private boolean mStarted; private int mPendingChanges; private boolean mWifiDisplayOnSetting; private WifiDisplayStatus mWifiDisplayStatus; private TextView mEmptyView; /* certification */ private boolean mWifiDisplayCertificationOn; private WifiP2pManager mWifiP2pManager; private Channel mWifiP2pChannel; private PreferenceGroup mCertCategory; private boolean mListen; private boolean mAutoGO; private int mWpsConfig = WpsInfo.INVALID; private int mListenChannel; private int mOperatingChannel; public WifiDisplaySettings() { mHandler = new Handler(); } @Override public int getMetricsCategory() { return SettingsEnums.WFD_WIFI_DISPLAY; } @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); final Context context = getActivity(); mRouter = (MediaRouter) context.getSystemService(Context.MEDIA_ROUTER_SERVICE); mRouter.setRouterGroupId(MediaRouter.MIRRORING_GROUP_ID); mDisplayManager = (DisplayManager) context.getSystemService(Context.DISPLAY_SERVICE); mWifiP2pManager = (WifiP2pManager) context.getSystemService(Context.WIFI_P2P_SERVICE); mWifiP2pChannel = mWifiP2pManager.initialize(context, Looper.getMainLooper(), null); addPreferencesFromResource(R.xml.wifi_display_settings); } @Override public int getHelpResource() { return R.string.help_url_remote_display; } @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); mEmptyView = (TextView) getView().findViewById(android.R.id.empty); mEmptyView.setText(R.string.wifi_display_no_devices_found); setEmptyView(mEmptyView); } @Override public void onStart() { super.onStart(); mStarted = true; final Context context = getActivity(); IntentFilter filter = new IntentFilter(); filter.addAction(DisplayManager.ACTION_WIFI_DISPLAY_STATUS_CHANGED); context.registerReceiver(mReceiver, filter); getContentResolver().registerContentObserver(Settings.Global.getUriFor( Settings.Global.WIFI_DISPLAY_ON), false, mSettingsObserver); getContentResolver().registerContentObserver(Settings.Global.getUriFor( Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON), false, mSettingsObserver); getContentResolver().registerContentObserver(Settings.Global.getUriFor( Settings.Global.WIFI_DISPLAY_WPS_CONFIG), false, mSettingsObserver); mRouter.addCallback(MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY, mRouterCallback, MediaRouter.CALLBACK_FLAG_PERFORM_ACTIVE_SCAN); update(CHANGE_ALL); } @Override public void onStop() { super.onStop(); mStarted = false; final Context context = getActivity(); context.unregisterReceiver(mReceiver); getContentResolver().unregisterContentObserver(mSettingsObserver); mRouter.removeCallback(mRouterCallback); unscheduleUpdate(); } @Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { if (getResources().getBoolean(R.bool.config_show_wifi_display_enable_menu) && mWifiDisplayStatus != null && mWifiDisplayStatus.getFeatureState() != WifiDisplayStatus.FEATURE_STATE_UNAVAILABLE) { MenuItem item = menu.add(Menu.NONE, MENU_ID_ENABLE_WIFI_DISPLAY, 0, R.string.wifi_display_enable_menu_item); item.setCheckable(true); item.setChecked(mWifiDisplayOnSetting); } super.onCreateOptionsMenu(menu, inflater); } @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case MENU_ID_ENABLE_WIFI_DISPLAY: mWifiDisplayOnSetting = !item.isChecked(); item.setChecked(mWifiDisplayOnSetting); Settings.Global.putInt(getContentResolver(), Settings.Global.WIFI_DISPLAY_ON, mWifiDisplayOnSetting ? 1 : 0); return true; } return super.onOptionsItemSelected(item); } public static boolean isAvailable(Context context) { return context.getSystemService(Context.DISPLAY_SERVICE) != null && context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI_DIRECT) && context.getSystemService(Context.WIFI_P2P_SERVICE) != null; } private void scheduleUpdate(int changes) { if (mStarted) { if (mPendingChanges == 0) { mHandler.post(mUpdateRunnable); } mPendingChanges |= changes; } } private void unscheduleUpdate() { if (mPendingChanges != 0) { mPendingChanges = 0; mHandler.removeCallbacks(mUpdateRunnable); } } private void update(int changes) { boolean invalidateOptions = false; // Update settings. if ((changes & CHANGE_SETTINGS) != 0) { mWifiDisplayOnSetting = Settings.Global.getInt(getContentResolver(), Settings.Global.WIFI_DISPLAY_ON, 0) != 0; mWifiDisplayCertificationOn = Settings.Global.getInt(getContentResolver(), Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON, 0) != 0; mWpsConfig = Settings.Global.getInt(getContentResolver(), Settings.Global.WIFI_DISPLAY_WPS_CONFIG, WpsInfo.INVALID); // The wifi display enabled setting may have changed. invalidateOptions = true; } // Update wifi display state. if ((changes & CHANGE_WIFI_DISPLAY_STATUS) != 0) { mWifiDisplayStatus = mDisplayManager.getWifiDisplayStatus(); // The wifi display feature state may have changed. invalidateOptions = true; } // Rebuild the routes. final PreferenceScreen preferenceScreen = getPreferenceScreen(); preferenceScreen.removeAll(); // Add all known remote display routes. final int routeCount = mRouter.getRouteCount(); for (int i = 0; i < routeCount; i++) { MediaRouter.RouteInfo route = mRouter.getRouteAt(i); if (route.matchesTypes(MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY)) { preferenceScreen.addPreference(createRoutePreference(route)); } } // Additional features for wifi display routes. if (mWifiDisplayStatus != null && mWifiDisplayStatus.getFeatureState() == WifiDisplayStatus.FEATURE_STATE_ON) { // Add all unpaired wifi displays. for (WifiDisplay display : mWifiDisplayStatus.getDisplays()) { if (!display.isRemembered() && display.isAvailable() && !display.equals(mWifiDisplayStatus.getActiveDisplay())) { preferenceScreen.addPreference(new UnpairedWifiDisplayPreference( getPrefContext(), display)); } } // Add the certification menu if enabled in developer options. if (mWifiDisplayCertificationOn) { buildCertificationMenu(preferenceScreen); } } // Invalidate menu options if needed. if (invalidateOptions) { getActivity().invalidateOptionsMenu(); } } private RoutePreference createRoutePreference(MediaRouter.RouteInfo route) { WifiDisplay display = findWifiDisplay(route.getDeviceAddress()); if (display != null) { return new WifiDisplayRoutePreference(getPrefContext(), route, display); } else { return new RoutePreference(getPrefContext(), route); } } private WifiDisplay findWifiDisplay(String deviceAddress) { if (mWifiDisplayStatus != null && deviceAddress != null) { for (WifiDisplay display : mWifiDisplayStatus.getDisplays()) { if (display.getDeviceAddress().equals(deviceAddress)) { return display; } } } return null; } private void buildCertificationMenu(final PreferenceScreen preferenceScreen) { if (mCertCategory == null) { mCertCategory = new PreferenceCategory(getPrefContext()); mCertCategory.setTitle(R.string.wifi_display_certification_heading); mCertCategory.setOrder(ORDER_CERTIFICATION); } else { mCertCategory.removeAll(); } preferenceScreen.addPreference(mCertCategory); // display session info if there is an active p2p session if (!mWifiDisplayStatus.getSessionInfo().getGroupId().isEmpty()) { Preference p = new Preference(getPrefContext()); p.setTitle(R.string.wifi_display_session_info); p.setSummary(mWifiDisplayStatus.getSessionInfo().toString()); mCertCategory.addPreference(p); // show buttons for Pause/Resume when a WFD session is established if (mWifiDisplayStatus.getSessionInfo().getSessionId() != 0) { mCertCategory.addPreference(new Preference(getPrefContext()) { @Override public void onBindViewHolder(PreferenceViewHolder view) { super.onBindViewHolder(view); Button b = (Button) view.findViewById(R.id.left_button); b.setText(R.string.wifi_display_pause); b.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { mDisplayManager.pauseWifiDisplay(); } }); b = (Button) view.findViewById(R.id.right_button); b.setText(R.string.wifi_display_resume); b.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { mDisplayManager.resumeWifiDisplay(); } }); } }); mCertCategory.setLayoutResource(R.layout.two_buttons_panel); } } // switch for Listen Mode TwoStatePreference pref = new SwitchPreferenceCompat(getPrefContext()) { @Override protected void onClick() { mListen = !mListen; setListenMode(mListen); setChecked(mListen); } }; pref.setTitle(R.string.wifi_display_listen_mode); pref.setChecked(mListen); mCertCategory.addPreference(pref); // switch for Autonomous GO pref = new SwitchPreferenceCompat(getPrefContext()) { @Override protected void onClick() { mAutoGO = !mAutoGO; if (mAutoGO) { startAutoGO(); } else { stopAutoGO(); } setChecked(mAutoGO); } }; pref.setTitle(R.string.wifi_display_autonomous_go); pref.setChecked(mAutoGO); mCertCategory.addPreference(pref); // Drop down list for choosing WPS method (PBC/KEYPAD/DISPLAY) ListPreference lp = new ListPreference(getPrefContext()); lp.setOnPreferenceChangeListener(new OnPreferenceChangeListener() { @Override public boolean onPreferenceChange(Preference preference, Object value) { int wpsConfig = Integer.parseInt((String) value); if (wpsConfig != mWpsConfig) { mWpsConfig = wpsConfig; getActivity().invalidateOptionsMenu(); Settings.Global.putInt(getActivity().getContentResolver(), Settings.Global.WIFI_DISPLAY_WPS_CONFIG, mWpsConfig); } return true; } }); mWpsConfig = Settings.Global.getInt(getActivity().getContentResolver(), Settings.Global.WIFI_DISPLAY_WPS_CONFIG, WpsInfo.INVALID); String[] wpsEntries = {"Default", "PBC", "KEYPAD", "DISPLAY"}; String[] wpsValues = { "" + WpsInfo.INVALID, "" + WpsInfo.PBC, "" + WpsInfo.KEYPAD, "" + WpsInfo.DISPLAY}; lp.setKey("wps"); lp.setTitle(R.string.wifi_display_wps_config); lp.setEntries(wpsEntries); lp.setEntryValues(wpsValues); lp.setValue("" + mWpsConfig); lp.setSummary("%1$s"); mCertCategory.addPreference(lp); // Drop down list for choosing listen channel lp = new ListPreference(getPrefContext()); lp.setOnPreferenceChangeListener(new OnPreferenceChangeListener() { @Override public boolean onPreferenceChange(Preference preference, Object value) { int channel = Integer.parseInt((String) value); if (channel != mListenChannel) { mListenChannel = channel; getActivity().invalidateOptionsMenu(); setWifiP2pChannels(mListenChannel, mOperatingChannel); } return true; } }); String[] lcEntries = {"Auto", "1", "6", "11"}; String[] lcValues = {"0", "1", "6", "11"}; lp.setKey("listening_channel"); lp.setTitle(R.string.wifi_display_listen_channel); lp.setEntries(lcEntries); lp.setEntryValues(lcValues); lp.setValue("" + mListenChannel); lp.setSummary("%1$s"); mCertCategory.addPreference(lp); // Drop down list for choosing operating channel lp = new ListPreference(getPrefContext()); lp.setOnPreferenceChangeListener(new OnPreferenceChangeListener() { @Override public boolean onPreferenceChange(Preference preference, Object value) { int channel = Integer.parseInt((String) value); if (channel != mOperatingChannel) { mOperatingChannel = channel; getActivity().invalidateOptionsMenu(); setWifiP2pChannels(mListenChannel, mOperatingChannel); } return true; } }); String[] ocEntries = {"Auto", "1", "6", "11", "36"}; String[] ocValues = {"0", "1", "6", "11", "36"}; lp.setKey("operating_channel"); lp.setTitle(R.string.wifi_display_operating_channel); lp.setEntries(ocEntries); lp.setEntryValues(ocValues); lp.setValue("" + mOperatingChannel); lp.setSummary("%1$s"); mCertCategory.addPreference(lp); } private void startAutoGO() { if (DEBUG) { Slog.d(TAG, "Starting Autonomous GO..."); } mWifiP2pManager.createGroup(mWifiP2pChannel, new ActionListener() { @Override public void onSuccess() { if (DEBUG) { Slog.d(TAG, "Successfully started AutoGO."); } } @Override public void onFailure(int reason) { Slog.e(TAG, "Failed to start AutoGO with reason " + reason + "."); } }); } private void stopAutoGO() { if (DEBUG) { Slog.d(TAG, "Stopping Autonomous GO..."); } mWifiP2pManager.removeGroup(mWifiP2pChannel, new ActionListener() { @Override public void onSuccess() { if (DEBUG) { Slog.d(TAG, "Successfully stopped AutoGO."); } } @Override public void onFailure(int reason) { Slog.e(TAG, "Failed to stop AutoGO with reason " + reason + "."); } }); } private void setListenMode(final boolean enable) { if (DEBUG) { Slog.d(TAG, "Setting listen mode to: " + enable); } final ActionListener listener = new ActionListener() { @Override public void onSuccess() { if (DEBUG) { Slog.d(TAG, "Successfully " + (enable ? "entered" : "exited") + " listen mode."); } } @Override public void onFailure(int reason) { Slog.e(TAG, "Failed to " + (enable ? "entered" : "exited") + " listen mode with reason " + reason + "."); } }; if (enable) { mWifiP2pManager.startListening(mWifiP2pChannel, listener); } else { mWifiP2pManager.stopListening(mWifiP2pChannel, listener); } } private void setWifiP2pChannels(final int lc, final int oc) { if (DEBUG) { Slog.d(TAG, "Setting wifi p2p channel: lc=" + lc + ", oc=" + oc); } mWifiP2pManager.setWifiP2pChannels(mWifiP2pChannel, lc, oc, new ActionListener() { @Override public void onSuccess() { if (DEBUG) { Slog.d(TAG, "Successfully set wifi p2p channels."); } } @Override public void onFailure(int reason) { Slog.e(TAG, "Failed to set wifi p2p channels with reason " + reason + "."); } }); } private void toggleRoute(MediaRouter.RouteInfo route) { if (route.isSelected()) { MediaRouteDialogPresenter.showDialogFragment(getActivity(), MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY, null); } else { route.select(); } } private void pairWifiDisplay(WifiDisplay display) { if (display.canConnect()) { mDisplayManager.connectWifiDisplay(display.getDeviceAddress()); } } private void showWifiDisplayOptionsDialog(final WifiDisplay display) { View view = getActivity().getLayoutInflater().inflate(R.layout.wifi_display_options, null); final EditText nameEditText = (EditText) view.findViewById(R.id.name); nameEditText.setText(display.getFriendlyDisplayName()); DialogInterface.OnClickListener done = new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { String name = nameEditText.getText().toString().trim(); if (name.isEmpty() || name.equals(display.getDeviceName())) { name = null; } mDisplayManager.renameWifiDisplay(display.getDeviceAddress(), name); } }; DialogInterface.OnClickListener forget = new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { mDisplayManager.forgetWifiDisplay(display.getDeviceAddress()); } }; AlertDialog dialog = new AlertDialog.Builder(getActivity()) .setCancelable(true) .setTitle(R.string.wifi_display_options_title) .setView(view) .setPositiveButton(R.string.wifi_display_options_done, done) .setNegativeButton(R.string.wifi_display_options_forget, forget) .create(); dialog.show(); } private final Runnable mUpdateRunnable = new Runnable() { @Override public void run() { final int changes = mPendingChanges; mPendingChanges = 0; update(changes); } }; private final BroadcastReceiver mReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); if (action.equals(DisplayManager.ACTION_WIFI_DISPLAY_STATUS_CHANGED)) { scheduleUpdate(CHANGE_WIFI_DISPLAY_STATUS); } } }; private final ContentObserver mSettingsObserver = new ContentObserver(new Handler()) { @Override public void onChange(boolean selfChange, Uri uri) { scheduleUpdate(CHANGE_SETTINGS); } }; private final MediaRouter.Callback mRouterCallback = new MediaRouter.SimpleCallback() { @Override public void onRouteAdded(MediaRouter router, RouteInfo info) { scheduleUpdate(CHANGE_ROUTES); } @Override public void onRouteChanged(MediaRouter router, RouteInfo info) { scheduleUpdate(CHANGE_ROUTES); } @Override public void onRouteRemoved(MediaRouter router, RouteInfo info) { scheduleUpdate(CHANGE_ROUTES); } @Override public void onRouteSelected(MediaRouter router, int type, RouteInfo info) { scheduleUpdate(CHANGE_ROUTES); } @Override public void onRouteUnselected(MediaRouter router, int type, RouteInfo info) { scheduleUpdate(CHANGE_ROUTES); } }; private class RoutePreference extends TwoTargetPreference implements Preference.OnPreferenceClickListener { private final MediaRouter.RouteInfo mRoute; public RoutePreference(Context context, MediaRouter.RouteInfo route) { super(context); mRoute = route; setTitle(route.getName()); setSummary(route.getDescription()); setEnabled(route.isEnabled()); if (route.isSelected()) { setOrder(ORDER_CONNECTED); if (route.isConnecting()) { setSummary(R.string.wifi_display_status_connecting); } else { CharSequence status = route.getStatus(); if (!TextUtils.isEmpty(status)) { setSummary(status); } else { setSummary(R.string.wifi_display_status_connected); } } } else { if (isEnabled()) { setOrder(ORDER_AVAILABLE); } else { setOrder(ORDER_UNAVAILABLE); if (route.getStatusCode() == MediaRouter.RouteInfo.STATUS_IN_USE) { setSummary(R.string.wifi_display_status_in_use); } else { setSummary(R.string.wifi_display_status_not_available); } } } setOnPreferenceClickListener(this); } @Override public boolean onPreferenceClick(Preference preference) { toggleRoute(mRoute); return true; } } private class WifiDisplayRoutePreference extends RoutePreference implements View.OnClickListener { private final WifiDisplay mDisplay; @Override protected int getSecondTargetResId() { return R.layout.preference_widget_gear; } public WifiDisplayRoutePreference(Context context, MediaRouter.RouteInfo route, WifiDisplay display) { super(context, route); mDisplay = display; } @Override public void onBindViewHolder(PreferenceViewHolder holder) { super.onBindViewHolder(holder); final ImageView gear = (ImageView) holder.findViewById(R.id.settings_button); if (gear != null) { gear.setOnClickListener(this); if (!isEnabled()) { TypedValue value = new TypedValue(); getContext().getTheme().resolveAttribute(android.R.attr.disabledAlpha, value, true); gear.setImageAlpha((int) (value.getFloat() * 255)); gear.setEnabled(true); // always allow button to be pressed } } } @Override public void onClick(View v) { showWifiDisplayOptionsDialog(mDisplay); } } private class UnpairedWifiDisplayPreference extends Preference implements Preference.OnPreferenceClickListener { private final WifiDisplay mDisplay; public UnpairedWifiDisplayPreference(Context context, WifiDisplay display) { super(context); mDisplay = display; setTitle(display.getFriendlyDisplayName()); setSummary(com.android.internal.R.string.wireless_display_route_description); setEnabled(display.canConnect()); if (isEnabled()) { setOrder(ORDER_AVAILABLE); } else { setOrder(ORDER_UNAVAILABLE); setSummary(R.string.wifi_display_status_in_use); } setOnPreferenceClickListener(this); } @Override public boolean onPreferenceClick(Preference preference) { pairWifiDisplay(mDisplay); return true; } } public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = new BaseSearchIndexProvider(R.xml.wifi_display_settings); }