二、注册广播

与 Wifi P2P 相关的广播有以下几个：

当接收到这几个广播时，我们都需要到 WifiP2pManager （对等网络管理器）来进行相应的信息请求，此外还需要用到 Channel 对象作为请求参数

mWifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);

mChannel = mWifiP2pManager.initialize( this, getMainLooper(), this);

当收到 WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION广播时，可以判断当前 Wifi P2P是否可用

intstate = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, - 1); if(state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {

mDirectActionListener.wifiP2pEnabled( true);

} else{

mDirectActionListener.wifiP2pEnabled( false);

}

当收到 WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION广播时，意味设备周围的可用设备列表发生了变化，可以通过 requestPeers方法得到可用的设备列表，之后就可以选择当中的某一个设备进行连接操作

mWifiP2pManager.requestPeers(mChannel, newWifiP2pManager.PeerListListener() {

@Override

publicvoidonPeersAvailable(WifiP2pDeviceList peers){

mDirectActionListener.onPeersAvailable(peers.getDeviceList());

}

});

当收到 WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION广播时，意味着 Wifi P2P 的连接状态发生了变化，可能是连接到了某设备，或者是与某设备断开了连接

NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);

if(networkInfo.isConnected()) {

mWifiP2pManager.requestConnectionInfo(mChannel, newWifiP2pManager.ConnectionInfoListener() {

@Override

publicvoidonConnectionInfoAvailable(WifiP2pInfo info){

mDirectActionListener.onConnectionInfoAvailable(info);

}

});

Log.e(TAG, "已连接p2p设备");

} else{

mDirectActionListener.onDisconnection();

Log.e(TAG, "与p2p设备已断开连接");

}

如果是与某设备连接上了，则可以通过 requestConnectionInfo方法获取到连接信息

当收到 WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION广播时，则可以获取到本设备变化后的设备信息

(WifiP2pDevice) intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE)

可以看出 Wifi P2P 的接口高度异步化，到现在已经用到了三个系统的回调函数，一个用于 WifiP2pManager 的初始化，两个用于在广播中异步请求数据，为了简化操作，此处统一使用一个自定义的回调函数，方法含义与系统的回调函数一致

publicinterfaceDirectActionListenerextendsWifiP2pManager.ChannelListener{

voidwifiP2pEnabled(booleanenabled);

voidonConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo);

voidonDisconnection();

voidonSelfDeviceAvailable(WifiP2pDevice wifiP2pDevice);

voidonPeersAvailable(Collection wifiP2pDeviceList);

}

所以，整个广播接收器使用到的所有代码是：

/**

* 作者：chenZY

* 时间：2018/2/9 17:53

* 描述：

*/

publicclassDirectBroadcastReceiverextendsBroadcastReceiver{

privatestaticfinalString TAG = "DirectBroadcastReceiver";

privateWifiP2pManager mWifiP2pManager;

privateWifiP2pManager.Channel mChannel;

privateDirectActionListener mDirectActionListener;

publicDirectBroadcastReceiver(WifiP2pManager wifiP2pManager, WifiP2pManager.Channel channel, DirectActionListener directActionListener){

mWifiP2pManager = wifiP2pManager;

mChannel = channel;

mDirectActionListener = directActionListener;

}

publicstaticIntentFilter getIntentFilter(){

IntentFilter intentFilter = newIntentFilter();

intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);

intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);

intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);

intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);

returnintentFilter;

}

@Override

publicvoidonReceive(Context context, Intent intent){

Log.e(TAG, "接收到广播： "+ intent.getAction());

if(!TextUtils.isEmpty(intent.getAction())) {

switch(intent.getAction()) {

// 用于指示 Wifi P2P 是否可用

caseWifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION: {

intstate = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, - 1);

if(state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {

mDirectActionListener.wifiP2pEnabled( true);

} else{

mDirectActionListener.wifiP2pEnabled( false);

List wifiP2pDeviceList = newArrayList();

mDirectActionListener.onPeersAvailable(wifiP2pDeviceList);

}

break;

}

// 对等节点列表发生了变化

caseWifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION: {

mWifiP2pManager.requestPeers(mChannel, newWifiP2pManager.PeerListListener() {

@Override

publicvoidonPeersAvailable(WifiP2pDeviceList peers){

mDirectActionListener.onPeersAvailable(peers.getDeviceList());

}

});

break;

}

// Wifi P2P 的连接状态发生了改变

caseWifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION: {

NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);

if(networkInfo.isConnected()) {

mWifiP2pManager.requestConnectionInfo(mChannel, newWifiP2pManager.ConnectionInfoListener() {

@Override

publicvoidonConnectionInfoAvailable(WifiP2pInfo info){

mDirectActionListener.onConnectionInfoAvailable(info);

}

});

Log.e(TAG, "已连接p2p设备");

} else{

mDirectActionListener.onDisconnection();

Log.e(TAG, "与p2p设备已断开连接");

}

break;

}

//本设备的设备信息发生了变化

caseWifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION: {

mDirectActionListener.onSelfDeviceAvailable((WifiP2pDevice) intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE));

break;

}

}

}

}

} 三、服务器端创建群组

假设当设备A搜索到了设备B，并与设备B连接到了一起，此时系统会自动创建一个群组（Group）并随机指定一台设备为群主（GroupOwner）。此时，对于两台设备来说，群主的IP地址是可知的（系统回调函数中有提供），但客户端的IP地址需要再来通过其他方法来主动获取。例如，可以在设备连接成功后，客户端主动发起对服务器端的Socket连接请求，服务器端在指定端口监听客户端的连接请求，当连接成功后，服务器端就可以获取到客户端的IP地址了

此处为了简化操作，直接指定某台设备作为服务器端（群主），即直接指定某台设备用来接收文件

因此，服务器端要主动创建群组，并等待客户端的连接

wifiP2pManager.createGroup(channel, newWifiP2pManager.ActionListener() {

@Override

publicvoidonSuccess(){

Log.e(TAG, "createGroup onSuccess");

dismissLoadingDialog();

showToast( "onSuccess");

}

@Override

publicvoidonFailure(intreason){

Log.e(TAG, "createGroup onFailure: "+ reason);

dismissLoadingDialog();

showToast( "onFailure");

}

});

此处，使用 IntentService 在后台监听客户端的Socket连接请求，并通过输入输出流来传输文件。此处的代码比较简单，就只是在指定端口一直堵塞监听客户端的连接请求，获取待传输的文件信息模型 FileTransfer ，之后就进行实际的数据传输

@Override

protectedvoidonHandleIntent(Intent intent){

clean();

File file = null;

try{

serverSocket = newServerSocket();

serverSocket.setReuseAddress( true);

serverSocket.bind( newInetSocketAddress(PORT));

Socket client = serverSocket.accept();

Log.e(TAG, "客户端IP地址 : "+ client.getInetAddress().getHostAddress());

inputStream = client.getInputStream();

objectInputStream = newObjectInputStream(inputStream);

FileTransfer fileTransfer = (FileTransfer) objectInputStream.readObject();

Log.e(TAG, "待接收的文件: "+ fileTransfer);

String name = newFile(fileTransfer.getFilePath()).getName();

//将文件存储至指定位置

file = newFile(Environment.getExternalStorageDirectory() + "/"+ name);

fileOutputStream = newFileOutputStream(file);

bytebuf[] = newbyte[ 512];

intlen;

longtotal = 0;

intprogress;

while((len = inputStream.read(buf)) != - 1) {

fileOutputStream.write(buf, 0, len);

total += len;

progress = ( int) ((total * 100) / fileTransfer.getFileLength());

Log.e(TAG, "文件接收进度: "+ progress);

if(progressChangListener != null) {

progressChangListener.onProgressChanged(fileTransfer, progress);

}

}

serverSocket.close();

inputStream.close();

objectInputStream.close();

fileOutputStream.close();

serverSocket = null;

inputStream = null;

objectInputStream = null;

fileOutputStream = null;

Log.e(TAG, "文件接收成功，文件的MD5码是："+ Md5Util.getMd5(file));

} catch(Exception e) {

Log.e(TAG, "文件接收 Exception: "+ e.getMessage());

} finally{

clean();

if(progressChangListener != null) {

progressChangListener.onTransferFinished(file);

}

//再次启动服务，等待客户端下次连接

startService( newIntent( this, WifiServerService.class));

}

}

因为客户端可能会多次发起连接请求，所以当此处文件传输完成后（不管成功或失败），都需要重新 startService ，让服务再次堵塞等待客户端的连接请求

FileTransfer 包含三个字段，MD5码值用于校验文件的完整性，fileLength 是为了用于计算文件的传输进度

publicclassFileTransferimplementsSerializable{

//文件路径

privateString filePath;

//文件大小

privatelongfileLength;

//MD5码

privateString md5;

···

}

为了将文件传输进度发布到外部界面，所以除了需要启动Service外，界面还需要绑定Service，此处就需要用到一个更新文件传输状态的接口

publicinterfaceOnProgressChangListener{

//当传输进度发生变化时

voidonProgressChanged(FileTransfer fileTransfer, intprogress);

//当传输结束时

voidonTransferFinished(File file);

}

因此，需要将 progressChangListener 作为参数传给 WifiServerService ，并在进度变化时更新进度对话框

privateWifiServerService.OnProgressChangListener progressChangListener = newWifiServerService.OnProgressChangListener() {

@Override

publicvoidonProgressChanged(finalFileTransfer fileTransfer, finalintprogress){

runOnUiThread( newRunnable() {

@Override

publicvoidrun(){

progressDialog.setMessage( "文件名： "+ newFile(fileTransfer.getFilePath()).getName());

progressDialog.setProgress(progress);

progressDialog.show();

}

});

}

@Override

publicvoidonTransferFinished(finalFile file){

runOnUiThread( newRunnable() {

@Override

publicvoidrun(){

progressDialog.cancel();

if(file != null&& file.exists()) {

openFile(file.getPath());

}

}

});

}

}; 四、客户端加入群组并发起文件传输请求

文件发送界面 SendFileActivity 需要实现 DirectActionListener 接口

首先，需要先注册P2P广播，以便获取周边设备信息以及连接状态

@Override

protectedvoidonCreate(Bundle savedInstanceState){

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_send_file);

initView();

mWifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);

mChannel = mWifiP2pManager.initialize( this, getMainLooper(), this);

broadcastReceiver = newDirectBroadcastReceiver(mWifiP2pManager, mChannel, this);

registerReceiver(broadcastReceiver, DirectBroadcastReceiver.getIntentFilter());

}

通过 discoverPeers方法搜索周边设备，回调函数用于通知方法是否调用成功

mWifiP2pManager.discoverPeers(mChannel, newWifiP2pManager.ActionListener() {

@Override

publicvoidonSuccess(){

showToast( "Success");

}

@Override

publicvoidonFailure(intreasonCode){

showToast( "Failure");

loadingDialog.cancel();

}

});

当搜索结束后，系统就会触发 WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION广播，此时就可以调用 requestPeers方法获取设备列表信息，此处用 RecyclerView 展示列表，在 onPeersAvailable 方法刷新列表

mWifiP2pManager.requestPeers(mChannel, newWifiP2pManager.PeerListListener() {

@Override

publicvoidonPeersAvailable(WifiP2pDeviceList peers){

mDirectActionListener.onPeersAvailable(peers.getDeviceList());

}

}); @Override

publicvoidonPeersAvailable(Collection wifiP2pDeviceList){

Log.e(TAG, "onPeersAvailable :"+ wifiP2pDeviceList.size());

this.wifiP2pDeviceList.clear();

this.wifiP2pDeviceList.addAll(wifiP2pDeviceList);

deviceAdapter.notifyDataSetChanged();

loadingDialog.cancel();

}

之后，通过点击事件选中群主（服务器端）设备，通过 connect方法请求与之进行连接

privatevoidconnect(){

WifiP2pConfig config = newWifiP2pConfig();

if(config.deviceAddress != null&& mWifiP2pDevice != null) {

config.deviceAddress = mWifiP2pDevice.deviceAddress;

config.wps.setup = WpsInfo.PBC;

showLoadingDialog( "正在连接 "+ mWifiP2pDevice.deviceName);

mWifiP2pManager.connect(mChannel, config, newWifiP2pManager.ActionListener() {

@Override

publicvoidonSuccess(){

Log.e(TAG, "connect onSuccess"); }

@Override

publicvoidonFailure(intreason){

showToast( "连接失败 "+ reason);

dismissLoadingDialog();

}

});

}

}

此处依然无法通过函数函数来判断连接结果，需要依靠系统发出的 WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION方法来获取到连接结果，在此处可以通过 requestConnectionInfo获取到组连接信息，信息最后通过 onConnectionInfoAvailable方法传递出来，在此可以判断当前设备是否为群主，获取群组IP地址

@Override

publicvoidonConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo){

dismissLoadingDialog();

wifiP2pDeviceList.clear();

deviceAdapter.notifyDataSetChanged();

btn_disconnect.setEnabled( true);

btn_chooseFile.setEnabled( true);

Log.e(TAG, "onConnectionInfoAvailable");

Log.e(TAG, "onConnectionInfoAvailable groupFormed: "+ wifiP2pInfo.groupFormed);

Log.e(TAG, "onConnectionInfoAvailable isGroupOwner: "+ wifiP2pInfo.isGroupOwner);

Log.e(TAG, "onConnectionInfoAvailable getHostAddress: "+ wifiP2pInfo.groupOwnerAddress.getHostAddress());

StringBuilder stringBuilder = newStringBuilder();

if(mWifiP2pDevice != null) {

stringBuilder.append( "连接的设备名：");

stringBuilder.append(mWifiP2pDevice.deviceName);

stringBuilder.append( "");

stringBuilder.append( "连接的设备的地址：");

stringBuilder.append(mWifiP2pDevice.deviceAddress);

}

stringBuilder.append( "");

stringBuilder.append( "是否群主：");

stringBuilder.append(wifiP2pInfo.isGroupOwner ? "是群主": "非群主");

stringBuilder.append( "");

stringBuilder.append( "群主IP地址：");

stringBuilder.append(wifiP2pInfo.groupOwnerAddress.getHostAddress());

tv_status.setText(stringBuilder);

if(wifiP2pInfo.groupFormed && !wifiP2pInfo.isGroupOwner) {

this.wifiP2pInfo = wifiP2pInfo;

}

}

至此服务器端和客户端已经通过 Wifi P2P 连接在了一起，客户端也获取到了服务器端的IP地址，在选取好待发送的文件后就可以主动发起对服务器端的连接请求了

发起选取文件的方法

Intent intent = newIntent(Intent.ACTION_GET_CONTENT);

intent.setType( "*/*");

intent.addCategory(Intent.CATEGORY_OPENABLE);

startActivityForResult(intent, 1);

获取选取的文件的实际路径

@Override

protectedvoidonActivityResult(intrequestCode, intresultCode, Intent data){

super.onActivityResult(requestCode, resultCode, data);

if(requestCode == 1) {

if(resultCode == RESULT_OK) {

Uri uri = data.getData();

if(uri != null) {

String path = getPath( this, uri);

if(path != null) {

File file = newFile(path);

if(file.exists() && wifiP2pInfo != null) {

FileTransfer fileTransfer = newFileTransfer(file.getPath(), file.length());

Log.e(TAG, "待发送的文件："+ fileTransfer);

newWifiClientTask( this, fileTransfer).execute(wifiP2pInfo.groupOwnerAddress.getHostAddress());

}

}

}

}

}

}

privateString getPath(Context context, Uri uri){

if( "content".equalsIgnoreCase(uri.getScheme())) {

Cursor cursor = context.getContentResolver().query(uri, newString[]{ "_data"}, null, null, null);

if(cursor != null) {

if(cursor.moveToFirst()) {

String data = cursor.getString(cursor.getColumnIndex( "_data"));

cursor.close();

returndata;

}

}

} elseif("file".equalsIgnoreCase(uri.getScheme())) {

returnuri.getPath();

}

returnnull;

}

文件的发送操作放到 AsyncTask 中处理，将服务器端的IP地址作为参数传进来，在正式发送文件前，先发送包含文件信息（文件名，文件大小，文件MD5码）的信息模型 FileTransfer ，并在发送文件的过程中同时更新进度

/**

* 作者：叶应是叶

* 时间：2018/2/15 8:51

* 描述：客户端发送文件

*/

publicclassWifiClientTaskextendsAsyncTask {

privateProgressDialog progressDialog;

privateFileTransfer fileTransfer;

privatestaticfinalintPORT = 4786;

privatestaticfinalString TAG = "WifiClientTask";

publicWifiClientTask(Context context, FileTransfer fileTransfer){

this.fileTransfer = fileTransfer;

progressDialog = newProgressDialog(context);

progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);

progressDialog.setCancelable( false);

progressDialog.setCanceledOnTouchOutside( false);

progressDialog.setTitle( "正在发送文件");

progressDialog.setMax( 100);

}

@Override

protectedvoidonPreExecute(){

progressDialog.show();

}

@Override

protectedBoolean doInBackground(String... strings){

fileTransfer.setMd5(Md5Util.getMd5( newFile(fileTransfer.getFilePath())));

Log.e(TAG, "文件的MD5码值是："+ fileTransfer.getMd5());

Socket socket = null;

OutputStream outputStream = null;

ObjectOutputStream objectOutputStream = null;

InputStream inputStream = null;

try{

socket = newSocket();

socket.bind( null);

socket.connect(( newInetSocketAddress(strings[ 0], PORT)), 10000);

outputStream = socket.getOutputStream();

objectOutputStream = newObjectOutputStream(outputStream);

objectOutputStream.writeObject(fileTransfer);

inputStream = newFileInputStream( newFile(fileTransfer.getFilePath()));

longfileSize = fileTransfer.getFileLength();

longtotal = 0;

bytebuf[] = newbyte[ 512];

intlen;

while((len = inputStream.read(buf)) != - 1) {

outputStream.write(buf, 0, len);

total += len;

intprogress = ( int) ((total * 100) / fileSize);

publishProgress(progress);

Log.e(TAG, "文件发送进度："+ progress); }

outputStream.close(); objectOutputStream.close();

inputStream.close(); socket.close();

outputStream = null; objectOutputStream = null;

inputStream = null; socket = null;

Log.e(TAG, "文件发送成功");

returntrue; } catch(Exception e) { Log.e(TAG, "文件发送异常 Exception: "+ e.getMessage()); } finally{

if(outputStream != null) {

try{ outputStream.close(); } catch(IOException e) { e.printStackTrace(); } }

if(objectOutputStream != null) {

try{ objectOutputStream.close(); } catch(IOException e) { e.printStackTrace(); } }

if(inputStream != null) {

try{ inputStream.close(); } catch(IOException e) { e.printStackTrace(); } }

if(socket != null) {

try{ socket.close(); } catch(Exception e) { e.printStackTrace(); } } }

returnfalse; }

@OverrideprotectedvoidonProgressUpdate(Integer... values){ progressDialog.setProgress(values[ 0]); }

@OverrideprotectedvoidonPostExecute(Boolean aBoolean){ progressDialog.cancel(); Log.e(TAG, "onPostExecute: "+ aBoolean); }} 五、校验文件完整性

传输文件的完整性主要是通过计算文件的MD5码值来保证了，在发送文件前，即在 WifiClientTask 的 doInBackground 方法中进行计算，将MD5码值赋给 FileTransfer 模型，通过如下方法计算得到

/**

* 作者：叶应是叶

* 时间：2018/2/14 21:16

* 描述：

*/

publicclassMd5Util{

publicstaticString getMd5(File file){ InputStream inputStream = null;

byte[] buffer = newbyte[ 2048];

intnumRead; MessageDigest md5;

try{ inputStream = newFileInputStream(file); md5 = MessageDigest.getInstance( "MD5");

while((numRead = inputStream.read(buffer)) > 0) { md5.update(buffer, 0, numRead); } inputStream.close(); inputStream = null;

returnmd5ToString(md5.digest()); } catch(Exception e) {

returnnull; } finally{

if(inputStream != null) {

try{ inputStream.close(); } catch(IOException e) { e.printStackTrace(); } } } }

privatestaticString md5ToString(byte[] md5Bytes){ StringBuilder hexValue = newStringBuilder();

for( byteb : md5Bytes) {

intval = (( int) b) & 0xff;

if(val < 16) { hexValue.append( "0"); } hexValue.append(Integer.toHexString(val)); }

returnhexValue.toString(); }}

因为客户端会将 FileTransfer 传给服务器端，所以服务器端在文件传输结束后，可以重新计算文件的MD5码值，进行对比以判断文件是否完整。

代码地址：https://github.com/leavesC/WifiP2P返回搜狐，查看更多