Wifi-Direct

xuke123

　　参考链接：http://developer.android.com/guide/topics/connectivity/wifip2p.html
　　国内镜像开发文档：http://wear.techbrood.com/guide/topics/connectivity/wifip2p.html
　　

API：
　　WifiP2pManager类提供了很多方法允许用户通过设备的Wi-Fi模块来进行交互，比如做一些如发现，连接其他对等设备的事情。下列的方法都是可以使用的： 表格1.Wi-Fi直连技术方法

方法名详细描述

　　initialize()


　　通过Wi-Fi框架对应用来进行注册。这个方法必须在任何其他Wi-Fi直连方法使用之前调用。




　　connect()]


　　开始一个拥有特定设置的设备的点对点连接。




　　cancelConnect()


　　取消任何一个正在进行的点对点组的连接。




　　requestConnectInfo()


　　获取一个设备的连接信息。




　　createGroup()


　　以当前设备为组拥有者来创建一个点对点连接组。




　　removeGroup()


　　移除当前的点对点连接组。




　　requestGroupInfo()


　　获取点对点连接组的信息。




　　discoverPeers()


　　初始化对等设备的发现。




　　requestPeers()


　　获取当前发现的对等设备列表。


　　WifiP2pManager的方法可以让你在一个监听器里传递参数，这样Wi-fi直连框架就可以通知给你的窗体这个方法调用的状态。可以被使用的监听器接口和使用监听器的相应的WifiP2pManager的方法的调用都将在下面这张表中有所描述：
　　表格 2. Wi-Fi直连监听器方法

监听器接口相关联的方法

　　WifiP2pManager.ActionListener


　　connect(), cancelConnect(), createGroup(), removeGroup(), and discoverPeers()




　　WifiP2pManager.ChannelListener


　　initialize()




　　WifiP2pManager.ConnectionInfoListener


　　requestConnectInfo()




　　WifiP2pManager.GroupInfoListener


　　requestGroupInfo()




　　WifiP2pManager.PeerListListener


　　requestPeers()


　　Wi-Fi直连技术的API定义了一些当特定的Wi-Fi直连事件发生时作为广播的意图，比如说当一个新的对等设备被发现，或者一个设备的Wi-Fi状态的改变。你可以在你的应用里通过创建一个处理这些意图的广播接收器来注册去接收这些意图。
　　Table 3. Wi-Fi 直连意图

意图名称详细描述

　　WIFI_P2P_CONNECTION_CHANGED_ACTION


　　当设备的Wi-Fi连接信息状态改变时候进行广播。




　　WIFI_P2P_PEERS_CHANGED_ACTION


　　当调用discoverPeers()方法的时候进行广播。在你的应用里处理此意图时，你通常会调用requestPeers()去获得对等设备列表的更新。




　　WIFI_P2P_STATE_CHANGED_ACTION


　　当设备的Wi-Fi 直连功能打开或关闭时进行广播。




　　WIFI_P2P_THIS_DEVICE_CHANGED_ACTION


　　当设备的详细信息改变的时候进行广播，比如设备的名称


　　

创建一个广播接收器
　　一个广播接收器允许你接收由android系统发布的意图广播，这样你的应用就可以对那些你感兴趣的事件作出响应。创建一个基本的Wi-Fi直连意图使用的广播接收器的步骤如下：
　　1.创建一个继承自BroadcastReceiver的类。对于类的构造，一般最常用的就是以WifiP2pManager, WifiP2pManager.Channel作为参数，同时这个广播接收器对应的窗体也将被注册进来。这个广播接收器可以像窗体发送更新或者在需要的时候可以访问Wi-Fi硬件或通信通道。
　　2.在广播接收器里，处理onReceive()方法里你感兴趣的意图。执行接收到的意图的任何需要的动作。比如，广播接收器接收到一个WIFI_P2P_PEERS_CHANGED_ACTION的意图，你就要调用requestPeers()方法去获得当前发现的对等设备列表。
　　下面的代码展示了怎样去创建一个典型的广播接收器。广播接收器接收一个WifiP2pManager对象和一个窗体对象作为参数然后利用这两个类去处理接收到的意图的特定的动作需求。
　　



1 @TargetApi(Build.VERSION_CODES.HONEYCOMB)
2 @SuppressLint("NewApi")
3 public class WiFiDirectBroadcastReceiver extends BroadcastReceiver {
4
5     private WifiP2pManager manager;
6     private Channel channel;
7     private WiFiDirectActivity activity;
8
9
10     public WiFiDirectBroadcastReceiver(WifiP2pManager manager, Channel channel,
11             WiFiDirectActivity activity) {
12         super();
13         this.manager = manager;
14         this.channel = channel;
15         this.activity = activity;
16     }
17
18
19     @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
20     @SuppressLint("NewApi")
21     @Override
22     public void onReceive(Context context, Intent intent) {
23         String action = intent.getAction();
24         if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
25             int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
26             if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
27             } else {
28                 Log.d(WiFiDirectActivity.TAG, "无法使用Wifi-Direct");
29                 activity.setIsWifiP2pEnabled(false);
30                 activity.resetData();
31
32             }
33             Log.d(WiFiDirectActivity.TAG, "P2P state changed - " + state);
34         } else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
35             if (manager != null) {
36                 manager.requestPeers(channel, (PeerListListener) activity.getFragmentManager()
37                         .findFragmentById(R.id.frag_list));
38             }
39             Log.d(WiFiDirectActivity.TAG, "P2P peers changed");
40         } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {
41             if (manager == null) {
42                 return;
43             }
44
45             NetworkInfo networkInfo = (NetworkInfo) intent
46                     .getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);
47
48             if (networkInfo.isConnected()) {
49
50                 // we are connected with the other device, request connection
51                 // info to find group owner IP
52
53                 DeviceDetailFragment fragment = (DeviceDetailFragment) activity
54                         .getFragmentManager().findFragmentById(R.id.frag_detail);
55                 manager.requestConnectionInfo(channel, fragment);
56             } else {
57                 // It's a disconnect
58                 activity.resetData();
59             }
60         } else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) {
61             DeviceListFragment fragment = (DeviceListFragment) activity.getFragmentManager()
62                     .findFragmentById(R.id.frag_list);
63             fragment.updateThisDevice((WifiP2pDevice) intent.getParcelableExtra(
64                     WifiP2pManager.EXTRA_WIFI_P2P_DEVICE));
65
66         }
67     }
68 }
　　

发现对等设备
　　要发现可以使用并连接的对等设备，调用discoverPeers()方法去检测在范围内的可使用设备。这个方法的调用是异步的同时如果你创建了一个WifiP2pManager.ActionListener监听器的话你会通过onSuccess()或者onFailure()方法收到发现成功或失败的消息。
　　onSuccess()方法只能通知你发现的过程是否成功而不能提供任何关于发现设备的信息：



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 });
连接到设备
　　当你已经找到你要连接的设备在获得发现设备列表之后，调用connect()方法去连接指定设备。这个方法的调用需要一个包含待连接设备信息的WifiP2pConfig对象。你可以通过WifiP2pManager.ActionListener接收到连接是否成功的通知。下面的代码展示了怎样去连接一个想得到的连接：



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

创建一个Wi-Fi直连的应用
　　创建一个Wi-Fi直连的应用包括创建和注册一个广播接收器，发现其他设备，连接其他设备，然后传输数据等步骤。接下来的几个部分描述了怎么去做这些工作。

初始化设置
　　在使用Wi-Fi直连的API之前，你必须确保你的应用可以访问设备的硬件并且你的设备要支持Wi-Fi直连的通讯协议。如果Wi-Fi直连技术是支持的，你可以获得一个WifiP2pManager的实例对象，然后创建并注册你的广播接收器，然后开始使用Wi-Fi直连的API方法。
　　1.为设备的Wi-Fi硬件获取权限并在Android的清单文件中声明你的应用正确使用的最低SDK版本：



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" />
　　2.在你的窗体的onCreate()方法里，获得一个WifiP2pManager的实例并调用initialize()方法通过Wi-Fi直连框架去注册你的应用。这个方法返回一个WifiP2pManager.Channel对象，是被用来连接你的应用和Wi-Fi直连框架的。你应该再创建一个以WifiP2pManager和WifiP2pManager.Channel为参数且关联你的窗体的广播接收器的实例。这样你的广播接收器就可以接收到你感兴趣的事件去通知你的窗体并更新它。它还可以让你在需要的时候操纵设备的Wi-Fi状态。



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 }
　　3.创建一个意图过滤器并把它添加在你的广播接收器需要处理的意图上。



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 }
　　4.注册你的广播接收器在窗体的onResume()方法，解除注册在onPause()方法中。



1 @Override
2 protected void onResume() {
3     super.onResume();
4     registerReceiver(mReceiver, mIntentFilter);
5 }
6 /* unregister the broadcast receiver */
7 @Override
8 protected void onPause() {
9     super.onPause();
10     unregisterReceiver(mReceiver);
11 }
　　当你获取到一个WifiP2pManager.Channel对象并且设置好你的广播接收器时，你的应用就可以调用Wi-Fi直连的方法并且可以接收Wi-Fi直连的意图。
　　你可以现在就通过调用WifiP2pManager中的方法取实现你的应用体验Wi-Fi直连技术的特性了。
　　
　　下面是窗体Activity的完整代码：



  1 @SuppressLint("NewApi")
  2 public class WiFiDirectActivity extends Activity implements ChannelListener, DeviceActionListener {
  3
  4     public static final String TAG = "wifidirectdemo";
  5     private WifiP2pManager manager;
  6     private boolean isWifiP2pEnabled = false;
  7     private boolean retryChannel = false;
  8
  9     private final IntentFilter intentFilter = new IntentFilter();
10     private Channel channel;
11     private BroadcastReceiver receiver = null;
12
13     public void setIsWifiP2pEnabled(boolean isWifiP2pEnabled) {
14         this.isWifiP2pEnabled = isWifiP2pEnabled;
15     }
16
17     @Override
18     public void onCreate(Bundle savedInstanceState) {
19         super.onCreate(savedInstanceState);
20         setContentView(R.layout.main);
21
22         // add necessary intent values to be matched.
23
24         intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
25         intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
26         intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
27         intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
28
29         manager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
30         channel = manager.initialize(this, getMainLooper(), null);
31     }
32
33     /** register the BroadcastReceiver with the intent values to be matched */
34     @Override
35     public void onResume() {
36         super.onResume();
37         receiver = new WiFiDirectBroadcastReceiver(manager, channel, this);
38         registerReceiver(receiver, intentFilter);
39     }
40
41     @Override
42     public void onPause() {
43         super.onPause();
44         unregisterReceiver(receiver);
45     }
46
47     /**
48      * Remove all peers and clear all fields. This is called on
49      * BroadcastReceiver receiving a state change event.
50      */
51     public void resetData() {
52         DeviceListFragment fragmentList = (DeviceListFragment) getFragmentManager()
53                 .findFragmentById(R.id.frag_list);
54         DeviceDetailFragment fragmentDetails = (DeviceDetailFragment) getFragmentManager()
55                 .findFragmentById(R.id.frag_detail);
56         if (fragmentList != null) {
57             fragmentList.clearPeers();
58         }
59         if (fragmentDetails != null) {
60             fragmentDetails.resetViews();
61         }
62     }
63
64     @Override
65     public boolean onCreateOptionsMenu(Menu menu) {
66         MenuInflater inflater = getMenuInflater();
67         inflater.inflate(R.menu.wi_fi_direct, menu);
68         return true;
69     }
70
71     @Override
72     public boolean onOptionsItemSelected(MenuItem item) {
73         switch (item.getItemId()) {
74             case R.id.atn_direct_enable:
75                 if (manager != null && channel != null) {
76
77                     // Since this is the system wireless settings activity, it's
78                     // not going to send us a result. We will be notified by
79                     // WiFiDeviceBroadcastReceiver instead.
80
81                     startActivity(new Intent(Settings.ACTION_WIRELESS_SETTINGS));
82                 } else {
83                     Log.e(TAG, "channel or manager is null");
84                 }
85                 return true;
86
87             case R.id.atn_direct_discover:
88                 if (!isWifiP2pEnabled) {
89                     Toast.makeText(WiFiDirectActivity.this, R.string.p2p_off_warning,
90                             Toast.LENGTH_SHORT).show();
91                     return true;
92                 }
93                 final DeviceListFragment fragment = (DeviceListFragment) getFragmentManager()
94                         .findFragmentById(R.id.frag_list);
95                 fragment.onInitiateDiscovery();
96                 manager.discoverPeers(channel, new WifiP2pManager.ActionListener() {
97
98                     @Override
99                     public void onSuccess() {
100                         Toast.makeText(WiFiDirectActivity.this, "Discovery Initiated",
101                                 Toast.LENGTH_SHORT).show();
102                     }
103
104                     @Override
105                     public void onFailure(int reasonCode) {
106                         Toast.makeText(WiFiDirectActivity.this, "Discovery Failed : " + reasonCode,
107                                 Toast.LENGTH_SHORT).show();
108                     }
109                 });
110                 return true;
111             default:
112                 return super.onOptionsItemSelected(item);
113         }
114     }
115
116     @Override
117     public void showDetails(WifiP2pDevice device) {
118         DeviceDetailFragment fragment = (DeviceDetailFragment) getFragmentManager()
119                 .findFragmentById(R.id.frag_detail);
120         fragment.showDetails(device);
121
122     }
123
124     @Override
125     public void connect(WifiP2pConfig config) {
126         manager.connect(channel, config, new ActionListener() {
127
128             @Override
129             public void onSuccess() {
130                 // WiFiDirectBroadcastReceiver will notify us. Ignore for now.
131                 Log.e(TAG, "Success!");
132             }
133
134             @Override
135             public void onFailure(int reason) {
136                 Toast.makeText(WiFiDirectActivity.this, "Connect failed. Retry.",
137                         Toast.LENGTH_SHORT).show();
138             }
139         });
140     }
141
142     @Override
143     public void disconnect() {
144         final DeviceDetailFragment fragment = (DeviceDetailFragment) getFragmentManager()
145                 .findFragmentById(R.id.frag_detail);
146         fragment.resetViews();
147         manager.removeGroup(channel, new ActionListener() {
148
149             @Override
150             public void onFailure(int reasonCode) {
151                 Log.d(TAG, "Disconnect failed. Reason :" + reasonCode);
152
153             }
154
155             @Override
156             public void onSuccess() {
157                 fragment.getView().setVisibility(View.GONE);
158             }
159
160         });
161     }
162
163     @Override
164     public void onChannelDisconnected() {
165         // we will try once more
166         if (manager != null && !retryChannel) {
167             Toast.makeText(this, "Channel lost. Trying again", Toast.LENGTH_LONG).show();
168             resetData();
169             retryChannel = true;
170             manager.initialize(this, getMainLooper(), this);
171         } else {
172             Toast.makeText(this,
173                     "Severe! Channel is probably lost premanently. Try Disable/Re-Enable P2P.",
174                     Toast.LENGTH_LONG).show();
175         }
176     }
177
178     @Override
179     public void cancelDisconnect() {
180
181         if (manager != null) {
182             final DeviceListFragment fragment = (DeviceListFragment) getFragmentManager()
183                     .findFragmentById(R.id.frag_list);
184             if (fragment.getDevice() == null
185                     || fragment.getDevice().status == WifiP2pDevice.CONNECTED) {
186                 disconnect();
187             } else if (fragment.getDevice().status == WifiP2pDevice.AVAILABLE
188                     || fragment.getDevice().status == WifiP2pDevice.INVITED) {
189
190                 manager.cancelConnect(channel, new ActionListener() {
191
192                     @Override
193                     public void onSuccess() {
194                         Toast.makeText(WiFiDirectActivity.this, "Aborting connection",
195                                 Toast.LENGTH_SHORT).show();
196                     }
197
198                     @Override
199                     public void onFailure(int reasonCode) {
200                         Toast.makeText(WiFiDirectActivity.this,
201                                 "Connect abort request failed. Reason Code: " + reasonCode,
202                                 Toast.LENGTH_SHORT).show();
203                     }
204                 });
205             }
206         }
207
208     }
209 }
显示设备连接的详细信息代码



  1 @TargetApi(Build.VERSION_CODES.HONEYCOMB)
  2 @SuppressLint("NewApi")
  3 public class DeviceListFragment extends ListFragment implements PeerListListener {
  4
  5     private List<WifiP2pDevice> peers = new ArrayList<WifiP2pDevice>();
  6     ProgressDialog progressDialog = null;
  7     View mContentView = null;
  8     private WifiP2pDevice device;
  9
10     @Override
11     public void onActivityCreated(Bundle savedInstanceState) {
12         super.onActivityCreated(savedInstanceState);
13         this.setListAdapter(new WiFiPeerListAdapter(getActivity(), R.layout.row_devices, peers));
14
15     }
16
17     @Override
18     public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
19         mContentView = inflater.inflate(R.layout.device_list, null);
20         return mContentView;
21     }
22
23     public WifiP2pDevice getDevice() {
24         return device;
25     }
26
27     private static String getDeviceStatus(int deviceStatus) {
28         Log.d(WiFiDirectActivity.TAG, "Peer status :" + deviceStatus);
29         switch (deviceStatus) {
30             case WifiP2pDevice.AVAILABLE:
31                 return "available";
32             case WifiP2pDevice.INVITED:
33                 return "invited";
34             case WifiP2pDevice.CONNECTED:
35                 return "connected";
36             case WifiP2pDevice.FAILED:
37                 return "failed";
38             case WifiP2pDevice.UNAVAILABLE:
39                 return "unavailable";
40             default:
41                 return "unknow";
42
43         }
44     }
45
46     /**
47      * Initiate a connection with the peer.
48      */
49     @Override
50     public void onListItemClick(ListView l, View v, int position, long id) {
51         WifiP2pDevice device = (WifiP2pDevice) getListAdapter().getItem(position);
52         ((DeviceActionListener) getActivity()).showDetails(device);
53     }
54
55     /**
56      * Array adapter for ListFragment that maintains WifiP2pDevice list.
57      */
58     private class WiFiPeerListAdapter extends ArrayAdapter<WifiP2pDevice> {
59
60         private List<WifiP2pDevice> items;
61
62         public WiFiPeerListAdapter(Context context, int textViewResourceId,
63                 List<WifiP2pDevice> objects) {
64             super(context, textViewResourceId, objects);
65             items = objects;
66
67         }
68
69         @Override
70         public View getView(int position, View convertView, ViewGroup parent) {
71             View v = convertView;
72             if (v == null) {
73                 LayoutInflater vi = (LayoutInflater) getActivity().getSystemService(
74                         Context.LAYOUT_INFLATER_SERVICE);
75                 v = vi.inflate(R.layout.row_devices, null);
76             }
77             WifiP2pDevice device = items.get(position);
78             if (device != null) {
79                 TextView top = (TextView) v.findViewById(R.id.device_name);
80                 TextView bottom = (TextView) v.findViewById(R.id.device_details);
81                 if (top != null) {
82                     top.setText(device.deviceName);
83                 }
84                 if (bottom != null) {
85                     bottom.setText(getDeviceStatus(device.status));
86                 }
87             }
88
89             return v;
90
91         }
92     }
93
94     public void updateThisDevice(WifiP2pDevice device) {
95         this.device = device;
96         TextView view = (TextView) mContentView.findViewById(R.id.my_name);
97         view.setText(device.deviceName);
98         view = (TextView) mContentView.findViewById(R.id.my_status);
99         view.setText(getDeviceStatus(device.status));
100     }
101     
102     @Override
103     public void onPeersAvailable(WifiP2pDeviceList peerList) {
104         if (progressDialog != null && progressDialog.isShowing()) {
105             progressDialog.dismiss();
106         }
107         peers.clear();
108         peers.addAll(peerList.getDeviceList());
109      
110         if (peers.size() == 0) {
111             Log.d(WiFiDirectActivity.TAG, "size==0");
112             return;
113         }
114
115     }
116
117     public void clearPeers() {
118         peers.clear();
119         ((WiFiPeerListAdapter) getListAdapter()).notifyDataSetChanged();
120     }
121
122     public void onInitiateDiscovery() {
123         if (progressDialog != null && progressDialog.isShowing()) {
124             progressDialog.dismiss();
125         }
126         progressDialog = ProgressDialog.show(getActivity(), "Press back to cancel", "finding peers", true,
127                 true, new DialogInterface.OnCancelListener() {
128
129                     @Override
130                     public void onCancel(DialogInterface dialog) {
131                        
132                     }
133                 });
134     }
135
136     public interface DeviceActionListener {
137
138         void showDetails(WifiP2pDevice device);
139
140         void cancelDisconnect();
141
142         void connect(WifiP2pConfig config);
143
144         void disconnect();
145     }
146
147 }
　　

数据传输
　　一旦连接已经建立，你可以通过套接字来进行数据的传输。基本的数据传输步骤如下：
　　1.创建一个ServerSocket对象。这个服务端套接字对象等待一个来自指定地址和端口的客户端的连接且阻塞线程直到连接发生，所以把它建立在一个后台线程里。
　　2.创建一个客户端Socket.这个客户端套接字对象使用指定ip地址和端口去连接服务端设备。
　　3.服务端等待客户端的连接(使用accept()方法)。这个调用阻塞服务端线程直到客户端连接上，所以叫这个过程一个新的线程。当连接建立时，服务端可以接受来自客户端的数据。执行关于数据的任何动作，比如保存数据或者展示给用户。
　　



1  　　　　@Override
2         protected String doInBackground(Void... params) {
3             try {
4                 ServerSocket serverSocket = new ServerSocket(8888);
5                 //服务器端口号
6                 Log.d(WiFiDirectActivity.TAG, "Server: Socket opened");
7                 Socket client = serverSocket.accept();
8                 //客户端绑定服务器端口
9                 //!!!!!!!!!!使用accept方法等待客户机发送数据
10                 Log.d(WiFiDirectActivity.TAG, "Server: connection done");
11                 
12                 
13                 final File f = new File(Environment.getExternalStorageDirectory() + "/"
14                         + context.getPackageName() + "/wifip2pshared-" + System.currentTimeMillis()
15                         + ".jpg");
16
17                 File dirs = new File(f.getParent());
18                 if (!dirs.exists())
19                     dirs.mkdirs();
20                 f.createNewFile();
21
22                 Log.d(WiFiDirectActivity.TAG, "server: copying files " + f.toString());
23                 InputStream inputstream = client.getInputStream();
24                 copyFile(inputstream, new FileOutputStream(f));
25                 serverSocket.close();
26                 return f.getAbsolutePath();
27             } catch (IOException e) {
28                 Log.e(WiFiDirectActivity.TAG, e.getMessage());
29                 return null;
30             }
31         }
　　4.服务端与客户端，官方demo只给出了客户端向服务端发送数据的方式。



1 @Override
2     public void onConnectionInfoAvailable(final WifiP2pInfo info) {
3         if (progressDialog != null && progressDialog.isShowing()) {
4             progressDialog.dismiss();
5         }
6         this.info = info;
7         this.getView().setVisibility(View.VISIBLE);
8
9         // The owner IP is now known.
10         TextView view = (TextView) mContentView.findViewById(R.id.group_owner);
11         view.setText(getResources().getString(R.string.group_owner_text)
12                 + ((info.isGroupOwner == true) ? getResources().getString(R.string.yes)
13                         : getResources().getString(R.string.no)));
14
15         // InetAddress from WifiP2pInfo struct.
16         view = (TextView) mContentView.findViewById(R.id.device_info);
17         view.setText("群主IP - " + info.groupOwnerAddress.getHostAddress());  
18
19         // After the group negotiation, we assign the group owner as the file
20         // server. The file server is single threaded, single connection server
21         // socket.
22         if (info.groupFormed && info.isGroupOwner) {      
23             new FileServerAsyncTask(getActivity(), mContentView.findViewById(R.id.status_text))
24                  .execute();
25         } else if (info.groupFormed) {
26             mContentView.findViewById(R.id.btn_start_client).setVisibility(View.VISIBLE);
27             ((TextView) mContentView.findViewById(R.id.status_text)).setText(getResources()
28                     .getString(R.string.client_text));
29         }
30         
31         // hide the connect button
32         mContentView.findViewById(R.id.btn_connect).setVisibility(View.GONE);
33     }
　　
　　完整代码如下：



  1 @TargetApi(Build.VERSION_CODES.HONEYCOMB)
  2 @SuppressLint("NewApi")
  3 public class DeviceDetailFragment extends Fragment implements ConnectionInfoListener {
  4
  5     protected static final int CHOOSE_FILE_RESULT_CODE = 20;
  6     private View mContentView = null;
  7     private WifiP2pDevice device;
  8     private WifiP2pInfo info;
  9     ProgressDialog progressDialog = null;
10
11     @Override
12     public void onActivityCreated(Bundle savedInstanceState) {
13         super.onActivityCreated(savedInstanceState);
14     }
15
16     @Override
17     public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
18
19         mContentView = inflater.inflate(R.layout.device_detail, null);
20         mContentView.findViewById(R.id.btn_connect).setOnClickListener(new View.OnClickListener() {
21
22             @Override
23             public void onClick(View v) {
24                 WifiP2pConfig config = new WifiP2pConfig();
25                 config.deviceAddress = device.deviceAddress;
26                 config.wps.setup = WpsInfo.PBC;
27                 if (progressDialog != null && progressDialog.isShowing()) {
28                     progressDialog.dismiss();
29                 }
30                 progressDialog = ProgressDialog.show(getActivity(), "Press back to cancel",
31                         "Connecting to :" + device.deviceAddress, true, true);
32             }
33         });
34
35         mContentView.findViewById(R.id.btn_disconnect).setOnClickListener(
36                 new View.OnClickListener() {
37
38                     @Override
39                     public void onClick(View v) {
40                         ((DeviceActionListener) getActivity()).disconnect();
41                     }
42                 });
43
44         mContentView.findViewById(R.id.btn_start_client).setOnClickListener(
45                 new View.OnClickListener() {
46
47                     @Override
48                     public void onClick(View v) {
49                         Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
50                         intent.setType("image/*");
51                         startActivityForResult(intent, CHOOSE_FILE_RESULT_CODE);
52                     }
53                 });
54
55         return mContentView;
56     }
57
58     @Override
59     public void onActivityResult(int requestCode, int resultCode, Intent data) {
60
61         // User has picked an image. Transfer it to group owner i.e peer using
62         // FileTransferService.
63         Uri uri = data.getData();
64         TextView statusText = (TextView) mContentView.findViewById(R.id.status_text);
65         statusText.setText("Sending: " + uri);
66         Log.d(WiFiDirectActivity.TAG, "Intent----------- " + uri);
67         Intent serviceIntent = new Intent(getActivity(), FileTransferService.class);
68         serviceIntent.setAction(FileTransferService.ACTION_SEND_FILE);
69         serviceIntent.putExtra(FileTransferService.EXTRAS_FILE_PATH, uri.toString());
70         serviceIntent.putExtra(FileTransferService.EXTRAS_GROUP_OWNER_ADDRESS,
71                 info.groupOwnerAddress.getHostAddress());
72         serviceIntent.putExtra(FileTransferService.EXTRAS_GROUP_OWNER_PORT, 8888);
73         getActivity().startService(serviceIntent);
74     }
75
76     @Override
77     public void onConnectionInfoAvailable(final WifiP2pInfo info) {
78         if (progressDialog != null && progressDialog.isShowing()) {
79             progressDialog.dismiss();
80         }
81         this.info = info;
82         this.getView().setVisibility(View.VISIBLE);
83
84         // The owner IP is now known.
85         TextView view = (TextView) mContentView.findViewById(R.id.group_owner);
86         view.setText(getResources().getString(R.string.group_owner_text)
87                 + ((info.isGroupOwner == true) ? getResources().getString(R.string.yes)
88                         : getResources().getString(R.string.no)));
89
90         // InetAddress from WifiP2pInfo struct.
91         view = (TextView) mContentView.findViewById(R.id.device_info);
92         view.setText("群主IP - " + info.groupOwnerAddress.getHostAddress());  
93
94         // After the group negotiation, we assign the group owner as the file
95         // server. The file server is single threaded, single connection server
96         // socket.
97         if (info.groupFormed && info.isGroupOwner) {      
98             new FileServerAsyncTask(getActivity(), mContentView.findViewById(R.id.status_text))
99                  .execute();
100         } else if (info.groupFormed) {
101             mContentView.findViewById(R.id.btn_start_client).setVisibility(View.VISIBLE);
102             ((TextView) mContentView.findViewById(R.id.status_text)).setText(getResources()
103                     .getString(R.string.client_text));
104         }
105         
106         // hide the connect button
107         mContentView.findViewById(R.id.btn_connect).setVisibility(View.GONE);
108     }
109
110     /**
111      * Updates the UI with device data
112      *
113      * @param device the device to be displayed
114      */
115     public void showDetails(WifiP2pDevice device) {
116         this.device = device;
117         this.getView().setVisibility(View.VISIBLE);
118         TextView view = (TextView) mContentView.findViewById(R.id.device_address);
119         view.setText(device.deviceAddress);
120         view = (TextView) mContentView.findViewById(R.id.device_info);
121         view.setText(device.toString());
122
123     }
124
125     /**
126      * Clears the UI fields after a disconnect or direct mode disable operation.
127      */
128     public void resetViews() {
129         mContentView.findViewById(R.id.btn_connect).setVisibility(View.VISIBLE);
130         TextView view = (TextView) mContentView.findViewById(R.id.device_address);
131         view.setText(R.string.empty);
132         view = (TextView) mContentView.findViewById(R.id.device_info);
133         view.setText(R.string.empty);
134         view = (TextView) mContentView.findViewById(R.id.group_owner);
135         view.setText(R.string.empty);
136         view = (TextView) mContentView.findViewById(R.id.status_text);
137         view.setText(R.string.empty);
138         mContentView.findViewById(R.id.btn_start_client).setVisibility(View.GONE);
139         this.getView().setVisibility(View.GONE);
140     }
141
142     public static class FileServerAsyncTask extends AsyncTask<Void, Void, String> {
143
144         private Context context;
145         private TextView statusText;
146
147         public FileServerAsyncTask(Context context, View statusText) {
148             this.context = context;
149             this.statusText = (TextView) statusText;
150         }
151
152         @Override
153         protected String doInBackground(Void... params) {
154             try {
155                 ServerSocket serverSocket = new ServerSocket(8888);
156                 //服务器端口号
157                 Log.d(WiFiDirectActivity.TAG, "Server: Socket opened");
158                 Socket client = serverSocket.accept();
159                 //客户端绑定服务器端
160                 //!!!!!!!!!!使用accept方法等待客户机发送数据
161                 Log.d(WiFiDirectActivity.TAG, "Server: connection done");
162                 
163                 
164                 final File f = new File(Environment.getExternalStorageDirectory() + "/"
165                         + context.getPackageName() + "/wifip2pshared-" + System.currentTimeMillis()
166                         + ".jpg");
167
168                 File dirs = new File(f.getParent());
169                 if (!dirs.exists())
170                     dirs.mkdirs();
171                 f.createNewFile();
172
173                 Log.d(WiFiDirectActivity.TAG, "server: copying files " + f.toString());
174                 InputStream inputstream = client.getInputStream();
175                 copyFile(inputstream, new FileOutputStream(f));
176                 serverSocket.close();
177                 return f.getAbsolutePath();
178             } catch (IOException e) {
179                 Log.e(WiFiDirectActivity.TAG, e.getMessage());
180                 return null;
181             }
182         }
183
184         @Override
185         protected void onPostExecute(String result) {
186             if (result != null) {
187                 statusText.setText("File copied - " + result);
188                 Intent intent = new Intent();
189                 intent.setAction(android.content.Intent.ACTION_VIEW);
190                 intent.setDataAndType(Uri.parse("file://" + result), "image/*");
191                 context.startActivity(intent);
192             }
193
194         }
195
196         @Override
197         protected void onPreExecute() {
198             statusText.setText("Opening a server socket");
199         }
200
201     }
202
203     public static boolean copyFile(InputStream inputStream, OutputStream out) {
204         byte buf[] = new byte[1024];
205         int len;
206         try {
207             while ((len = inputStream.read(buf)) != -1) {
208                 out.write(buf, 0, len);
209
210             }
211             out.close();
212             inputStream.close();
213         } catch (IOException e) {
214             Log.d(WiFiDirectActivity.TAG, e.toString());
215             return false;
216         }
217         return true;
218     }
219
220 }
　　文件传输代码如下：



1 public class FileTransferService extends IntentService {
2
3     private static final int SOCKET_TIMEOUT = 5000;
4     public static final String ACTION_SEND_FILE = "com.example.android.wifidirect.SEND_FILE";
5     public static final String EXTRAS_FILE_PATH = "file_url";
6     public static final String EXTRAS_GROUP_OWNER_ADDRESS = "go_host";
7     public static final String EXTRAS_GROUP_OWNER_PORT = "go_port";
8
9     public FileTransferService(String name) {
10         super(name);
11     }
12
13     public FileTransferService() {
14         super("FileTransferService");
15     }
16
17     @Override
18     protected void onHandleIntent(Intent intent) {
19
20         Context context = getApplicationContext();
21         if (intent.getAction().equals(ACTION_SEND_FILE)) {
22             String fileUri = intent.getExtras().getString(EXTRAS_FILE_PATH);
23             String host = intent.getExtras().getString(EXTRAS_GROUP_OWNER_ADDRESS);
24             Socket socket = new Socket();
25             int port = intent.getExtras().getInt(EXTRAS_GROUP_OWNER_PORT);
26         
27             try {
28                 Log.d(WiFiDirectActivity.TAG, "Opening client socket - ");
29                 socket.bind(null);
30                 socket.connect((new InetSocketAddress(host, port)), SOCKET_TIMEOUT);
31
32                 Log.d(WiFiDirectActivity.TAG, "Client socket - " + socket.isConnected());
33                 OutputStream stream = socket.getOutputStream();
34                 ContentResolver cr = context.getContentResolver();
35                 InputStream is = null;
36                 try {
37                     is = cr.openInputStream(Uri.parse(fileUri));
38                 } catch (FileNotFoundException e) {
39                     Log.d(WiFiDirectActivity.TAG, e.toString());
40                 }
41                 DeviceDetailFragment.copyFile(is, stream);
42                 Log.d(WiFiDirectActivity.TAG, "Client: Data written");
43             } catch (IOException e) {
44                 Log.e(WiFiDirectActivity.TAG, e.getMessage());
45             } finally {
46                 if (socket != null) {
47                     if (socket.isConnected()) {
48                         try {
49                             socket.close();
50                         } catch (IOException e) {
51                             // Give up
52                             e.printStackTrace();
53                         }
54                     }
55                 }
56             }
57
58         }
59         
60     }
61 }