Android 實現無網路傳輸檔案

leavesC發表於2018-02-15

最近的專案需要實現一個 Android 手機之間無網路傳輸檔案的功能，就發現了 **Wifi P2P（Wifi點對點）**這麼一個功能，最後也實現了通過 Wifi 隔空傳輸檔案 的功能，這裡我也來整理下程式碼，分享給大家。

Wifi P2P 是在 Android 4.0 以及更高版本系統中加入的功能，通過 Wifi P2P 可以在不連線網路的情況下，直接與配對的裝置進行資料交換。相對於藍芽，Wifi P2P 的搜尋速度和傳輸速度更快，傳輸距離更遠

專案主頁：Android 實現無網路傳輸檔案，歡迎 star

實現的效果如下所示：

一般而言，開發步驟分為以下幾點：

在 AndroidManifest 中宣告相關許可權（網路和檔案讀寫許可權）
獲取 WifiP2pManager ，註冊相關廣播監聽Wifi直連的狀態變化
指定某一臺裝置為伺服器（用來接收檔案），建立群組並作為群主存在，在指定埠監聽客戶端的連線請求，等待客戶端發起連線請求以及檔案傳輸請求
客戶端（用來傳送檔案）主動搜尋附近的裝置，加入到伺服器建立的群組，獲取伺服器的IP地址，向其發起檔案傳輸請求
校驗檔案完整性

一、宣告許可權

Wifi P2P 技術並不會訪問網路，但由於會使用到 Java Socket，所以需要申請網路許可權。此外，由於是要實現檔案互傳，所以也需要申請SD卡讀寫許可權。

    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <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 物件作為請求引數

mWifiP2pManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
mChannel = mWifiP2pManager.initialize(this, getMainLooper(), this);
複製程式碼

當收到 WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION 廣播時，可以判斷當前 Wifi P2P是否可用

int state = 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, new WifiP2pManager.PeerListListener() {
    @Override
    public void onPeersAvailable(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, new WifiP2pManager.ConnectionInfoListener() {
        @Override
        public void onConnectionInfoAvailable(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 的初始化，兩個用於在廣播中非同步請求資料，為了簡化操作，此處統一使用一個自定義的回撥函式，方法含義與系統的回撥函式一致

public interface DirectActionListener extends WifiP2pManager.ChannelListener {

    void wifiP2pEnabled(boolean enabled);

    void onConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo);

    void onDisconnection();

    void onSelfDeviceAvailable(WifiP2pDevice wifiP2pDevice);

    void onPeersAvailable(Collection<WifiP2pDevice> wifiP2pDeviceList);

}
複製程式碼

所以，整個廣播接收器使用到的所有程式碼是：

/**
 * 作者：leavesC
 * 時間：2019/2/27 23:58
 * 描述：
 * GitHub：https://github.com/leavesC
 * Blog：https://www.jianshu.com/u/9df45b87cfdf
 */
public class DirectBroadcastReceiver extends BroadcastReceiver {

    private static final String TAG = "DirectBroadcastReceiver";

    private WifiP2pManager mWifiP2pManager;

    private WifiP2pManager.Channel mChannel;

    private DirectActionListener mDirectActionListener;

    public DirectBroadcastReceiver(WifiP2pManager wifiP2pManager, WifiP2pManager.Channel channel, DirectActionListener directActionListener) {
        mWifiP2pManager = wifiP2pManager;
        mChannel = channel;
        mDirectActionListener = directActionListener;
    }

    public static IntentFilter getIntentFilter() {
        IntentFilter intentFilter = new IntentFilter();
        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);
        return intentFilter;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        Log.e(TAG, "接收到廣播： " + intent.getAction());
        if (!TextUtils.isEmpty(intent.getAction())) {
            switch (intent.getAction()) {
                // 用於指示 Wifi P2P 是否可用
                case WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION: {
                    int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
                    if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
                        mDirectActionListener.wifiP2pEnabled(true);
                    } else {
                        mDirectActionListener.wifiP2pEnabled(false);
                        List<WifiP2pDevice> wifiP2pDeviceList = new ArrayList<>();
                        mDirectActionListener.onPeersAvailable(wifiP2pDeviceList);
                    }
                    break;
                }
                // 對等節點列表發生了變化
                case WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION: {
                    mWifiP2pManager.requestPeers(mChannel, new WifiP2pManager.PeerListListener() {
                        @Override
                        public void onPeersAvailable(WifiP2pDeviceList peers) {
                            mDirectActionListener.onPeersAvailable(peers.getDeviceList());
                        }
                    });
                    break;
                }
                // Wifi P2P 的連線狀態發生了改變
                case WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION: {
                    NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);
                    if (networkInfo.isConnected()) {
                        mWifiP2pManager.requestConnectionInfo(mChannel, new WifiP2pManager.ConnectionInfoListener() {
                            @Override
                            public void onConnectionInfoAvailable(WifiP2pInfo info) {
                                mDirectActionListener.onConnectionInfoAvailable(info);
                            }
                        });
                        Log.e(TAG, "已連線p2p裝置");
                    } else {
                        mDirectActionListener.onDisconnection();
                        Log.e(TAG, "與p2p裝置已斷開連線");
                    }
                    break;
                }
                //本裝置的裝置資訊發生了變化
                case WifiP2pManager.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, new WifiP2pManager.ActionListener() {
    @Override
    public void onSuccess() {
        Log.e(TAG, "createGroup onSuccess");
        dismissLoadingDialog();
        showToast("onSuccess");
    }

     @Override
     public void onFailure(int reason) {
        Log.e(TAG, "createGroup onFailure: " + reason);
        dismissLoadingDialog();
        showToast("onFailure");
    }
});
複製程式碼

此處，使用 IntentService 在後臺監聽客戶端的 Socket 連線請求，並通過輸入輸出流來傳輸檔案。此處的程式碼比較簡單，就只是在指定埠一直堵塞監聽客戶端的連線請求，獲取待傳輸的檔案資訊模型 FileTransfer ，之後就進行實際的資料傳輸

   @Override
    protected void onHandleIntent(Intent intent) {
        clean();
        File file = null;
        try {
            serverSocket = new ServerSocket();
            serverSocket.setReuseAddress(true);
            serverSocket.bind(new InetSocketAddress(PORT));
            Socket client = serverSocket.accept();
            Log.e(TAG, "客戶端IP地址 : " + client.getInetAddress().getHostAddress());
            inputStream = client.getInputStream();
            objectInputStream = new ObjectInputStream(inputStream);
            FileTransfer fileTransfer = (FileTransfer) objectInputStream.readObject();
            Log.e(TAG, "待接收的檔案: " + fileTransfer);
            String name = new File(fileTransfer.getFilePath()).getName();
            //將檔案儲存至指定位置
            file = new File(Environment.getExternalStorageDirectory() + "/" + name);
            fileOutputStream = new FileOutputStream(file);
            byte buf[] = new byte[512];
            int len;
            long total = 0;
            int progress;
            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(new Intent(this, WifiServerService.class));
        }
    }
複製程式碼

因為客戶端可能會多次發起連線請求，所以當此處檔案傳輸完成後（不管成功或失敗），都需要重新 startService ，讓服務再次堵塞等待客戶端的連線請求

FileTransfer 包含三個欄位，MD5碼值用於校驗檔案的完整性，fileLength 是為了用於計算檔案的傳輸進度

public class FileTransfer implements Serializable {

    //檔案路徑
    private String filePath;

    //檔案大小
    private long fileLength;

    //MD5碼
    private String md5;

    ···
    
}
複製程式碼

為了將檔案傳輸進度釋出到外部介面，所以除了需要啟動Service外，介面還需要繫結Service，此處就需要用到一個更新檔案傳輸狀態的介面

    public interface OnProgressChangListener {

        //當傳輸進度發生變化時
        void onProgressChanged(FileTransfer fileTransfer, int progress);

        //當傳輸結束時
        void onTransferFinished(File file);

    }
複製程式碼

因此，需要將 progressChangListener 作為引數傳給 WifiServerService ，並在進度變化時更新進度對話方塊

 private WifiServerService.OnProgressChangListener progressChangListener = new WifiServerService.OnProgressChangListener() {
        @Override
        public void onProgressChanged(final FileTransfer fileTransfer, final int progress) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    progressDialog.setMessage("檔名： " + new File(fileTransfer.getFilePath()).getName());
                    progressDialog.setProgress(progress);
                    progressDialog.show();
                }
            });
        }

        @Override
        public void onTransferFinished(final File file) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    progressDialog.cancel();
                    if (file != null && file.exists()) {
                        openFile(file.getPath());
                    }
                }
            });
        }
    };
複製程式碼

四、客戶端加入群組併發起檔案傳輸請求

檔案傳送介面 SendFileActivity 需要實現 DirectActionListener 介面首先，需要先註冊P2P廣播，以便獲取周邊裝置資訊以及連線狀態

    @Override
    protected void onCreate(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 = new DirectBroadcastReceiver(mWifiP2pManager, mChannel, this);
        registerReceiver(broadcastReceiver, DirectBroadcastReceiver.getIntentFilter());
    }
複製程式碼

通過 discoverPeers 方法搜尋周邊裝置，回撥函式用於通知方法是否呼叫成功

mWifiP2pManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() {
    @Override
    public void onSuccess() {
        showToast("Success");
    }

    @Override
    public void onFailure(int reasonCode) {
        showToast("Failure");
        loadingDialog.cancel();
     }
});
複製程式碼

當搜尋結束後，系統就會觸發 WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION 廣播，此時就可以呼叫 requestPeers 方法獲取裝置列表資訊，此處用 RecyclerView 展示列表，在 onPeersAvailable 方法重新整理列表

mWifiP2pManager.requestPeers(mChannel, new WifiP2pManager.PeerListListener() {
    @Override
    public void onPeersAvailable(WifiP2pDeviceList peers) {
        mDirectActionListener.onPeersAvailable(peers.getDeviceList());
    }
});
複製程式碼

    @Override
    public void onPeersAvailable(Collection<WifiP2pDevice> wifiP2pDeviceList) {
        Log.e(TAG, "onPeersAvailable :" + wifiP2pDeviceList.size());
        this.wifiP2pDeviceList.clear();
        this.wifiP2pDeviceList.addAll(wifiP2pDeviceList);
        deviceAdapter.notifyDataSetChanged();
        loadingDialog.cancel();
    }
複製程式碼

之後，通過點選事件選中群主（伺服器端）裝置，通過 connect 方法請求與之進行連線

private void connect() {
    WifiP2pConfig config = new WifiP2pConfig();
    if (config.deviceAddress != null && mWifiP2pDevice != null) {
        config.deviceAddress = mWifiP2pDevice.deviceAddress;
        config.wps.setup = WpsInfo.PBC;
        showLoadingDialog("正在連線 " + mWifiP2pDevice.deviceName);
        mWifiP2pManager.connect(mChannel, config, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                Log.e(TAG, "connect onSuccess");
            }

            @Override
            public void onFailure(int reason) {
                showToast("連線失敗 " + reason);
                dismissLoadingDialog();
            }
        });
    }
}
複製程式碼

此處依然無法通過函式函式來判斷連線結果，需要依靠系統發出的 WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION 方法來獲取到連線結果，在此處可以通過 requestConnectionInfo 獲取到組連線資訊，資訊最後通過 onConnectionInfoAvailable 方法傳遞出來，在此可以判斷當前裝置是否為群主，獲取群組IP地址

  @Override
public void onConnectionInfoAvailable(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 = new StringBuilder();
    if (mWifiP2pDevice != null) {
        stringBuilder.append("連線的裝置名：");
        stringBuilder.append(mWifiP2pDevice.deviceName);
        stringBuilder.append("\n");
        stringBuilder.append("連線的裝置的地址：");
        stringBuilder.append(mWifiP2pDevice.deviceAddress);
    }
    stringBuilder.append("\n");
    stringBuilder.append("是否群主：");
    stringBuilder.append(wifiP2pInfo.isGroupOwner ? "是群主" : "非群主");
    stringBuilder.append("\n");
    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 = new Intent(Intent.ACTION_GET_CONTENT);
intent.setType("*/*");
intent.addCategory(Intent.CATEGORY_OPENABLE);
startActivityForResult(intent, 1);
複製程式碼

獲取選取的檔案的實際路徑

@Override
protected void onActivityResult(int requestCode, int resultCode, 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 = new File(path);
                    if (file.exists() && wifiP2pInfo != null) {
                        FileTransfer fileTransfer = new FileTransfer(file.getPath(), file.length());
                        Log.e(TAG, "待傳送的檔案：" + fileTransfer);
                        new WifiClientTask(this, fileTransfer).execute(wifiP2pInfo.groupOwnerAddress.getHostAddress());
                    }
                }
            }
        }
    }
}

private String getPath(Context context, Uri uri) {
    if ("content".equalsIgnoreCase(uri.getScheme())) {
        Cursor cursor = context.getContentResolver().query(uri, new String[]{"_data"}, null, null, null);
        if (cursor != null) {
           if (cursor.moveToFirst()) {
                String data = cursor.getString(cursor.getColumnIndex("_data"));
                cursor.close();
                return data;
            }
        }
    } else if ("file".equalsIgnoreCase(uri.getScheme())) {
        return uri.getPath();
    }
    return null;
}
複製程式碼

檔案的傳送操作放到 AsyncTask 中處理，將伺服器端的IP地址作為引數傳進來，在正式傳送檔案前，先傳送包含檔案資訊（檔名，檔案大小，檔案MD5碼）的資訊模型 FileTransfer ，並在傳送檔案的過程中同時更新進度

/**
 * 作者：leavesC
 * 時間：2019/2/27 23:56
 * 描述：客戶端傳送檔案
 * GitHub：https://github.com/leavesC
 * Blog：https://www.jianshu.com/u/9df45b87cfdf
 */
public class WifiClientTask extends AsyncTask<String, Integer, Boolean> {

    private ProgressDialog progressDialog;

    private FileTransfer fileTransfer;

    private static final int PORT = 4786;

    private static final String TAG = "WifiClientTask";

    public WifiClientTask(Context context, FileTransfer fileTransfer) {
        this.fileTransfer = fileTransfer;
        progressDialog = new ProgressDialog(context);
        progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        progressDialog.setCancelable(false);
        progressDialog.setCanceledOnTouchOutside(false);
        progressDialog.setTitle("正在傳送檔案");
        progressDialog.setMax(100);
    }

    @Override
    protected void onPreExecute() {
        progressDialog.show();
    }

    @Override
    protected Boolean doInBackground(String... strings) {
        fileTransfer.setMd5(Md5Util.getMd5(new File(fileTransfer.getFilePath())));
        Log.e(TAG, "檔案的MD5碼值是：" + fileTransfer.getMd5());
        Socket socket = null;
        OutputStream outputStream = null;
        ObjectOutputStream objectOutputStream = null;
        InputStream inputStream = null;
        try {
            socket = new Socket();
            socket.bind(null);
            socket.connect((new InetSocketAddress(strings[0], PORT)), 10000);
            outputStream = socket.getOutputStream();
            objectOutputStream = new ObjectOutputStream(outputStream);
            objectOutputStream.writeObject(fileTransfer);
            inputStream = new FileInputStream(new File(fileTransfer.getFilePath()));
            long fileSize = fileTransfer.getFileLength();
            long total = 0;
            byte buf[] = new byte[512];
            int len;
            while ((len = inputStream.read(buf)) != -1) {
                outputStream.write(buf, 0, len);
                total += len;
                int progress = (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, "檔案傳送成功");
            return true;
        } 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();
                }
            }
        }
        return false;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        progressDialog.setProgress(values[0]);
    }

    @Override
    protected void onPostExecute(Boolean aBoolean) {
        progressDialog.cancel();
        Log.e(TAG, "onPostExecute: " + aBoolean);
    }

}
複製程式碼

五、校驗檔案完整性

傳輸檔案的完整性主要是通過計算檔案的MD5碼值來保證了，在傳送檔案前，即在 WifiClientTask 的 doInBackground 方法中進行計算，將MD5碼值賦給 FileTransfer 模型，通過如下方法計算得到

/**
 * 作者：leavesC
 * 時間：2019/2/27 23:57
 * 描述：
 * GitHub：https://github.com/leavesC
 * Blog：https://www.jianshu.com/u/9df45b87cfdf
 */
public class Md5Util {

    public static String getMd5(File file) {
        InputStream inputStream = null;
        byte[] buffer = new byte[2048];
        int numRead;
        MessageDigest md5;
        try {
            inputStream = new FileInputStream(file);
            md5 = MessageDigest.getInstance("MD5");
            while ((numRead = inputStream.read(buffer)) > 0) {
                md5.update(buffer, 0, numRead);
            }
            inputStream.close();
            inputStream = null;
            return md5ToString(md5.digest());
        } catch (Exception e) {
            return null;
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static String md5ToString(byte[] md5Bytes) {
        StringBuilder hexValue = new StringBuilder();
        for (byte b : md5Bytes) {
            int val = ((int) b) & 0xff;
            if (val < 16) {
                hexValue.append("0");
            }
            hexValue.append(Integer.toHexString(val));
        }
        return hexValue.toString();
    }

}
複製程式碼

因為客戶端會將 FileTransfer 傳給伺服器端，所以伺服器端在檔案傳輸結束後，可以重新計算檔案的 MD5碼值，進行對比以判斷檔案是否完整

專案主頁：Android 實現無網路傳輸檔案，歡迎 star

網路隔離下實現的檔案傳輸，現有的方式真的安全嗎？
2023-09-22
網際網路大檔案的傳輸方式
2019-06-25
java tcp網路通訊傳輸檔案
2017-08-31
JavaTCP
藍芽網路檔案傳輸過程
2014-03-27
藍芽
實現linux和windows檔案傳輸
2012-12-20
LinuxWindows
如何實現檔案高速傳輸，推薦鐳速高速檔案傳輸解決方案
2023-02-23
資料檔案在網路“裸奔”，如何在網際網路中進行檔案傳輸？
2020-09-27
網路通訊3：HTTP實現文字傳輸
2020-05-22
HTTP
基於Service Worker實現WebRTC區域網大檔案傳輸能力
2024-09-09
Web
xftp實現linux伺服器傳輸檔案
2024-07-07
FTPLinux伺服器
網際網路使用者之間如何傳輸大檔案
2023-05-16
為實現跨境檔案高速傳輸，鐳速傳輸都用了哪些技術？
2020-09-27
為實現跨境檔案高速傳輸，鐳速傳輸都用了哪些技術
2023-02-14
安卓檔案傳輸工具Android File Transfer
2021-11-29
安卓Android
極路由+NETGEAR 傳輸無線網路
2017-11-12
路由
跨國大檔案傳輸需要哪些方面？怎麼實現資料快速傳輸？
2024-06-11
針對IT網際網路行業的檔案傳輸解決方案
2020-09-14
行業
簡單實現TCP下的大檔案高效傳輸
2013-06-19
TCP
java實現TCP與UDP混合傳輸檔案總結
2015-04-07
JavaTCPUDP
用Socket實現點對點的檔案傳輸 (轉)
2007-08-15
如何實現檔案傳輸系統的多儲存
2024-03-28
什麼是極速檔案傳輸，極速檔案傳輸如何進行大檔案傳輸
2023-02-13
使用java的MultipartFile實現layui官網檔案上傳實現全部示例，java檔案上傳
2019-07-13
JavaUI
expect+scp傳輸檔案發現檔案丟失
2018-01-10
Android File Transfer for mac(安卓檔案傳輸工具)
2023-03-13
AndroidMac安卓
webservice傳輸檔案
2017-12-19
Web
scp 傳輸檔案
2024-10-14
sftp 傳輸檔案
2024-09-14
FTP
無外掛實現大檔案分片上傳，斷點續傳
2017-08-19
斷點
快速傳輸大檔案，怎麼透過網路傳大檔案給對方（1G以上）
2022-12-16
資料無界：大型企業如何實現多區域檔案安全傳輸的無縫體驗？
2024-08-30
java tcp 網路通訊--使用多執行緒傳輸檔案
2017-09-01
JavaTCP執行緒
大檔案如何傳輸，大檔案的傳輸方式有哪些？
2019-05-28
Android 用Retrofit 2實現多檔案上傳實戰
2017-04-03
Android
win10電腦怎麼互傳大檔案無網路互傳大檔案的方法
2021-01-16
Win10
Android如何實現TCP和UDP傳輸
2015-03-16
AndroidTCPUDP
Android okHttp網路請求之檔案上傳下載
2016-05-26
AndroidHTTP
從零手寫實現 nginx-07-大檔案傳輸分塊傳輸（chunked transfer）/ 分頁傳輸（paging）
2024-06-06
Nginx

Android 實現無網路傳輸檔案

一、宣告許可權

二、註冊廣播

三、伺服器端建立群組

四、客戶端加入群組併發起檔案傳輸請求

五、校驗檔案完整性

專案主頁：Android 實現無網路傳輸檔案 ，歡迎 star

相關文章

專案主頁：Android 實現無網路傳輸檔案，歡迎 star