Android如何实现无网络传输文件

移动开发 Android
最近的项目需要实现一个 Android 手机之间无网络传输文件的功能,就发现了 Wifi P2P(Wifi点对点)这么一个功能,最后也实现了通过 Wifi 隔空传输文件的功能,这里我也来整理下代码,分享给大家。

最近的项目需要实现一个 Android 手机之间无网络传输文件的功能,就发现了 Wifi P2P(Wifi点对点)这么一个功能,最后也实现了通过 Wifi 隔空传输文件的功能,这里我也来整理下代码,分享给大家。

Wifi P2P 是在 Android 4.0 以及更高版本系统中加入的功能,通过 Wifi P2P 可以在不连接网络的情况下,直接与配对的设备进行数据交换。相对于蓝牙,Wifi P2P 的搜索速度和传输速度更快,传输距离更远

实现的效果如下所示:

 

一般而言,开发步骤分为以下几点:

  • 在 AndroidManifest 中声明相关权限(网络和文件读写权限)
  • 获取 WifiP2pManager ,注册相关广播监听Wifi直连的状态变化
  • 指定某一台设备为服务器(用来接收文件),创建群组并作为群主存在,在指定端口监听客户端的连接请求,等待客户端发起连接请求以及文件传输请求
  • 客户端(用来发送文件)主动搜索附近的设备,加入到服务器创建的群组,获取服务器的IP地址,向其发起文件传输请求
  • 校验文件完整性

一、声明权限

Wifi P2P 技术并不会访问网络,但由于会使用到 Java socket,所以需要申请网络权限。此外,由于是要实现文件互传,所以也需要申请SD卡读写权限。   

  1. <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />  
  2. <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />  
  3. <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />  
  4. <uses-permission android:name="android.permission.INTERNET" />  
  5. <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />  
  6. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />  
  7. <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /> 

 

二、注册广播

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

  • WIFI_P2P_STATE_CHANGED_ACTION( 用于指示 Wifi P2P 是否可用 )
  • WIFI_P2P_PEERS_CHANGED_ACTION( 对等节点列表发生了变化 )
  • WIFI_P2P_CONNECTION_CHANGED_ACTION( Wifi P2P 的连接状态发生了改变 )
  • WIFI_P2P_THIS_DEVICE_CHANGED_ACTION( 本设备的设备信息发生了变化 )

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

 

  1. mWifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);  
  2. mChannel = mWifiP2pManager.initialize(this, getMainLooper(), this); 

 

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

 

  1. int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {  
  2.     mDirectActionListener.wifiP2pEnabled(true);  
  3. else {  
  4.     mDirectActionListener.wifiP2pEnabled(false);  

 

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

 

  1. mWifiP2pManager.requestPeers(mChannel, new WifiP2pManager.PeerListListener() {    @Override  
  2.     public void onPeersAvailable(WifiP2pDeviceList peers) {  
  3.         mDirectActionListener.onPeersAvailable(peers.getDeviceList());  
  4.     }  
  5. }); 

 

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

 

  1. NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);if (networkInfo.isConnected()) {  
  2.     mWifiP2pManager.requestConnectionInfo(mChannel, new WifiP2pManager.ConnectionInfoListener() {        @Override 
  3.  
  4.         public void onConnectionInfoAvailable(WifiP2pInfo info) {  
  5.             mDirectActionListener.onConnectionInfoAvailable(info);  
  6.         }  
  7.     });  
  8.     Log.e(TAG, "已连接p2p设备");  
  9. else {  
  10.     mDirectActionListener.onDisconnection();  
  11.     Log.e(TAG, "与p2p设备已断开连接");  

 

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

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

 

  1. (WifiP2pDevice) intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE) 

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

 

  1. public interface DirectActionListener extends WifiP2pManager.ChannelListener {  
  2.     void wifiP2pEnabled(boolean enabled);      
  3.     void onConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo);  
  4.     void onDisconnection();      
  5.     void onSelfDeviceAvailable(WifiP2pDevice wifiP2pDevice);     
  6.     void onPeersAvailable(Collection<WifiP2pDevice> wifiP2pDeviceList); 

 

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

 

  1. /** 
  2.  
  3.  * 作者:chenZY 
  4.  
  5.  * 时间:2018/2/9 17:53 
  6.  
  7.  * 描述: 
  8.  
  9.  */  
  10. public class DirectBroadcastReceiver extends BroadcastReceiver {  
  11.     private static final String TAG = "DirectBroadcastReceiver";     
  12.     private WifiP2pManager mWifiP2pManager;     
  13.     private WifiP2pManager.Channel mChannel;    
  14.     private DirectActionListener mDirectActionListener;      
  15.  
  16.     public DirectBroadcastReceiver(WifiP2pManager wifiP2pManager, WifiP2pManager.Channel channel, DirectActionListener directActionListener) {  
  17.         mWifiP2pManager = wifiP2pManager;  
  18.         mChannel = channel;  
  19.         mDirectActionListener = directActionListener;  
  20.     }     
  21.     public static IntentFilter getIntentFilter() {  
  22.         IntentFilter intentFilter = new IntentFilter();  
  23.         intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);  
  24.         intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);  
  25.         intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);  
  26.         intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);  
  27.  
  28.         return intentFilter;  
  29.     }   
  30.  
  31.     @Override  
  32.     public void onReceive(Context context, Intent intent) {  
  33.         Log.e(TAG, "接收到广播: " + intent.getAction()); 
  34.         if (!TextUtils.isEmpty(intent.getAction())) {  
  35.             switch (intent.getAction()) {      
  36.                 // 用于指示 Wifi P2P 是否可用 
  37.                 case WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION: {     
  38.                     int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);   
  39.                     if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) { 
  40.                         mDirectActionListener.wifiP2pEnabled(true); 
  41.                     } else { 
  42.                         mDirectActionListener.wifiP2pEnabled(false); 
  43.                         List<WifiP2pDevice> wifiP2pDeviceList = new ArrayList<>(); 
  44.                         mDirectActionListener.onPeersAvailable(wifiP2pDeviceList); 
  45.                     }                     
  46.                     break; 
  47.                  }                 
  48.  
  49.                 // 对等节点列表发生了变化  
  50.                 case WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION: {  
  51.                     mWifiP2pManager.requestPeers(mChannel, new WifiP2pManager.PeerListListener() {  
  52.                         @Override 
  53.                          public void onPeersAvailable(WifiP2pDeviceList peers) { 
  54.                             mDirectActionListener.onPeersAvailable(peers.getDeviceList()); 
  55.                         } 
  56.                     });          
  57.                     break; 
  58.                 }                 
  59.                  // Wifi P2P 的连接状态发生了改变  
  60.                 case WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION: { 
  61.                     NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);   
  62.                     if (networkInfo.isConnected()) { 
  63.                         mWifiP2pManager.requestConnectionInfo(mChannel, new WifiP2pManager.ConnectionInfoListener() {   
  64.                             @Override 
  65.                             public void onConnectionInfoAvailable(WifiP2pInfo info) { 
  66.                                 mDirectActionListener.onConnectionInfoAvailable(info); 
  67.                             } 
  68.                         });  
  69.                         Log.e(TAG, "已连接p2p设备");  
  70.                     } else {  
  71.                         mDirectActionListener.onDisconnection();  
  72.                         Log.e(TAG, "与p2p设备已断开连接");  
  73.                     }                     
  74.                     break;  
  75.                 }                 
  76.  
  77.                 //本设备的设备信息发生了变化  
  78.                 case WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION: { 
  79.                     mDirectActionListener.onSelfDeviceAvailable((WifiP2pDevice) intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE));   
  80.                     break; 
  81.                 } 
  82.             } 
  83.         } 
  84.     } 

 

三、服务器端创建群组

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

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

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

 

  1. wifiP2pManager.createGroup(channel, new WifiP2pManager.ActionListener() {  
  2.     @Override 
  3.     public void onSuccess() { 
  4.         Log.e(TAG, "createGroup onSuccess"); 
  5.         dismissLoadingDialog(); 
  6.         showToast("onSuccess"); 
  7.     }     
  8.  
  9.     @Override 
  10.      public void onFailure(int reason) { 
  11.         Log.e(TAG, "createGroup onFailure: " + reason); 
  12.         dismissLoadingDialog(); 
  13.         showToast("onFailure"); 
  14.     } 
  15. }); 

 

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

 

  1. @Override  
  2.  protected void onHandleIntent(Intent intent) { 
  3.      clean(); 
  4.      File file = null;      
  5.      try {  
  6.          serverSocket = new ServerSocket();  
  7.          serverSocket.setReuseAddress(true);  
  8.          serverSocket.bind(new InetSocketAddress(PORT));  
  9.          Socket client = serverSocket.accept();  
  10.          Log.e(TAG, "客户端IP地址 : " + client.getInetAddress().getHostAddress());  
  11.          inputStream = client.getInputStream();  
  12.          objectInputStream = new ObjectInputStream(inputStream);  
  13.          FileTransfer fileTransfer = (FileTransfer) objectInputStream.readObject(); 
  14.          Log.e(TAG, "待接收的文件: " + fileTransfer);  
  15.          String name = new File(fileTransfer.getFilePath()).getName();         
  16.  
  17.          //将文件存储至指定位置  
  18.          file = new File(Environment.getExternalStorageDirectory() + "/" + name);  
  19.          fileOutputStream = new FileOutputStream(file);    
  20.          byte buf[] = new byte[512];       
  21.          int len;             
  22.          long total = 0;            
  23.          int progress;            
  24.          while ((len = inputStream.read(buf)) != -1) { 
  25.              fileOutputStream.write(buf, 0, len); 
  26.              total += len; 
  27.              progress = (int) ((total * 100) / fileTransfer.getFileLength()); 
  28.              Log.e(TAG, "文件接收进度: " + progress);     
  29.              if (progressChangListener != null) { 
  30.                  progressChangListener.onProgressChanged(fileTransfer, progress); 
  31.              } 
  32.           } 
  33.          serverSocket.close(); 
  34.          inputStream.close(); 
  35.          objectInputStream.close();  
  36.          fileOutputStream.close();  
  37.          serverSocket = null 
  38.          inputStream = null 
  39.          objectInputStream = null 
  40.          fileOutputStream = null 
  41.          Log.e(TAG, "文件接收成功,文件的MD5码是:" + Md5Util.getMd5(file));  
  42.      } catch (Exception e) {  
  43.          Log.e(TAG, "文件接收 Exception: " + e.getMessage());  
  44.      } finally {  
  45.          clean();            
  46.           if (progressChangListener != null) {  
  47.              progressChangListener.onTransferFinished(file);  
  48.          }     
  49.          //再次启动服务,等待客户端下次连接 
  50.          startService(new Intent(this, WifiServerService.class)); 
  51.      }  
  52.  } 

 

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

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

 

  1. public class FileTransfer implements Serializable { 
  2.     //文件路径 
  3.     private String filePath;      
  4.     //文件大小 
  5.     private long fileLength;   
  6.     //MD5码  
  7.     private String md5;  
  8.     ··· 

 

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

 

  1. public interface OnProgressChangListener {  
  2.     //当传输进度发生变化时  
  3.     void onProgressChanged(FileTransfer fileTransfer, int progress);  
  4.     //当传输结束时 
  5.     void onTransferFinished(File file); 

 

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

 

  1. private WifiServerService.OnProgressChangListener progressChangListener = new WifiServerService.OnProgressChangListener() {    
  2.        @Override 
  3.        public void onProgressChanged(final FileTransfer fileTransfer, final int progress) { 
  4.            runOnUiThread(new Runnable() { 
  5.                @Override 
  6.                public void run() { 
  7.                   progressDialog.setMessage("文件名: " + new File(fileTransfer.getFilePath()).getName()); 
  8.                    progressDialog.setProgress(progress); 
  9.                    progressDialog.show(); 
  10.                } 
  11.            }); 
  12.         }      
  13.  
  14.        @Override  
  15.        public void onTransferFinished(final File file) {  
  16.            runOnUiThread(new Runnable() {   
  17.                @Override 
  18.                public void run() { 
  19.                    progressDialog.cancel();  
  20.                    if (file != null &amp;&amp; file.exists()) { 
  21.                        openFile(file.getPath()); 
  22.                    } 
  23.                } 
  24.            }); 
  25.        } 
  26.    }; 

 

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

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

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

 

  1. @Override  
  2. protected void onCreate(Bundle savedInstanceState) { 
  3.     super.onCreate(savedInstanceState);  
  4.     setContentView(R.layout.activity_send_file);  
  5.     initView();  
  6.     mWifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);  
  7.     mChannel = mWifiP2pManager.initialize(this, getMainLooper(), this);  
  8.     broadcastReceiver = new DirectBroadcastReceiver(mWifiP2pManager, mChannel, this);  
  9.     registerReceiver(broadcastReceiver, DirectBroadcastReceiver.getIntentFilter());  

 

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

 

  1. mWifiP2pManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() {    @Override  
  2.     public void onSuccess() {  
  3.         showToast("Success");  
  4.     }     
  5.  
  6.     @Override  
  7.     public void onFailure(int reasonCode) {  
  8.         showToast("Failure");  
  9.         loadingDialog.cancel(); 
  10.      }  
  11. }); 

 

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

 

  1. mWifiP2pManager.requestPeers(mChannel, new WifiP2pManager.PeerListListener() {  
  2.     @Override  
  3.     public void onPeersAvailable(WifiP2pDeviceList peers) {  
  4.         mDirectActionListener.onPeersAvailable(peers.getDeviceList());  
  5.     } 
  6. }); 
  7.  
  8.     @Override  
  9.     public void onPeersAvailable(Collection<WifiP2pDevice> wifiP2pDeviceList) {  
  10.         Log.e(TAG, "onPeersAvailable :" + wifiP2pDeviceList.size());  
  11.         this.wifiP2pDeviceList.clear();         
  12.         this.wifiP2pDeviceList.addAll(wifiP2pDeviceList);  
  13.         deviceAdapter.notifyDataSetChanged(); 
  14.         loadingDialog.cancel(); 
  15.     } 

 

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

 

  1. private void connect() {  
  2.     WifiP2pConfig config = new WifiP2pConfig();  
  3.     if (config.deviceAddress != null &amp;&amp; mWifiP2pDevice != null) {  
  4.         config.deviceAddress = mWifiP2pDevice.deviceAddress;  
  5.         config.wps.setup = WpsInfo.PBC;  
  6.         showLoadingDialog("正在连接 " + mWifiP2pDevice.deviceName);  
  7.         mWifiP2pManager.connect(mChannel, config, new WifiP2pManager.ActionListener() {           
  8.  
  9.             @Override  
  10.             public void onSuccess() {  
  11.                 Log.e(TAG, "connect onSuccess");  
  12.             }         
  13.  
  14.             @Override  
  15.             public void onFailure(int reason) { 
  16.                 showToast("连接失败 " + reason);  
  17.                 dismissLoadingDialog(); 
  18.             }  
  19.         });  
  20.     } 
  21.  

 

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

 

  1. @Override  
  2. public void onConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo) {  
  3.     dismissLoadingDialog();  
  4.     wifiP2pDeviceList.clear();  
  5.     deviceAdapter.notifyDataSetChanged();  
  6.     btn_disconnect.setEnabled(true);  
  7.     btn_chooseFile.setEnabled(true);  
  8.     Log.e(TAG, "onConnectionInfoAvailable");  
  9.     Log.e(TAG, "onConnectionInfoAvailable groupFormed: " + wifiP2pInfo.groupFormed);  
  10.     Log.e(TAG, "onConnectionInfoAvailable isGroupOwner: " + wifiP2pInfo.isGroupOwner);  
  11.     Log.e(TAG, "onConnectionInfoAvailable getHostAddress: " + wifiP2pInfo.groupOwnerAddress.getHostAddress());  
  12.     StringBuilder stringBuilder = new StringBuilder();   
  13.  
  14.     if (mWifiP2pDevice != null) {  
  15.         stringBuilder.append("连接的设备名:");  
  16.         stringBuilder.append(mWifiP2pDevice.deviceName);  
  17.         stringBuilder.append("\n");  
  18.         stringBuilder.append("连接的设备的地址:");  
  19.         stringBuilder.append(mWifiP2pDevice.deviceAddress);  
  20.     } 
  21.  
  22.     stringBuilder.append("\n");  
  23.     stringBuilder.append("是否群主:");  
  24.     stringBuilder.append(wifiP2pInfo.isGroupOwner ? "是群主" : "非群主");  
  25.     stringBuilder.append("\n");  
  26.     stringBuilder.append("群主IP地址:");  
  27.     stringBuilder.append(wifiP2pInfo.groupOwnerAddress.getHostAddress());  
  28.     tv_status.setText(stringBuilder);     
  29.     if (wifiP2pInfo.groupFormed &amp;&amp; !wifiP2pInfo.isGroupOwner) {  
  30.         this.wifiP2pInfo = wifiP2pInfo;  
  31.     }  

 

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

发起选取文件的方法

 

  1. Intent intent = new Intent(Intent.ACTION_GET_CONTENT);  
  2. intent.setType("*/*"); 
  3. intent.addCategory(Intent.CATEGORY_OPENABLE);  
  4. startActivityForResult(intent, 1); 

 

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

 

  1. @Override  
  2. protected void onActivityResult(int requestCode, int resultCode, Intent data) {     
  3.     super.onActivityResult(requestCode, resultCode, data);      
  4.     if (requestCode == 1) {
  5.         if (resultCode == RESULT_OK) { 
  6.             Uri uri = data.getData(); 
  7.              if (uri != null) {  
  8.                 String path = getPath(this, uri);  
  9.                 if (path != null) { 
  10.                     File file = new File(path);  
  11.                     if (file.exists() &amp;&amp; wifiP2pInfo != null) { 
  12.                         FileTransfer fileTransfer = new FileTransfer(file.getPath(), file.length());
  13.                         Log.e(TAG, "待发送的文件:" + fileTransfer);      
  14.                         new WifiClientTask(this, fileTransfer).execute(wifiP2pInfo.groupOwnerAddress.getHostAddress()); 
  15.                     } 
  16.                 }  
  17.             }  
  18.         }  
  19.     }  
  20.                          
  21.  
  22. private String getPath(Context context, Uri uri) {     
  23.     if ("content".equalsIgnoreCase(uri.getScheme())) {  
  24.         Cursor cursor = context.getContentResolver().query(uri, new String[]{"_data"}, nullnullnull);   
  25.         if (cursor != null) {           
  26.             if (cursor.moveToFirst()) { 
  27.                 String data = cursor.getString(cursor.getColumnIndex("_data")); 
  28.                 cursor.close();                 
  29.             return data;  
  30.             }  
  31.         }  
  32.     } else if ("file".equalsIgnoreCase(uri.getScheme())) {    
  33.             return uri.getPath(); 
  34.     }     
  35.     return null 

 

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

 

  1. /**  
  2.  * 作者:叶应是叶  
  3.  * 时间:2018/2/15 8:51  
  4.  * 描述:客户端发送文件  
  5.  */ 
  6.  
  7. public class WifiClientTask extends AsyncTask<String, Integer, Boolean> {   
  8.     private ProgressDialog progressDialog;  
  9.     private FileTransfer fileTransfer;    
  10.     private static final int PORT = 4786;     
  11.     private static final String TAG = "WifiClientTask";       
  12.  
  13.     public WifiClientTask(Context context, FileTransfer fileTransfer) {   
  14.         this.fileTransfer = fileTransfer;  
  15.         progressDialog = new ProgressDialog(context);  
  16.         progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);  
  17.         progressDialog.setCancelable(false);  
  18.         progressDialog.setCanceledOnTouchOutside(false);  
  19.         progressDialog.setTitle("正在发送文件");  
  20.         progressDialog.setMax(100);  
  21.     }     
  22.  
  23.     @Override  
  24.     protected void onPreExecute() { 
  25.         progressDialog.show();  
  26.     }    
  27.  
  28.     @Override 
  29.      protected Boolean doInBackground(String... strings) {  
  30.         fileTransfer.setMd5(Md5Util.getMd5(new File(fileTransfer.getFilePath())));  
  31.         Log.e(TAG, "文件的MD5码值是:" + fileTransfer.getMd5());  
  32.         Socket socket = null 
  33.         OutputStream outputStream = null 
  34.         ObjectOutputStream objectOutputStream = null 
  35.         InputStream inputStream = null;    
  36.         try { 
  37.             socket = new Socket();  
  38.             socket.bind(null);  
  39.             socket.connect((new InetSocketAddress(strings[0], PORT)), 10000);  
  40.             outputStream = socket.getOutputStream();  
  41.             objectOutputStream = new ObjectOutputStream(outputStream);  
  42.             objectOutputStream.writeObject(fileTransfer);  
  43.             inputStream = new FileInputStream(new File(fileTransfer.getFilePath()));   
  44.             long fileSize = fileTransfer.getFileLength();             
  45.             long total = 0;              
  46.             byte buf[] = new byte[512];             
  47.  
  48.             int len;              
  49.             while ((len = inputStream.read(buf)) != -1) {  
  50.                 outputStream.write(buf, 0, len);  
  51.                 total += len;                
  52.                 int progress = (int) ((total * 100) / fileSize); 
  53.                 publishProgress(progress);  
  54.                 Log.e(TAG, "文件发送进度:" + progress);  
  55.             }  
  56.             outputStream.close();  
  57.             objectOutputStream.close();  
  58.             inputStream.close();  
  59.             socket.close();  
  60.             outputStream = null 
  61.             objectOutputStream = null 
  62.             inputStream = null 
  63.             socket = null 
  64.             Log.e(TAG, "文件发送成功");           
  65.  
  66.             return true
  67.  
  68.         } catch (Exception e) {  
  69.             Log.e(TAG, "文件发送异常 Exception: " + e.getMessage());  
  70.         } finally {   
  71.             if (outputStream != null) {  
  72.                 try { 
  73.                     outputStream.close();  
  74.                 } catch (IOException e) { 
  75.                     e.printStackTrace(); 
  76.                 } 
  77.             }              
  78.             if (objectOutputStream != null) { 
  79.                 try { 
  80.  
  81.                     objectOutputStream.close();  
  82.                 } catch (IOException e) {  
  83.                     e.printStackTrace();  
  84.                 }  
  85.             }             
  86.  
  87.             if (inputStream != null) {    
  88.                 try {  
  89.                     inputStream.close();  
  90.                 } catch (IOException e) {  
  91.                     e.printStackTrace();  
  92.                 } 
  93.             }              
  94.             if (socket != null) {   
  95.                 try { 
  96.                     socket.close(); 
  97.                 } catch (Exception e) { 
  98.                     e.printStackTrace(); 
  99.                 }  
  100.             }  
  101.         }          
  102.         return false 
  103.     }      
  104.  
  105.     @Override  
  106.     protected void onProgressUpdate(Integer... values) {  
  107.         progressDialog.setProgress(values[0]);  
  108.     }    
  109.  
  110.     @Override  
  111.     protected void onPostExecute(Boolean aBoolean) {  
  112.         progressDialog.cancel();  
  113.         Log.e(TAG, "onPostExecute: " + aBoolean);  
  114.     }  

 

五、校验文件完整性

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

 

  1. /**  
  2.  * 作者:叶应是叶  
  3.  * 时间:2018/2/14 21:16  
  4.  * 描述:  
  5.  */  
  6. public class Md5Util {  
  7.     public static String getMd5(File file) {  
  8.         InputStream inputStream = null;  
  9.         byte[] buffer = new byte[2048];  
  10.         int numRead; 
  11.         MessageDigest md5;         
  12.         try {  
  13.             inputStream = new FileInputStream(file);  
  14.             md5 = MessageDigest.getInstance("MD5"); 
  15.             while ((numRead = inputStream.read(buffer)) > 0) { 
  16.                 md5.update(buffer, 0, numRead); 
  17.             } 
  18.             inputStream.close();  
  19.             inputStream = null;  
  20.             return md5ToString(md5.digest()); 
  21.         } catch (Exception e) {         
  22.             return null
  23.         } finally {             
  24.             if (inputStream != null) {   
  25.                 try { 
  26.                     inputStream.close(); 
  27.                 } catch (IOException e) { 
  28.                     e.printStackTrace(); 
  29.                 } 
  30.             } 
  31.         } 
  32.     }              
  33.  
  34.     private static String md5ToString(byte[] md5Bytes) {  
  35.         StringBuilder hexValue = new StringBuilder();  
  36.         for (byte b : md5Bytes) {        
  37.             int val = ((int) b) &amp; 0xff;   
  38.             if (val < 16) { 
  39.                 hexValue.append("0"); 
  40.             }  
  41.             hexValue.append(Integer.toHexString(val));  
  42.         }          
  43.         return hexValue.toString();  
  44.     }  

 

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

 

代码地址:https://github.com/leavesC/WifiP2P 

责任编辑:庞桂玉 来源: 安卓巴士Android开发者门户
相关推荐

2010-09-06 09:43:46

TCPUDPAndroid

2020-11-13 08:30:57

Socket

2009-11-11 10:27:11

IP路由器

2011-09-07 14:43:24

2021-06-01 08:00:00

Linux操作系统工具

2019-11-21 09:26:29

物联网无源传输网络

2013-08-09 16:50:59

远程桌面连接软件文件传输

2022-11-21 10:49:29

Nacos配置加密

2009-12-08 15:06:33

WCF传输DataSe

2018-09-05 09:26:21

服务器无密码数据

2015-08-04 15:09:31

2023-07-27 07:35:55

HTTP持久化服务器

2019-03-26 09:11:32

无文件恶意软件

2022-01-10 14:01:36

云计算云计算环境云应用

2022-04-08 08:30:42

大数据网络

2010-12-08 12:34:46

文件传输

2019-08-14 15:08:51

缓存存储数据

2009-09-07 13:38:03

C# HTTP文件传输HTTP文件传输

2009-03-04 06:18:00

FTP服务器双向传输FTP服务器搭建

2019-11-11 15:33:34

高并发缓存数据
点赞
收藏

51CTO技术栈公众号