/*
* 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 android.net.wifi.p2p;
import android.os.Parcelable;
import android.os.Parcel;
import java.util.ArrayList;
import java.util.List;
import java.util.Collection;
import java.util.Collections;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
/**
* A class representing a Wi-Fi P2p group. A p2p group consists of a single group
* owner and one or more clients. In the case of a group with only two devices, one
* will be the group owner and the other will be a group client.
*
* {@see WifiP2pManager}
*/
public class WifiP2pGroup implements Parcelable {
/** The temporary network id.
* {@hide} */
public static final int TEMPORARY_NET_ID = -1;
/** The persistent network id.
* If a matching persistent profile is found, use it.
* Otherwise, create a new persistent profile.
* {@hide} */
public static final int PERSISTENT_NET_ID = -2;
/** The network name */
private String mNetworkName;
/** Group owner */
private WifiP2pDevice mOwner;
/** Device is group owner */
private boolean mIsGroupOwner;
/** Group clients */
private List<WifiP2pDevice> mClients = new ArrayList<WifiP2pDevice>();
/** The passphrase used for WPA2-PSK */
private String mPassphrase;
private String mInterface;
/** The network id in the wpa_supplicant */
private int mNetId;
/** P2P group started string pattern */
private static final Pattern groupStartedPattern = Pattern.compile(
"ssid=\"(.+)\" " +
"freq=(\\d+) " +
"(?:psk=)?([0-9a-fA-F]{64})?" +
"(?:passphrase=)?(?:\"(.{0,63})\")? " +
"go_dev_addr=((?:[0-9a-f]{2}:){5}[0-9a-f]{2})" +
" ?(\\[PERSISTENT\\])?"
);
public WifiP2pGroup() {
}
/**
* @param supplicantEvent formats supported include
*
* P2P-GROUP-STARTED p2p-wlan0-0 [client|GO] ssid="DIRECT-W8" freq=2437
* [psk=2182b2e50e53f260d04f3c7b25ef33c965a3291b9b36b455a82d77fd82ca15bc|
* passphrase="fKG4jMe3"] go_dev_addr=fa:7b:7a:42:02:13 [PERSISTENT]
*
* P2P-GROUP-REMOVED p2p-wlan0-0 [client|GO] reason=REQUESTED
*
* P2P-INVITATION-RECEIVED sa=fa:7b:7a:42:02:13 go_dev_addr=f8:7b:7a:42:02:13
* bssid=fa:7b:7a:42:82:13 unknown-network
*
* P2P-INVITATION-RECEIVED sa=b8:f9:34:2a:c7:9d persistent=0
*
* Note: The events formats can be looked up in the wpa_supplicant code
* @hide
*/
public WifiP2pGroup(String supplicantEvent) throws IllegalArgumentException {
String[] tokens = supplicantEvent.split(" ");
if (tokens.length < 3) {
throw new IllegalArgumentException("Malformed supplicant event");
}
if (tokens[0].startsWith("P2P-GROUP")) {
mInterface = tokens[1];
mIsGroupOwner = tokens[2].equals("GO");
Matcher match = groupStartedPattern.matcher(supplicantEvent);
if (!match.find()) {
return;
}
mNetworkName = match.group(1);
//freq and psk are unused right now
//int freq = Integer.parseInt(match.group(2));
//String psk = match.group(3);
mPassphrase = match.group(4);
mOwner = new WifiP2pDevice(match.group(5));
if (match.group(6) != null) {
mNetId = PERSISTENT_NET_ID;
} else {
mNetId = TEMPORARY_NET_ID;
}
} else if (tokens[0].equals("P2P-INVITATION-RECEIVED")) {
String sa = null;
mNetId = PERSISTENT_NET_ID;
for (String token : tokens) {
String[] nameValue = token.split("=");
if (nameValue.length != 2) continue;
if (nameValue[0].equals("sa")) {
sa = nameValue[1];
// set source address into the client list.
WifiP2pDevice dev = new WifiP2pDevice();
dev.deviceAddress = nameValue[1];
mClients.add(dev);
continue;
}
if (nameValue[0].equals("go_dev_addr")) {
mOwner = new WifiP2pDevice(nameValue[1]);
continue;
}
if (nameValue[0].equals("persistent")) {
mOwner = new WifiP2pDevice(sa);
mNetId = Integer.parseInt(nameValue[1]);
continue;
}
}
} else {
throw new IllegalArgumentException("Malformed supplicant event");
}
}
/** @hide */
public void setNetworkName(String networkName) {
mNetworkName = networkName;
}
/**
* Get the network name (SSID) of the group. Legacy Wi-Fi clients will discover
* the p2p group using the network name.
*/
public String getNetworkName() {
return mNetworkName;
}
/** @hide */
public void setIsGroupOwner(boolean isGo) {
mIsGroupOwner = isGo;
}
/** Check whether this device is the group owner of the created p2p group */
public boolean isGroupOwner() {
return mIsGroupOwner;
}
/** @hide */
public void setOwner(WifiP2pDevice device) {
mOwner = device;
}
/** Get the details of the group owner as a {@link WifiP2pDevice} object */
public WifiP2pDevice getOwner() {
return mOwner;
}
/** @hide */
public void addClient(String address) {
addClient(new WifiP2pDevice(address));
}
/** @hide */
public void addClient(WifiP2pDevice device) {
for (WifiP2pDevice client : mClients) {
if (client.equals(device)) return;
}
mClients.add(device);
}
/** @hide */
public boolean removeClient(String address) {
return mClients.remove(new WifiP2pDevice(address));
}
/** @hide */
public boolean removeClient(WifiP2pDevice device) {
return mClients.remove(device);
}
/** @hide */
public boolean isClientListEmpty() {
return mClients.size() == 0;
}
/** @hide Returns {@code true} if the device is part of the group */
public boolean contains(WifiP2pDevice device) {
if (mOwner.equals(device) || mClients.contains(device)) return true;
return false;
}
/** Get the list of clients currently part of the p2p group */
public Collection<WifiP2pDevice> getClientList() {
return Collections.unmodifiableCollection(mClients);
}
/** @hide */
public void setPassphrase(String passphrase) {
mPassphrase = passphrase;
}
/**
* Get the passphrase of the group. This function will return a valid passphrase only
* at the group owner. Legacy Wi-Fi clients will need this passphrase alongside
* network name obtained from {@link #getNetworkName()} to join the group
*/
public String getPassphrase() {
return mPassphrase;
}
/** @hide */
public void setInterface(String intf) {
mInterface = intf;
}
/** Get the interface name on which the group is created */
public String getInterface() {
return mInterface;
}
/** @hide */
public int getNetworkId() {
return mNetId;
}
/** @hide */
public void setNetworkId(int netId) {
this.mNetId = netId;
}
public String toString() {
StringBuffer sbuf = new StringBuffer();
sbuf.append("network: ").append(mNetworkName);
sbuf.append("\n isGO: ").append(mIsGroupOwner);
sbuf.append("\n GO: ").append(mOwner);
for (WifiP2pDevice client : mClients) {
sbuf.append("\n Client: ").append(client);
}
sbuf.append("\n interface: ").append(mInterface);
sbuf.append("\n networkId: ").append(mNetId);
return sbuf.toString();
}
/** Implement the Parcelable interface */
public int describeContents() {
return 0;
}
/** copy constructor */
public WifiP2pGroup(WifiP2pGroup source) {
if (source != null) {
mNetworkName = source.getNetworkName();
mOwner = new WifiP2pDevice(source.getOwner());
mIsGroupOwner = source.mIsGroupOwner;
for (WifiP2pDevice d : source.getClientList()) mClients.add(d);
mPassphrase = source.getPassphrase();
mInterface = source.getInterface();
mNetId = source.getNetworkId();
}
}
/** Implement the Parcelable interface */
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(mNetworkName);
dest.writeParcelable(mOwner, flags);
dest.writeByte(mIsGroupOwner ? (byte) 1: (byte) 0);
dest.writeInt(mClients.size());
for (WifiP2pDevice client : mClients) {
dest.writeParcelable(client, flags);
}
dest.writeString(mPassphrase);
dest.writeString(mInterface);
dest.writeInt(mNetId);
}
/** Implement the Parcelable interface */
public static final Creator<WifiP2pGroup> CREATOR =
new Creator<WifiP2pGroup>() {
public WifiP2pGroup createFromParcel(Parcel in) {
WifiP2pGroup group = new WifiP2pGroup();
group.setNetworkName(in.readString());
group.setOwner((WifiP2pDevice)in.readParcelable(null));
group.setIsGroupOwner(in.readByte() == (byte)1);
int clientCount = in.readInt();
for (int i=0; i<clientCount; i++) {
group.addClient((WifiP2pDevice) in.readParcelable(null));
}
group.setPassphrase(in.readString());
group.setInterface(in.readString());
group.setNetworkId(in.readInt());
return group;
}
public WifiP2pGroup[] newArray(int size) {
return new WifiP2pGroup[size];
}
};
}
|
