android高级架构工程师前景及薪资

如果你觉得Java 7是一个过期的语言，并决定找一个更现代的语言代替。恭喜你！就如你知道的，虽然Java 8已经发布了，它包含了很多我们期待的像现代语言中那样的改善，但是我们Android开发者还是被迫在使用Java 7.这是因为法律的问题。但是就算没有这个限制，并且新的Android设备从今天开始使用新的能理解Java8的VM，在当前的设备过期、几乎没有人使用它们之前我们也不能使用Java 8，所以恐怕我们不会很快等到这一天的到来。

但是并不是没有补救的方法。多亏使用了JVM，我们可以使用任何语言去编写Android应用，只要它能够编译成JVM能够认识的字节码就可以了。

正如你所想，有很多选择，比如Groovy，Scala，Clojure，当然还有Kotlin。通过实践，只有其中一些能够被考虑来作为替代品。

上述的每一种语言都有它的利弊，如果你还没有真正确定你该使用那种语言，我建议你可以去尝试一下它们。

1. 什么是Kotlin？

Kotlin，如前面所说，它是JetBrains开发的基于JVM的语言。JetBrains因为创造了一个强大的Java开发IDE被大家所熟知。Android Studio，官方的Android IDE，就是基于Intellij，作为一个该平台的插件。

Kotlin是使用Java开发者的思维被创建的，Intellij作为它主要的开发IDE。对于Android开发者，有两个有趣的特点：

对Java开发者来说，Kotlin是非常直觉化的，并且非常容易学习。语言的大部分内容都是与我们知道的非常相似，不同的地方，它的基础概念也能迅速地掌握它。

它与我们日常生活使用的IDE无需配置就能完全整合。Android Studio能够非常完美地理解、编译运行Kotlin代码。而且对这门语言的支持来正是自于开发了这个IDE的公司本身，所以我们Android开发者是一等公民。

但是这仅仅是开发语言和开发工具之间的整合。相比Java 7的优势到底是什么呢？

它更加易表现：这是它最重要的优点之一。你可以编写少得多的代码。

它更加安全：Kotlin是空安全的，也就是说在我们编译时期就处理了各种null的情况，避免了执行时异常。如果一个对象可以是null，则我们需要明确地指定它，然后在使用它之前检查它是否是null。你可以节约很多调试空指针异常的时间，解决掉null引发的bug。

它是函数式的：Kotlin是基于面向对象的语言。但是就如其他很多现代的语言那样，它使用了很多函数式编程的概念，比如，使用lambda表达式来更方便地解决问题。其中一个很棒的特性就是Collections的处理方式。

它可以扩展函数：这意味着我们可以扩展类的更多的特性，甚至我们没有权限去访问这个类中的代码。

它是高度互操作性的：你可以继续使用所有的你用Java写的代码和库，因为两个语言之间的互操作性是完美的。甚至可以在一个项目中使用Kotlin和Java两种语言混合编程。

2. 我们通过Kotlin得到什么

不深入Kotlin语言（我们会在下一章再去学习），这里有一些Java中没有的有趣的特性：

易表现

通过Kotlin，可以更容易地避免模版代码因为大部分的典型情况都在语言中默认覆盖实现了。举个例子，在Java中，如果我们要典型的数据类，我们需要去编写（至少生成）这些代码：

publicclassArtist{

privatelongid;

privateString name;

privateString url;

privateString mbid;

publiclonggetId(){

returnid;

}

publicvoidsetId(longid){

this.id = id;

}

publicString getName(){

returnname;

}

publicvoidsetName(String name){

this.name = name;

}

publicString getUrl(){

returnurl;

}

publicvoidsetUrl(String url){

this.url = url;

}

publicString getMbid(){

returnmbid;

}

publicvoidsetMbid(String mbid){

this.mbid = mbid;

}

@OverridepublicString toString(){

return"Artist{"+

"id="+ id +

", name='"+ name + '''+

", url='"+ url + '''+

", mbid='"+ mbid + '''+

'}';

}

}

使用Kotlin，我们只需要通过数据类：

data class Artist(

varid: Long,

varname: String,

varurl: String,

varmbid: String)

这个数据类，它会自动生成所有属性和它们的访问器，以及一些有用的方法，比如，toString()

空安全

当我们使用Java开发的时候，我们的代码大多是防御性的。如果我们不想遇到NullPointerException，我们就需要在使用它之前不停地去判断它是否为null。Kotlin，如很多现代的语言，是空安全的，因为我们需要通过一个安全调用操作符（写做?）来明确地指定一个对象是否能为空。

我们可以像这样去写：

// 这里不能通过编译. Artist 不能是null

varnotNullArtist: Artist = null

// Artist 可以是 null

varartist: Artist? = null

// 无法编译, artist可能是null，我们需要进行处理

artist. print()

// 只要在artist != null时才会打印

artist?. print()

// 智能转换. 如果我们在之前进行了空检查，则不需要使用安全调用操作符调用

if(artist != null) {

artist. print()

}

// 只有在确保artist不是null的情况下才能这么调用，否则它会抛出异常

artist!!. print()

// 使用Elvis操作符来给定一个在是null的情况下的替代值

val name = artist?.name ?: "empty"

扩展方法

我们可以给任何类添加函数。它比那些我们项目中典型的工具类更加具有可读性。举个例子，我们可以给fragment增加一个显示toast的函数：

fun Fragment.toast(message: CharSequence, duration: Int = Toast.LENGTH_SHORT) {

Toast.makeText(getActivity(), message, duration).show()

}

我们现在可以这么做：

fragment.toast( "Hello world!")

函数式支持（Lambdas）

每次我们去声明一个点击所触发的事件，可以只需要定义我们需要做些什么，而不是不得不去实现一个内部类？我们确实可以这么做，这个（或者其它更多我们感兴趣的事件）我们需要感谢lambda：

view.setOnClickListener { toast( "Hello world!") }

这里只是挑选了很小一部分Kotlin可以简化我们代码的事情。现在你已经知道这门语言的一些有趣的特性了，你可以考虑它是否是适合你的。如果你选择继续，我们将在下一章开始我们的实践之旅。

距离活动开始还有一天，重庆的开发者们赶快报名行动起来吧！

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

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

实现的效果如下所示：

一般而言，开发步骤分为以下几点：

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

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

<uses-permissionandroid:name="android.permission.ACCESS_WIFI_STATE"/><uses-permissionandroid:name="android.permission.CHANGE_WIFI_STATE"/><uses-permissionandroid:name="android.permission.CHANGE_NETWORK_STATE"/><uses-permissionandroid:name="android.permission.INTERNET"/><uses-permissionandroid:name="android.permission.ACCESS_NETWORK_STATE"/><uses-permissionandroid:name="android.permission.WRITE_EXTERNAL_STORAGE"/><uses-permissionandroid: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是否可用

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() { @OverridepublicvoidonPeersAvailable(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() { @OverridepublicvoidonConnectionInfoAvailable(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<WifiP2pDevice> 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; }

@OverridepublicvoidonReceive(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<WifiP2pDevice> wifiP2pDeviceList = newArrayList<>(); mDirectActionListener.onPeersAvailable(wifiP2pDeviceList); }

break; }

// 对等节点列表发生了变化caseWifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION: { mWifiP2pManager.requestPeers(mChannel, newWifiP2pManager.PeerListListener() {

@OverridepublicvoidonPeersAvailable(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() {

@OverridepublicvoidonConnectionInfoAvailable(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() {

@OverridepublicvoidonSuccess(){ Log.e(TAG, "createGroup onSuccess"); dismissLoadingDialog(); showToast( "onSuccess"); }

@OverridepublicvoidonFailure(intreason){ Log.e(TAG, "createGroup onFailure: "+ reason); dismissLoadingDialog(); showToast( "onFailure"); }});

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

@OverrideprotectedvoidonHandleIntent(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() {

@OverridepublicvoidonProgressChanged(finalFileTransfer fileTransfer, finalintprogress){ runOnUiThread( newRunnable() {

@Overridepublicvoidrun(){ progressDialog.setMessage( "文件名： "+ newFile(fileTransfer.getFilePath()).getName()); progressDialog.setProgress(progress); progressDialog.show(); } }); }

@OverridepublicvoidonTransferFinished(finalFile file){ runOnUiThread( newRunnable() {

@Overridepublicvoidrun(){ progressDialog.cancel();

if(file != null&& file.exists()) { openFile(file.getPath()); } } }); } }; 四、客户端加入群组并发起文件传输请求

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

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

@OverrideprotectedvoidonCreate(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() { @OverridepublicvoidonSuccess(){ showToast( "Success"); }

@OverridepublicvoidonFailure(intreasonCode){ showToast( "Failure"); loadingDialog.cancel(); }});

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

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

@OverridepublicvoidonPeersAvailable(WifiP2pDeviceList peers){ mDirectActionListener.onPeersAvailable(peers.getDeviceList()); }}); @OverridepublicvoidonPeersAvailable(Collection<WifiP2pDevice> 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() {

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

@OverridepublicvoidonFailure(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( "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 = 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<String, Integer, Boolean> {

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); }

@OverrideprotectedvoidonPreExecute(){ progressDialog.show(); }

@OverrideprotectedBoolean 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

大家都在看

距离活动开始还有两天，深圳的开发者们赶快报名行动起来吧！

在我的上一篇文章：Android 如何实现无网络传输文件，我介绍了通过 Wifi Direct（Wifi 直连）实现 Android 设备之间进行文件传输的方法，可以在无移动网络的情况下实现点对点的文件传输

本来觉得这样也就够了，可在要应用到实际项目的时候，又考虑到用户的设备系统版本可能并不都符合要求（Wifi Direct 是 Android 4.0 后支持的功能，话说低于 4.4 版本的手机应该都很少了吧？），而且我也不确定 IOS 系统是否支持 Wifi Direct，所以为了让文件传输逻辑可以应用到更多的设备上，就又实现了通过 Wifi热点进行文件传输的功能

相比于通过 Wiif Direct 进行文件传输，通过 Wifi 热点进行设备配对更加方便，逻辑也更为直接，传输一个1G左右的压缩包用了5分钟左右的时间，平均传输速率有 3.5 M/S左右。此外，相对于上个版本，新版本除了提供传输进度外，还提供了传输速率、预估完成时间、文件传输前后的MD5码等数据

实现的效果如下所示：

开启Ap热点接收文件

连接Wiif热点发送文件

文件传输完成后校验文件完整性

开发步骤分为以下几点：

在 AndroidManifest 中声明相关权限（网络和文件读写权限） 文件接收端开启Ap热点，作为服务器端建立Socket，在指定端口等待客户端的连接 文件发送端连接到Wifi热点，作为客户端主动连接到服务器端 文件发送端将待发送的文件信息模型（包括文件路径，文件大小和文件MD5码等信息）通过Socket发送给文件接收端 文件发送端发起实际的文件传输请求，接收端和发送端根据已接收到或已发送的的文件字节数，计算文件传输进度、文件传输速率和预估完成时间等数据 文件传输结束后，对比文件信息模型携带来的MD5码值与本地文件重新计算生成的MD5码是否相等，以此校验文件完整性 一、声明权限

本应用并不会消耗移动数据，但由于要使用到 Wifi 以及 Java Socket，所以需要申请网络相关的权限。此外，由于是要实现文件互传，所以也需要申请SD卡读写权限。

<uses-permissionandroid:name="android.permission.ACCESS_WIFI_STATE"/>

<uses-permissionandroid:name="android.permission.CHANGE_WIFI_STATE"/>

<uses-permissionandroid:name="android.permission.CHANGE_NETWORK_STATE"/>

<uses-permissionandroid:name="android.permission.INTERNET"/>

<uses-permissionandroid:name="android.permission.ACCESS_NETWORK_STATE"/>

<uses-permissionandroid:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

<uses-permissionandroid:name="android.permission.READ_EXTERNAL_STORAGE"/>

二、文件接收端

文件接收端作为服务器存在，需要主动开启Ap热点供文件发送端连接，此处开启Ap热点的方法是通过反射来实现，这种方法虽然方便，但并不保证在所有系统上都能成功，比如我在 7.1.2 版本系统上就开启不了，最好还是引导用户去主动开启

/**

* 开启便携热点

*

* @paramcontext 上下文

* @paramssid SSID

* @parampassword 密码

* @return是否成功

*/

publicstaticbooleanopenAp(Context context, String ssid, String password){

WifiManager wifimanager = (WifiManager) context.getApplicationContext().getSystemService(WIFI_SERVICE);

if(wifimanager == null) {

returnfalse;

}

if(wifimanager.isWifiEnabled()) {

wifimanager.setWifiEnabled( false);

}

try{

Method method = wifimanager.getClass().getMethod( "setWifiApEnabled", WifiConfiguration.class, boolean.class);

method.invoke(wifimanager, null, false);

method = wifimanager.getClass().getMethod( "setWifiApEnabled", WifiConfiguration.class, boolean.class);

method.invoke(wifimanager, createApConfiguration(ssid, password), true);

returntrue;

} catch(Exception e) {

e.printStackTrace();

}

returnfalse;

}

/**

* 关闭便携热点

*

* @paramcontext 上下文

*/

publicstaticvoidcloseAp(Context context){

WifiManager wifimanager = (WifiManager) context.getApplicationContext().getSystemService(WIFI_SERVICE);

try{

Method method = wifimanager.getClass().getMethod( "setWifiApEnabled", WifiConfiguration.class, boolean.class);

method.invoke(wifimanager, null, false);

} catch(Exception e) {

e.printStackTrace();

}

}

此处需要先定义一个文件信息模型 FileTransfer ，FileTransfer 包含三个字段，MD5码值用于校验文件的完整性，fileLength 是为了用于计算文件的传输进度和传输速率

publicclassFileTransferimplementsSerializable{

//文件路径

privateString filePath;

//文件大小

privatelongfileLength;

//MD5码

privateString md5;

···

}

Ap热点开启成功后，就可以启动一个服务在后台等待文件发送端来主动连接了，这里使用 IntentService 在后台监听客户端的Socket连接请求，并通过输入输出流来传输文件。此处的代码比较简单，就只是在指定端口一直堵塞监听客户端的连接请求，获取待传输的文件信息模型 FileTransfer ，之后就进行实际的数据传输

文件传输速率是每一秒计算一次，根据这段时间内接收的字节数与消耗的时间做除法，从而得到传输速率，再通过将剩余的未传输字节数与传输速率做除法，从而得到预估的剩余传输时间

@Override

protectedvoidonHandleIntent(Intent intent){

clean();

File file = null;

try{

serverSocket = newServerSocket();

serverSocket.setReuseAddress( true);

serverSocket.bind( newInetSocketAddress(Constants.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;

//文件大小

longfileSize = fileTransfer.getFileLength();

//当前的传输进度

intprogress;

//总的已接收字节数

longtotal = 0;

//缓存-当次更新进度时的时间

longtempTime = System.currentTimeMillis();

//缓存-当次更新进度时已接收的总字节数

longtempTotal = 0;

//传输速率（Kb/s）

doublespeed = 0;

//预估的剩余完成时间（秒）

longremainingTime;

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

fileOutputStream.write(buf, 0, len);

total += len;

longtime = System.currentTimeMillis() - tempTime;

//每一秒更新一次传输速率和传输进度

if(time > 1000) {

//当前的传输进度

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

Logger.e(TAG, "---------------------------");

Logger.e(TAG, "传输进度: "+ progress);

Logger.e(TAG, "时间变化："+ time / 1000.0);

Logger.e(TAG, "字节变化："+ (total - tempTotal));

//计算传输速率，字节转Kb，毫秒转秒 17:45:07

speed = ((total - tempTotal) / 1024.0/ (time / 1000.0));

//预估的剩余完成时间

remainingTime = ( long) ((fileSize - total) / 1024.0/ speed);

Logger.e(TAG, "传输速率："+ speed);

Logger.e(TAG, "预估的剩余完成时间："+ remainingTime);

//缓存-当次更新进度时已传输的总字节数

tempTotal = total;

//缓存-当次更新进度时的时间

tempTime = System.currentTimeMillis();

if(progressChangListener != null) {

progressChangListener.onProgressChanged(fileTransfer, progress, speed, remainingTime);

}

}

}

progressChangListener.onProgressChanged(fileTransfer, 100, 0, 0);

serverSocket.close();

inputStream.close();

objectInputStream.close();

fileOutputStream.close();

serverSocket = null;

inputStream = null;

objectInputStream = null;

fileOutputStream = null;

Log.e(TAG, "文件接收成功");

} catch(Exception e) {

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

} finally{

clean();

if(progressChangListener != null) {

FileTransfer fileTransfer = newFileTransfer();

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

String md5 = Md5Util.getMd5(file);

fileTransfer.setFilePath(file.getPath());

fileTransfer.setFileLength(file.length());

fileTransfer.setMd5(md5);

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

}

progressChangListener.onTransferFinished(fileTransfer);

}

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

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

}

}

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

为了让界面能够实时获取到文件的传输状态，所以此处除了需要启动Service外，界面还需要绑定Service，所以需要用到一个更新文件传输状态的接口

publicinterfaceOnProgressChangListener{

/**

* 当传输进度发生变化时回调

*

* @paramfileTransfer 文件发送方传来的文件模型

* @paramprogress 文件传输进度

* @paramspeed 文件传输速率

* @paramremainingTime 预估的剩余完成时间

*/

voidonProgressChanged(FileTransfer fileTransfer, intprogress, doublespeed, longremainingTime);

//当传输结束时

voidonTransferFinished(FileTransfer fileTransfer);

}

在界面层刷新UI

privateFileReceiverService.OnProgressChangListener progressChangListener = newFileReceiverService.OnProgressChangListener() {

privateFileTransfer originFileTransfer;

@Override

publicvoidonProgressChanged(finalFileTransfer fileTransfer, finalintprogress, finaldoublespeed, finallongremainingTime){

this.originFileTransfer = fileTransfer;

runOnUiThread( newRunnable() {

@Override

publicvoidrun(){

progressDialog.setTitle( "正在接收的文件： "+ newFile(fileTransfer.getFilePath()).getName());

progressDialog.setMessage( "原始文件的MD5码是："+ fileTransfer.getMd5()

+ "n"+ "传输速率："+ ( int) speed + " Kb/s"

+ "n"+ "预估的剩余完成时间："+ remainingTime + " 秒");

progressDialog.setProgress(progress);

progressDialog.setCancelable( false);

progressDialog.show();

}

});

}

@Override

publicvoidonTransferFinished(finalFileTransfer fileTransfer){

runOnUiThread( newRunnable() {

@Override

publicvoidrun(){

progressDialog.setTitle( "传输结束");

progressDialog.setMessage( "原始文件的MD5码是："+ originFileTransfer.getMd5()

+ "n"+ "本地文件的MD5码是："+ fileTransfer.getMd5()

+ "n"+ "文件位置："+ fileTransfer.getFilePath());

progressDialog.setCancelable( true);

}

});

}

};

三、文件发送端

文件发送端作为客户端存在，需要主动连接文件接收端开启的Wifi热点

/**

* 连接指定Wifi

*

* @paramcontext 上下文

* @paramssid SSID

* @parampassword 密码

* @return是否连接成功

*/

publicstaticbooleanconnectWifi(Context context, String ssid, String password){

String connectedSsid = getConnectedSSID(context);

if(!TextUtils.isEmpty(connectedSsid) && connectedSsid.equals(ssid)) {

returntrue;

}

openWifi(context);

WifiConfiguration wifiConfiguration = isWifiExist(context, ssid);

if(wifiConfiguration == null) {

wifiConfiguration = createWifiConfiguration(ssid, password);

}

WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);

if(wifiManager == null) {

returnfalse;

}

intnetworkId = wifiManager.addNetwork(wifiConfiguration);

returnwifiManager.enableNetwork(networkId, true);

}

/**

* 开启Wifi

*

* @paramcontext 上下文

* @return是否成功

*/

publicstaticbooleanopenWifi(Context context){

WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);

returnwifiManager != null&& (wifiManager.isWifiEnabled() || wifiManager.setWifiEnabled( true));

}

/**

* 获取当前连接的Wifi的SSID

*

* @paramcontext 上下文

* @returnSSID

*/

publicstaticString getConnectedSSID(Context context){

WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);

WifiInfo wifiInfo = wifiManager == null? null: wifiManager.getConnectionInfo();

returnwifiInfo != null? wifiInfo.getSSID().replaceAll( """, "") : "";

}

连接到指定Wifi后，在选择了要发送的文件后，就启动一个后台线程去主动请求连接服务器端，然后就是进行实际的文件传输操作了

发起选取文件请求的方法

Intent intent = newIntent(Intent.ACTION_GET_CONTENT);

intent.setType( "*/*");

intent.addCategory(Intent.CATEGORY_OPENABLE);

startActivityForResult(intent, CODE_CHOOSE_FILE);

获取选取的文件的实际路径，并启动 AsyncTask 去进行文件传输操作

@Override

protectedvoid onActivityResult(int requestCode, int resultCode, Intent data) {

if(requestCode == CODE_CHOOSE_FILE && 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()) {

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

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

new FileSenderTask( this, fileTransfer).execute(WifiLManager.getHotspotIpAddress( this));

}

}

}

}

}

privateString 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();

returndata;

}

}

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

returnuri.getPath();

}

returnnull;

}

将服务器端的IP地址作为参数传给 FileSenderTask ，在正式发送文件前，先发送包含文件信息的 FileTransfer ，并在发送文件的过程中实时更新文件传输状态

/**

* 作者：chenZY

* 时间：2018/2/24 10:21

* 描述：

*/

publicclassFileSenderTaskextendsAsyncTask<String, Double, Boolean> {

privateProgressDialog progressDialog;

privateFileTransfer fileTransfer;

privatestaticfinalString TAG = "FileSenderTask";

publicFileSenderTask(Context context, FileTransfer fileTransfer){

this.fileTransfer = fileTransfer;

progressDialog = newProgressDialog(context);

progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);

progressDialog.setCancelable( false);

progressDialog.setCanceledOnTouchOutside( false);

progressDialog.setTitle( "发送文件："+ fileTransfer.getFilePath());

progressDialog.setMax( 100);

}

@Override

protectedvoidonPreExecute(){

progressDialog.show();

}

@Override

protectedBoolean doInBackground(String... strings){

Logger.e(TAG, "开始计算文件的MD5码");

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], Constants.PORT)), 10000);

outputStream = socket.getOutputStream();

objectOutputStream = newObjectOutputStream(outputStream);

objectOutputStream.writeObject(fileTransfer);

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

bytebuf[] = newbyte[ 512];

intlen;

//文件大小

longfileSize = fileTransfer.getFileLength();

//当前的传输进度

doubleprogress;

//总的已传输字节数

longtotal = 0;

//缓存-当次更新进度时的时间

longtempTime = System.currentTimeMillis();

//缓存-当次更新进度时已传输的总字节数

longtempTotal = 0;

//传输速率（Kb/s）

doublespeed;

//预估的剩余完成时间（秒）

doubleremainingTime;

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

outputStream.write(buf, 0, len);

total += len;

longtime = System.currentTimeMillis() - tempTime;

//每一秒更新一次传输速率和传输进度

if(time > 1000) {

//当前的传输进度

progress = total * 100/ fileSize;

Logger.e(TAG, "---------------------------");

Logger.e(TAG, "传输进度: "+ progress);

Logger.e(TAG, "时间变化："+ time / 1000.0);

Logger.e(TAG, "字节变化："+ (total - tempTotal));

//计算传输速率，字节转Kb，毫秒转秒

speed = ((total - tempTotal) / 1024.0/ (time / 1000.0));

//预估的剩余完成时间

remainingTime = (fileSize - total) / 1024.0/ speed;

publishProgress(progress, speed, remainingTime);

Logger.e(TAG, "传输速率："+ speed);

Logger.e(TAG, "预估的剩余完成时间："+ remainingTime);

//缓存-当次更新进度时已传输的总字节数

tempTotal = total;

//缓存-当次更新进度时的时间

tempTime = System.currentTimeMillis();

}

}

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());

returnfalse;

} 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();

}

}

}

}

@Override

protectedvoidonProgressUpdate(Double... values){

progressDialog.setProgress(values[ 0].intValue());

progressDialog.setTitle( "传输速率："+ values[ 1].intValue() + "Kb/s"+ "n"

+ "预计剩余完成时间："+ values[ 2].longValue() + "秒");

}

@Override

protectedvoidonPostExecute(Boolean aBoolean){

progressDialog.cancel();

Log.e(TAG, "onPostExecute: "+ aBoolean);

}

}

四、校验文件完整性

文件的完整性主要是通过对比文件前后的MD5码值来校验了，文件发送端在发送文件前，先计算得到文件的MD5码，将值赋给 FileTransfer 模型传给文件接收端，文件接收端在传输结束后，再次计算本地的文件MD5码值，通过对比前后值是否相等，就可以判断文件是否传输完整

MD5码值通过如下方法计算得到

/**

* 作者：chenZY

* 时间：2018/2/24 9:46

* 描述：

*/

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();

}

}

好了，Wifi 传输文件的主要思路就讲到这里了，这里也分享下源代码：https://github.com/leavesC/WifiFileTransfer

大家都在看