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

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;
}
}
}
}