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