Android WifiDirect学习(一)

1 <uses-sdk android:minSdkVersion="14" />
2 <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
3 <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
4 <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
5 <uses-permission android:name="android.permission.INTERNET" />
6 <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

 1 @Override
 2 public void onReceive(Context context, Intent intent) {
 3     ...
 4     String action = intent.getAction();
 5     if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
 6         int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
 7         if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
 8             // Wifi Direct is enabled
 9         } else {
10             // Wi-Fi Direct is not enabled
11         }
12     }
13     ...
14 }

 1 WifiP2pManager mManager;
 2 Channel mChannel;
 3 BroadcastReceiver mReceiver;
 4 ...
 5 @Override
 6 protected void onCreate(Bundle savedInstanceState){
 7     ...
 8     mManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
 9     mChannel = mManager.initialize(this, getMainLooper(), null);
10     mReceiver = new WiFiDirectBroadcastReceiver(manager, channel, this);
11     ...
12 }

 1 IntentFilter mIntentFilter;
 2 ...
 3 @Override
 4 protected void onCreate(Bundle savedInstanceState){
 5     ...
 6     mIntentFilter = new IntentFilter();
 7     mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
 8     mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
 9     mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
10     mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
11     ...
12 }

 1 /* register the broadcast receiver with the intent values to be matched */
 2 @Override
 3 protected void onResume() {
 4     super.onResume();
 5     registerReceiver(mReceiver, mIntentFilter);
 6 }
 7 /* unregister the broadcast receiver */
 8 @Override
 9 protected void onPause() {
10     super.onPause();
11     unregisterReceiver(mReceiver);
12 }

 1 manager.discoverPeers(channel, new WifiP2pManager.ActionListener() {
 2     @Override
 3     public void onSuccess() {
 4         ...
 5     }
 6  
 7     @Override
 8     public void onFailure(int reasonCode) {
 9         ...
10     }
11 });

 1 PeerListListener myPeerListListener;
 2 ...
 3 if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
 4  
 5     // request available peers from the wifi p2p manager. This is an
 6     // asynchronous call and the calling activity is notified with a
 7     // callback on PeerListListener.onPeersAvailable()
 8     if (manager != null) {
 9         manager.requestPeers(channel, myPeerListListener);
10     }
11 }

 1 //obtain a peer from the WifiP2pDeviceList
 2 WifiP2pDevice device;
 3 WifiP2pConfig config = new WifiP2pConfig();
 4 config.deviceAddress = device.deviceAddress;
 5 manager.connect(channel, config, new ActionListener() {
 6  
 7     @Override
 8     public void onSuccess() {
 9         //success logic
10     }
11  
12     @Override
13     public void onFailure(int reason) {
14         //failure logic
15     }
16 });

 1 public static class FileServerAsyncTask extends AsyncTask {
 2  
 3     private Context context;
 4     private TextView statusText;
 5  
 6     public FileServerAsyncTask(Context context, View statusText) {
 7         this.context = context;
 8         this.statusText = (TextView) statusText;
 9     }
10  
11     @Override
12     protected String doInBackground(Void... params) {
13         try {
14  
15             /**
16              * Create a server socket and wait for client connections. This
17              * call blocks until a connection is accepted from a client
18              */
19             ServerSocket serverSocket = new ServerSocket(8888);
20             Socket client = serverSocket.accept();
21  
22             /**
23              * If this code is reached, a client has connected and transferred data
24              * Save the input stream from the client as a JPEG file
25              */
26             final File f = new File(Environment.getExternalStorageDirectory() + "/"
27                     + context.getPackageName() + "/wifip2pshared-" + System.currentTimeMillis()
28                     + ".jpg");
29  
30             File dirs = new File(f.getParent());
31             if (!dirs.exists())
32                 dirs.mkdirs();
33             f.createNewFile();
34             InputStream inputstream = client.getInputStream();
35             copyFile(inputstream, new FileOutputStream(f));
36             serverSocket.close();
37             return f.getAbsolutePath();
38         } catch (IOException e) {
39             Log.e(WiFiDirectActivity.TAG, e.getMessage());
40             return null;
41         }
42     }
43  
44     /**
45      * Start activity that can handle the JPEG image
46      */
47     @Override
48     protected void onPostExecute(String result) {
49         if (result != null) {
50             statusText.setText("File copied - " + result);
51             Intent intent = new Intent();
52             intent.setAction(android.content.Intent.ACTION_VIEW);
53             intent.setDataAndType(Uri.parse("file://" + result), "image/*");
54             context.startActivity(intent);
55         }
56     }
57 }

 1 Context context = this.getApplicationContext();
 2 String host;
 3 int port;
 4 int len;
 5 Socket socket = new Socket();
 6 byte buf[]  = new byte[1024];
 7 ...
 8 try {
 9     /**
10      * Create a client socket with the host,
11      * port, and timeout information.
12      */
13     socket.bind(null);
14     socket.connect((new InetSocketAddress(host, port)), 500);
15  
16     /**
17      * Create a byte stream from a JPEG file and pipe it to the output stream
18      * of the socket. This data will be retrieved by the server device.
19      */
20     OutputStream outputStream = socket.getOutputStream();
21     ContentResolver cr = context.getContentResolver();
22     InputStream inputStream = null;
23     inputStream = cr.openInputStream(Uri.parse("path/to/picture.jpg"));
24     while ((len = inputStream.read(buf)) != -1) {
25         outputStream.write(buf, 0, len);
26     }
27     outputStream.close();
28     inputStream.close();
29 } catch (FileNotFoundException e) {
30     //catch logic
31 } catch (IOException e) {
32     //catch logic
33 }
34  
35 /**
36  * Clean up any open sockets when done
37  * transferring or if an exception occurred.
38  */
39 finally {
40     if (socket != null) {
41         if (socket.isConnected()) {
42             try {
43                 socket.close();
44             } catch (IOException e) {
45                 //catch logic
46             }
47         }
48     }
49 }