PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated: Wi-Fi p2p initial UI implementation

Browse Source 
Change-Id: If60f42f76fa07a868d2e11b012b4697252c69f5f
This commit is contained in:
repo sync
2011-06-30 10:58:43 -07:00
committed by Irfan Sheriff
parent e707d8b44b
commit b98463f8b0
14 changed files with 833 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
AndroidManifest.xml
View File

@@ -270,6 +270,24 @@
android:value="com.android.settings.Settings$WirelessSettingsActivity" />
</activity-alias>
<activity android:name="Settings$WifiP2pSettingsActivity"
android:clearTaskOnLaunch="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.VOICE_LAUNCH" />
</intent-filter>
<meta-data android:name="com.android.settings.FRAGMENT_CLASS"
android:value="com.android.settings.WifiP2pSettings" />
<meta-data android:name="com.android.settings.TOP_LEVEL_HEADER_ID"
android:resource="@id/wireless_settings" />
<meta-data android:name="com.android.settings.PARENT_FRAGMENT_TITLE"
android:resource="@string/wireless_networks_settings_title" />
<meta-data android:name="com.android.settings.PARENT_FRAGMENT_CLASS"
android:value="com.android.settings.Settings$WirelessSettingsActivity" />
</activity>
<activity android:name="Settings$VpnSettingsActivity"
android:label="@string/vpn_settings_title"
android:clearTaskOnLaunch="true">

88
res/layout/wifi_p2p_dialog.xml Normal file
View File

@@ -0,0 +1,88 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2011 The Android Open Source Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="300sp"
android:layout_height="wrap_content">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:padding="8dip"
android:orientation="vertical">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical" />
<TextView
style="?android:attr/textAppearanceSmall"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="8dip"
android:text="@string/wifi_p2p_device_info" />
<TextView android:id="@+id/device_name"
style="?android:attr/textAppearanceMedium"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="8dip" />
<TextView android:id="@+id/device_address"
style="?android:attr/textAppearanceMedium"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="8dip" />
<TextView
style="?android:attr/textAppearanceSmall"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="8dip"
android:text="@string/wifi_p2p_wps_setup" />
<Spinner android:id="@+id/wps_setup"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:prompt="@string/wifi_p2p_wps_setup"
android:entries="@array/wifi_p2p_wps_setup" />
<LinearLayout android:id="@+id/wps_pin_entry"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical"
android:visibility="gone">
<TextView
style="@style/wifi_item_label"
android:text="@string/wifi_p2p_wps_pin" />
<EditText android:id="@+id/wps_pin"
style="@style/wifi_item_content"
android:singleLine="true"
android:inputType="textPassword" />
</LinearLayout>
<CheckBox android:id="@+id/persist_network"
style="?android:attr/textAppearanceSmall"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="@string/wifi_p2p_persist_network" />
</LinearLayout>
</ScrollView>

22
res/values/arrays.xml
View File

@@ -324,6 +324,28 @@
<item>TTLS</item>
</string-array>
<!-- Wi-Fi WPS setup for p2p connections. -->
<!-- Note that adding/removing/moving the items will need wifi settings code change. -->
<string-array name="wifi_p2p_wps_setup">
<!-- Push button based configuration involves pushing a button on two connecting devices [CHAR LIMIT=30]-->
<item>Push button</item>
<!-- This involves entering a pin obtained from a peer device [CHAR LIMIT=30] -->
<item>Pin from peer device</item>
<!-- This involves generating a pin from this device [CHAR LIMIT=20] -->
<item>Pin from this device</item>
</string-array>
<!-- Match this with the order of WifiP2pDevice.Status -->
<!-- Wi-Fi p2p settings device status message -->
<string-array name="wifi_p2p_status">
<item>Connected</item>
<item>Invited</item>
<item>Failed</item>
<item>Available</item>
<item>Out of range</item>
</string-array>
<!-- Bluetooth Settings -->
<!-- Discoverable mode timeout options -->

17
res/values/strings.xml
View File

@@ -1272,6 +1272,23 @@
<!-- Hint text for network prefix length -->
<string name="wifi_network_prefix_length_hint" translatable="false">24</string>
<!-- Wi-Fi p2p / Wi-Fi Direct settings -->
<!-- Used in the 1st-level settings screen to launch Wi-fi Direct settings [CHAR LIMIT=25] -->
<string name="wifi_p2p_settings_title">Wi-Fi Direct</string>
<!-- Summary for Wi-fi Direct settings item in the 1st-level settings screen [CHAR LIMIT=50]-->
<string name="wifi_p2p_settings_summary">Setup peer-to-peer connectivity</string>
<string name="wifi_p2p_device_info">Device Information</string>
<string name="wifi_p2p_wps_setup">Wi-Fi Protected Setup</string>
<string name="wifi_p2p_wps_pin">Enter pin</string>
<string name="wifi_p2p_persist_network">Remember this connection</string>
<!-- Menu option to discover peers-->
<string name="wifi_p2p_menu_search">Search</string>
<!-- Menu option to create a group-->
<string name="wifi_p2p_menu_create_group">Create group</string>
<!-- Menu option to Wi-Fi p2p advanced settings -->
<string name="wifi_p2p_menu_advanced">Advanced</string>
<!-- Wifi AP settings-->
<!-- Label for wifi tether checkbox. Toggles Access Point on/off -->
<string name="wifi_tether_checkbox_text">Portable Wi-Fi hotspot</string>

19
res/xml/wifi_p2p_settings.xml Normal file
View File

@@ -0,0 +1,19 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2011 The Android Open Source Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
</PreferenceScreen>

6
res/xml/wireless_settings.xml
View File

@@ -45,6 +45,12 @@
android:summary="@string/zeroclick_settings_summary" >
</PreferenceScreen>
<PreferenceScreen
android:fragment="com.android.settings.WifiP2pSettings"
android:key="wifi_p2p_settings"
android:title="@string/wifi_p2p_settings_title"
android:summary="@string/wifi_p2p_settings_summary">
</PreferenceScreen>
<PreferenceScreen
android:key="mobile_network_settings"

1
src/com/android/settings/Settings.java
View File

@@ -559,6 +559,7 @@ public class Settings extends PreferenceActivity implements ButtonBarHandler {
public static class DateTimeSettingsActivity extends Settings { /* empty */ }
public static class StorageSettingsActivity extends Settings { /* empty */ }
public static class WifiSettingsActivity extends Settings { /* empty */ }
public static class WifiP2pSettingsActivity extends Settings { /* empty */ }
public static class InputMethodAndLanguageSettingsActivity extends Settings { /* empty */ }
public static class InputMethodAndSubtypeEnablerActivity extends Settings { /* empty */ }
public static class LocalePickerActivity extends Settings { /* empty */ }

10
src/com/android/settings/WirelessSettings.java
View File

@@ -21,6 +21,7 @@ import android.app.admin.DevicePolicyManager;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.wifi.p2p.WifiP2pManager;
import android.nfc.NfcAdapter;
import android.os.Bundle;
import android.os.SystemProperties;
@@ -28,6 +29,9 @@ import android.preference.CheckBoxPreference;
import android.preference.Preference;
import android.preference.PreferenceScreen;
import android.provider.Settings;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.Switch;
import com.android.internal.telephony.TelephonyIntents;
import com.android.internal.telephony.TelephonyProperties;
@@ -39,6 +43,7 @@ public class WirelessSettings extends SettingsPreferenceFragment {
private static final String KEY_TOGGLE_NFC = "toggle_nfc";
private static final String KEY_ZEROCLICK_SETTINGS = "zeroclick_settings";
private static final String KEY_VPN_SETTINGS = "vpn_settings";
private static final String KEY_WIFI_P2P_SETTINGS = "wifi_p2p_settings";
private static final String KEY_TETHER_SETTINGS = "tether_settings";
private static final String KEY_PROXY_SETTINGS = "proxy_settings";
private static final String KEY_MOBILE_NETWORK_SETTINGS = "mobile_network_settings";
@@ -118,6 +123,11 @@ public class WirelessSettings extends SettingsPreferenceFragment {
getPreferenceScreen().removePreference(findPreference(KEY_MOBILE_NETWORK_SETTINGS));
}
WifiP2pManager wifiP2p = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
if (!wifiP2p.isP2pSupported()) {
getPreferenceScreen().removePreference(findPreference(KEY_WIFI_P2P_SETTINGS));
}
// Enable Proxy selector settings if allowed.
Preference mGlobalProxy = findPreference(KEY_PROXY_SETTINGS);
DevicePolicyManager mDPM = (DevicePolicyManager)

16
src/com/android/settings/wifi/WifiConfigController.java
View File

@@ -90,8 +90,8 @@ public class WifiConfigController implements TextWatcher,
/* These values come from "wifi_network_setup" resource array */
public static final int MANUAL = 0;
public static final int WPS_PBC = 1;
public static final int WPS_PIN_FROM_ACCESS_POINT = 2;
public static final int WPS_PIN_FROM_DEVICE = 3;
public static final int WPS_KEYPAD = 2;
public static final int WPS_DISPLAY = 3;
/* These values come from "wifi_proxy_settings" resource array */
public static final int PROXY_NONE = 0;
@@ -473,11 +473,11 @@ public class WifiConfigController implements TextWatcher,
case WPS_PBC:
config.setup = Setup.PBC;
break;
case WPS_PIN_FROM_ACCESS_POINT:
config.setup = Setup.PIN_FROM_ACCESS_POINT;
case WPS_KEYPAD:
config.setup = Setup.KEYPAD;
break;
case WPS_PIN_FROM_DEVICE:
config.setup = Setup.PIN_FROM_DEVICE;
case WPS_DISPLAY:
config.setup = Setup.DISPLAY;
break;
default:
config.setup = Setup.INVALID;
@@ -559,14 +559,14 @@ public class WifiConfigController implements TextWatcher,
int pos = mNetworkSetupSpinner.getSelectedItemPosition();
/* Show pin text input if needed */
if (pos == WPS_PIN_FROM_ACCESS_POINT) {
if (pos == WPS_DISPLAY) {
mView.findViewById(R.id.wps_fields).setVisibility(View.VISIBLE);
} else {
mView.findViewById(R.id.wps_fields).setVisibility(View.GONE);
}
/* show/hide manual security fields appropriately */
if ((pos == WPS_PIN_FROM_ACCESS_POINT) || (pos == WPS_PIN_FROM_DEVICE)
if ((pos == WPS_DISPLAY) || (pos == WPS_KEYPAD)
|| (pos == WPS_PBC)) {
mView.findViewById(R.id.security_fields).setVisibility(View.GONE);
} else {

4
src/com/android/settings/wifi/WifiSettings.java
View File

@@ -683,8 +683,8 @@ public class WifiSettings extends SettingsPreferenceFragment
int networkSetup = configController.chosenNetworkSetupMethod();
switch(networkSetup) {
case WifiConfigController.WPS_PBC:
case WifiConfigController.WPS_PIN_FROM_ACCESS_POINT:
case WifiConfigController.WPS_PIN_FROM_DEVICE:
case WifiConfigController.WPS_DISPLAY:
case WifiConfigController.WPS_KEYPAD:
mWifiManager.startWps(configController.getWpsConfig());
break;
case WifiConfigController.MANUAL:

137
src/com/android/settings/wifi/p2p/WifiP2pDialog.java Normal file
View File

@@ -0,0 +1,137 @@
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.wifi.p2p;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.net.wifi.WpsConfiguration;
import android.net.wifi.WpsConfiguration.Setup;
import android.net.wifi.p2p.WifiP2pConfig;
import android.net.wifi.p2p.WifiP2pDevice;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.CheckBox;
import android.widget.Spinner;
import android.widget.TextView;
import com.android.settings.R;
/**
* Dialog to setup a p2p connection
*/
public class WifiP2pDialog extends AlertDialog implements AdapterView.OnItemSelectedListener {
static final int BUTTON_SUBMIT = DialogInterface.BUTTON_POSITIVE;
private final DialogInterface.OnClickListener mListener;
private View mView;
private TextView mDeviceName;
private TextView mDeviceAddress;
/* These values come from "wifi_p2p_wps_setup" resource array */
private static final int WPS_PBC = 0;
private static final int WPS_KEYPAD = 1;
private static final int WPS_DISPLAY = 2;
private int mWpsSetupIndex = WPS_PBC; //default is pbc
WifiP2pDevice mDevice;
public WifiP2pDialog(Context context, DialogInterface.OnClickListener listener,
WifiP2pDevice device) {
super(context);
mListener = listener;
mDevice = device;
}
public WifiP2pConfig getConfig() {
WifiP2pConfig config = new WifiP2pConfig();
config.deviceAddress = mDeviceAddress.getText().toString();
config.deviceName = mDeviceName.getText().toString();
config.wpsConfig = new WpsConfiguration();
switch (mWpsSetupIndex) {
case WPS_PBC:
config.wpsConfig.setup = Setup.PBC;
break;
case WPS_KEYPAD:
config.wpsConfig.setup = Setup.KEYPAD;
config.wpsConfig.pin = ((TextView) mView.findViewById(R.id.wps_pin)).
getText().toString();
break;
case WPS_DISPLAY:
config.wpsConfig.setup = Setup.DISPLAY;
break;
default:
config.wpsConfig.setup = Setup.PBC;
break;
}
if (mDevice.isGroupOwner()) {
config.joinExistingGroup = true;
}
return config;
}
@Override
protected void onCreate(Bundle savedInstanceState) {
mView = getLayoutInflater().inflate(R.layout.wifi_p2p_dialog, null);
Spinner mWpsSetup = ((Spinner) mView.findViewById(R.id.wps_setup));
setView(mView);
setInverseBackgroundForced(true);
Context context = getContext();
setTitle(R.string.wifi_p2p_settings_title);
mDeviceName = (TextView) mView.findViewById(R.id.device_name);
mDeviceAddress = (TextView) mView.findViewById(R.id.device_address);
setButton(BUTTON_SUBMIT, context.getString(R.string.wifi_connect), mListener);
setButton(DialogInterface.BUTTON_NEGATIVE,
context.getString(R.string.wifi_cancel), mListener);
if (mDevice != null) {
mDeviceName.setText(mDevice.deviceName);
mDeviceAddress.setText(mDevice.deviceAddress);
mWpsSetup.setSelection(mWpsSetupIndex); //keep pbc as default
}
mWpsSetup.setOnItemSelectedListener(this);
super.onCreate(savedInstanceState);
}
@Override
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
mWpsSetupIndex = position;
if (mWpsSetupIndex == WPS_KEYPAD) {
mView.findViewById(R.id.wps_pin_entry).setVisibility(View.VISIBLE);
} else {
mView.findViewById(R.id.wps_pin_entry).setVisibility(View.GONE);
}
return;
}
@Override
public void onNothingSelected(AdapterView<?> parent) {
}
}

144
src/com/android/settings/wifi/p2p/WifiP2pEnabler.java Normal file
View File

@@ -0,0 +1,144 @@
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.wifi.p2p;
import com.android.settings.R;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.wifi.p2p.WifiP2pManager;
import android.os.Handler;
import android.os.Message;
import android.preference.Preference;
import android.provider.Settings;
import android.util.Log;
import android.widget.CompoundButton;
import android.widget.Switch;
/**
* WifiP2pEnabler is a helper to manage the Wifi p2p on/off
*/
public class WifiP2pEnabler implements CompoundButton.OnCheckedChangeListener {
private static final String TAG = "WifiP2pEnabler";
private final Context mContext;
private Switch mSwitch;
private int mWifiP2pState;
private final IntentFilter mIntentFilter;
private final Handler mHandler = new WifiP2pHandler();
private WifiP2pManager mWifiP2pManager;
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
handleP2pStateChanged(intent.getIntExtra(
WifiP2pManager.EXTRA_WIFI_STATE, WifiP2pManager.WIFI_P2P_STATE_DISABLED));
}
}
};
public WifiP2pEnabler(Context context, Switch switch_) {
mContext = context;
mSwitch = switch_;
mWifiP2pManager = (WifiP2pManager) context.getSystemService(Context.WIFI_P2P_SERVICE);
if (!mWifiP2pManager.connectHandler(mContext, mHandler)) {
//Failure to set up connection
Log.e(TAG, "Failed to set up connection with wifi p2p service");
mWifiP2pManager = null;
mSwitch.setEnabled(false);
}
mIntentFilter = new IntentFilter(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
}
public void resume() {
if (mWifiP2pManager == null) return;
mContext.registerReceiver(mReceiver, mIntentFilter);
mSwitch.setOnCheckedChangeListener(this);
}
public void pause() {
if (mWifiP2pManager == null) return;
mContext.unregisterReceiver(mReceiver);
mSwitch.setOnCheckedChangeListener(null);
}
public void setSwitch(Switch switch_) {
if (mSwitch == switch_) return;
mSwitch.setOnCheckedChangeListener(null);
mSwitch = switch_;
mSwitch.setOnCheckedChangeListener(this);
mSwitch.setChecked(mWifiP2pState == WifiP2pManager.WIFI_P2P_STATE_ENABLED);
}
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if (mWifiP2pManager == null) return;
if (isChecked) {
mWifiP2pManager.enableP2p();
} else {
mWifiP2pManager.disableP2p();
}
}
private void handleP2pStateChanged(int state) {
mSwitch.setEnabled(true);
switch (state) {
case WifiP2pManager.WIFI_P2P_STATE_ENABLED:
mWifiP2pState = WifiP2pManager.WIFI_P2P_STATE_ENABLED;
mSwitch.setChecked(true);
break;
case WifiP2pManager.WIFI_P2P_STATE_DISABLED:
mWifiP2pState = WifiP2pManager.WIFI_P2P_STATE_DISABLED;
mSwitch.setChecked(false);
break;
default:
mWifiP2pState = WifiP2pManager.WIFI_P2P_STATE_DISABLED;
Log.e(TAG,"Unhandled wifi state " + state);
break;
}
}
private class WifiP2pHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case WifiP2pManager.HANDLER_DISCONNECTION:
//Failure to set up connection
Log.e(TAG, "Lost connection with wifi p2p service");
mWifiP2pManager = null;
mSwitch.setEnabled(false);
break;
case WifiP2pManager.ENABLE_P2P_FAILED:
mSwitch.setEnabled(true);
break;
default:
//Ignore
break;
}
}
}
}

104
src/com/android/settings/wifi/p2p/WifiP2pPeer.java Normal file
View File

@@ -0,0 +1,104 @@
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.wifi.p2p;
import com.android.settings.R;
import android.content.Context;
import android.net.wifi.WifiManager;
import android.net.wifi.p2p.WifiP2pManager;
import android.net.wifi.p2p.WifiP2pDevice;
import android.net.wifi.p2p.WifiP2pDevice.Status;
import android.preference.Preference;
import android.text.TextUtils;
import android.view.View;
import android.widget.ImageView;
import java.util.Comparator;
public class WifiP2pPeer extends Preference {
private static final int[] STATE_SECURED = {R.attr.state_encrypted};
public WifiP2pDevice device;
private int mRssi;
private ImageView mSignal;
private static final int SIGNAL_LEVELS = 4;
public WifiP2pPeer(Context context, WifiP2pDevice dev) {
super(context);
device = dev;
setWidgetLayoutResource(R.layout.preference_widget_wifi_signal);
mRssi = 60; //TODO: fix
}
@Override
protected void onBindView(View view) {
if (TextUtils.isEmpty(device.deviceName)) {
setTitle(device.deviceAddress);
} else {
setTitle(device.deviceName);
}
mSignal = (ImageView) view.findViewById(R.id.signal);
if (mRssi == Integer.MAX_VALUE) {
mSignal.setImageDrawable(null);
} else {
mSignal.setImageResource(R.drawable.wifi_signal);
mSignal.setImageState(STATE_SECURED, true);
}
refresh();
super.onBindView(view);
}
@Override
public int compareTo(Preference preference) {
if (!(preference instanceof WifiP2pPeer)) {
return 1;
}
WifiP2pPeer other = (WifiP2pPeer) preference;
// devices go in the order of the status
if (device.status != other.device.status) {
return device.status.ordinal() < other.device.status.ordinal() ? -1 : 1;
}
// Sort by name/address
if (device.deviceName != null) {
return device.deviceName.compareToIgnoreCase(other.device.deviceName);
}
return device.deviceAddress.compareToIgnoreCase(other.device.deviceAddress);
}
int getLevel() {
if (mRssi == Integer.MAX_VALUE) {
return -1;
}
return WifiManager.calculateSignalLevel(mRssi, SIGNAL_LEVELS);
}
private void refresh() {
if (mSignal == null) {
return;
}
Context context = getContext();
mSignal.setImageLevel(getLevel());
String[] statusArray = context.getResources().getStringArray(R.array.wifi_p2p_status);
setSummary(statusArray[device.status.ordinal()]);
}
}

257
src/com/android/settings/wifi/p2p/WifiP2pSettings.java Normal file
View File

@@ -0,0 +1,257 @@
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings;
import android.app.ActionBar;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.wifi.p2p.WifiP2pConfig;
import android.net.wifi.p2p.WifiP2pDevice;
import android.net.wifi.p2p.WifiP2pDeviceList;
import android.net.wifi.p2p.WifiP2pManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceScreen;
import android.util.Log;
import android.view.Gravity;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.widget.Switch;
import com.android.settings.wifi.p2p.WifiP2pDialog;
import com.android.settings.wifi.p2p.WifiP2pEnabler;
import com.android.settings.wifi.p2p.WifiP2pPeer;
import java.util.Arrays;
import java.util.List;
import java.util.Collection;
/*
* Displays Wi-fi p2p settings UI
*/
public class WifiP2pSettings extends SettingsPreferenceFragment {
private static final String TAG = "WifiP2pSettings";
private static final int MENU_ID_SEARCH = Menu.FIRST;
private static final int MENU_ID_CREATE_GROUP = Menu.FIRST + 1;
private static final int MENU_ID_ADVANCED = Menu.FIRST +2;
private final IntentFilter mIntentFilter = new IntentFilter();
private final Handler mHandler = new WifiP2pHandler();
private WifiP2pManager mWifiP2pManager;
private WifiP2pEnabler mWifiP2pEnabler;
private WifiP2pDialog mConnectDialog;
private OnClickListener mConnectListener;
private OnClickListener mDisconnectListener;
private WifiP2pPeer mSelectedWifiPeer;
private static final int DIALOG_CONNECT = 1;
private static final int DIALOG_DISCONNECT = 2;
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
//TODO: nothing right now
} else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
if (mWifiP2pManager != null) mWifiP2pManager.requestPeers();
}
}
};
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
addPreferencesFromResource(R.xml.wifi_p2p_settings);
mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
final Activity activity = getActivity();
mWifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
if (!mWifiP2pManager.connectHandler(activity, mHandler)) {
//Failure to set up connection
Log.e(TAG, "Failed to set up connection with wifi p2p service");
mWifiP2pManager = null;
}
Switch actionBarSwitch = new Switch(activity);
if (activity instanceof PreferenceActivity) {
PreferenceActivity preferenceActivity = (PreferenceActivity) activity;
if (preferenceActivity.onIsHidingHeaders() || !preferenceActivity.onIsMultiPane()) {
final int padding = activity.getResources().getDimensionPixelSize(
R.dimen.action_bar_switch_padding);
actionBarSwitch.setPadding(0, 0, padding, 0);
activity.getActionBar().setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM,
ActionBar.DISPLAY_SHOW_CUSTOM);
activity.getActionBar().setCustomView(actionBarSwitch, new ActionBar.LayoutParams(
ActionBar.LayoutParams.WRAP_CONTENT,
ActionBar.LayoutParams.WRAP_CONTENT,
Gravity.CENTER_VERTICAL | Gravity.RIGHT));
}
}
mWifiP2pEnabler = new WifiP2pEnabler(activity, actionBarSwitch);
//connect dialog listener
mConnectListener = new OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
if (which == DialogInterface.BUTTON_POSITIVE) {
WifiP2pConfig config = mConnectDialog.getConfig();
if (mWifiP2pManager != null) {
mWifiP2pManager.connect(config);
}
}
}
};
//disconnect dialog listener
mDisconnectListener = new OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
if (which == DialogInterface.BUTTON_POSITIVE) {
if (mWifiP2pManager != null) {
mWifiP2pManager.disconnect();
}
}
}
};
setHasOptionsMenu(true);
}
@Override
public void onResume() {
super.onResume();
getActivity().registerReceiver(mReceiver, mIntentFilter);
if (mWifiP2pEnabler != null) {
mWifiP2pEnabler.resume();
}
if (mWifiP2pManager != null) mWifiP2pManager.discoverPeers();
}
@Override
public void onPause() {
super.onPause();
if (mWifiP2pEnabler != null) {
mWifiP2pEnabler.pause();
}
getActivity().unregisterReceiver(mReceiver);
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
menu.add(Menu.NONE, MENU_ID_SEARCH, 0, R.string.wifi_p2p_menu_search)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
menu.add(Menu.NONE, MENU_ID_CREATE_GROUP, 0, R.string.wifi_p2p_menu_create_group)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
menu.add(Menu.NONE, MENU_ID_ADVANCED, 0, R.string.wifi_p2p_menu_advanced)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
super.onCreateOptionsMenu(menu, inflater);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_ID_SEARCH:
mWifiP2pManager.discoverPeers();
return true;
case MENU_ID_CREATE_GROUP:
mWifiP2pManager.createGroup();
return true;
case MENU_ID_ADVANCED:
//TODO: add advanced settings for p2p
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
public boolean onPreferenceTreeClick(PreferenceScreen screen, Preference preference) {
if (preference instanceof WifiP2pPeer) {
mSelectedWifiPeer = (WifiP2pPeer) preference;
if (mSelectedWifiPeer.device.status == WifiP2pDevice.Status.CONNECTED) {
showDialog(DIALOG_DISCONNECT);
} else {
showDialog(DIALOG_CONNECT);
}
}
return super.onPreferenceTreeClick(screen, preference);
}
@Override
public Dialog onCreateDialog(int id) {
if (id == DIALOG_CONNECT) {
mConnectDialog = new WifiP2pDialog(getActivity(), mConnectListener,
mSelectedWifiPeer.device);
return mConnectDialog;
} else if (id == DIALOG_DISCONNECT) {
AlertDialog dialog = new AlertDialog.Builder(getActivity())
.setTitle("Disconnect ?")
.setMessage("Do you want to disconnect ?")
.setPositiveButton(getActivity().getString(R.string.dlg_ok), mDisconnectListener)
.setNegativeButton(getActivity().getString(R.string.dlg_cancel), null)
.create();
return dialog;
}
return null;
}
private void updatePeers(WifiP2pDeviceList peers) {
final PreferenceScreen preferenceScreen = getPreferenceScreen();
preferenceScreen.removeAll();
for (WifiP2pDevice peer: peers.getDeviceList()) {
preferenceScreen.addPreference(new WifiP2pPeer(getActivity(), peer));
}
}
private class WifiP2pHandler extends Handler {
@Override
public void handleMessage(Message message) {
switch (message.what) {
case WifiP2pManager.HANDLER_DISCONNECTION:
//Failure to set up connection
Log.e(TAG, "Lost connection with wifi p2p service");
mWifiP2pManager = null;
break;
case WifiP2pManager.RESPONSE_PEERS:
updatePeers(mWifiP2pManager.peersInResponse(message));
break;
default:
//Ignore
break;
}
}
}
}