《Efective Jave》中主要介绍了 3 种多参数构建方法，我在项目里还用到了第 4 种。下面一一介绍。

##0x00 简单、常用：重叠构造器
代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class A {
    private int v1;
    private int v2;
    private int v3;
    private int v4;
    private int v5;
    
    public A(int v1) { this(v1, DEFUALT_V2)}
    public A(int v1, int v2) { this(v1, v2, DEFUALT_V3)}
    public A(int v1, int v2, int v3) { this(v1, v2, v3, DEFUALT_V4)}
    public A(int v1, int v2, int v3, int v4) { this(v1, v2, v3, v4, DEFUALT_V5)}
    public A(int v1, int v2, int v3, int v4, int v5) {
        this.v1 = v1;
        this.v2 = v2;
        this.v3 = v3;
        this.v4 = v4;
        this.v5 = v5;
    }
}

优点：

1. 逻辑、层级清晰明了。适合参数层级关系明确的类，如 Android 里的 View。

缺点：

1. 参数增多时，可读性变差
2. 如示例所示，如果连续传入多个同样类型的变量，容易把顺序弄错
3. 灵活性不足，无法指定初始化特定几个参数

##0x01 简单、灵活：重复 set 方法
代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class B {
    private int v1 = DEFAULT_V1;
    private int v2 = DEFAULT_V2;
    private int v3 = DEFAULT_V3;
    private int v4 = DEFAULT_V4;
    private int v5 = DEFAULT_V5;
    
    public B() {}
    public void setV1(int val) { v1 = val; }
    public void setV2(int val) { v2 = val; }
    public void setV3(int val) { v3 = val; }
    public void setV4(int val) { v4 = val; }
    public void setV5(int val) { v5 = val; }
}

优点:

1. 简单
2. 灵活，支持定制式初始化，即参数可选，如果不需要自定义的变量可以直接不给初始化方法
3. 支持动态改变参数，set 方法也可以在程序运行的任何阶段调用

缺点：

1. 如果变量的需要按一定顺序初始化，那么这种调用方式将带来风险。实际项目被这个坑过。提供外部的接口最好在编写时排除这种漏洞的隐患
2. set 方法可在任何时间调用，更改变量的值。和缺点 1 同理，如果变量耦合了其他逻辑，那么随时可调用 set 方法就是不安全的。

0x02 安全、可读：Builder 构建器

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class C {
    private int v1;
    private int v2;
    private int v3;
    private int v4;
    private int v5;
    
    public static class Builder {
        private int v1 = DEFAULT_V1;
        private int v2 = DEFAULT_V2;
        private int v3 = DEFAULT_V3;
        private int v4 = DEFAULT_V4;
        private int v5 = DEFAULT_V5;
        public Builder(int v1) { this.v1 = v1; return this;}
        public Builder v2(int val) { this.v2 = val; return this; }
        public Builder v3(int val) { this.v3 = val; return this; }
        public Builder v4(int val) { this.v4 = val; return this; }
        public Builder v5(int val) { this.v5 = val; return this; }
        public C build() { return new C(this); }
    }
    private C(Builder builder) {
        this.v1 = builder.v1;
        this.v2 = builder.v2;
        this.v3 = builder.v3;
        this.v4 = builder.v4;
        this.v5 = builder.v5;
    }
}
// Usage:
// C c = new C.Builder(1).v2(2).v3(3).v4(4).v5(5).build();

优点：

1. 灵活，支持定制式初始化
2. 可读性强，参见 Android 的 Animator 类，一个语句完成类的初始化和调用
3. 可以在 build() 方法内统一进行参数校验，为《Ecfective Java》推荐方法

缺点：

1. 复杂，构建所需代码行数增加
2. 参数在传入时为确定参数，不支持动态改变

0x03 实时参数：Provider 模式

该方法借鉴了 Builder 构建器，但是将构建器独立于类外，同时提供实时获取的接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public class D {
    private int v1;
    private int v2;
    private int v3;
    private int v4;
    private int v5;
    
    public interface Provider {
        public int getV1();
        public int getV2();
        public int getV3();
        public int getV4();
        public int getV5();
    }
    public D(Provider provider) {
        this.v1 = provider.getV1();
        this.v2 = builder.v2;
        this.v3 = builder.v3;
        this.v4 = builder.v4;
        this.v5 = builder.v5;
    }
}
// Usage:
// public class IProvider implement D.Provider {
//        @Override
//        public int getV1() { return val; }
//        @Override
//        public int getV2() { return val; }
//        @Override
//        public int getV3() { return val; }
//        @Override
//        public int getV4() { return val; }
//        @Override
//        public int getV5() { return val; } 
// }
// D d = new D(new IProvider());

优点：

1. 借鉴了 Builder 构建器的优点，隔离了参数传入方法和初始化方法
2. Provider 由调用方实现，使动态参数的传入变为可能
3. 调用节点只需要调用一行语句，初始化参数的准备移至他处。这种场景需求可能发生在一个核心类的 initAll() 方法中，调用者需要在该方法内先后初始化十几个模块。如果每个模块都要写十行代码那就非常恐怖了。

1. 参照官网安装 Docker for Mac，傻瓜式安装非常简单，不再累述；

2. 判断本地 CPU 是否支持 AVX指令集：

   1	if cat /proc/cpuinfo | grep -q avx ; then echo "Support AVX"; else echo "Not support AVX"; fi

3. 根据是否支持 AVX 选择镜像下载：

虽然新版的文档只有6个镜像，但实际上上述表格中所有镜像都在同步更新（地址）。 没有本文选择cpu-noavx-latest下载：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

$ docker pull paddledev/paddle:cpu-noavx-latest
$ docker run -it paddledev/paddle:cpu-noavx-latest 
root@c9eea5b52828:/# paddle version
PaddlePaddle 0.8.0b3, compiled with
    with_avx: OFF
    with_gpu: OFF
    with_double: OFF
    with_python: ON
    with_rdma: OFF
    with_glog: ON
    with_gflags: ON
    with_metric_learning: 
    with_timer: OFF
    with_predict_sdk:

安装成功！

##注意：
旧版官网上提到的镜像下载语句：

1

$ docker run -it paddledev/paddlepaddle:cpu-latest

是错的！！！。仓库路径应该为paddledev/paddle，而非paddledev/paddlepaddle。这个小问题折腾了我很久，希望对读者有所帮助。

1
2
3
4
5
6
7
8
9

Bad notification posted from package com.mypkg.name: Couldn't create icon: StatusBarIcon(pkg=com.mypkg.name user=0 id=0x7f0200dc level=0 visible=true num=0 )
android.app.ActivityThread$H.handleMessage(ActivityThread.java:1638) 
android.os.Handler.dispatchMessage(Handler.java:111) 
android.os.Looper.loop(Looper.java:194) 
android.app.ActivityThread.main(ActivityThread.java:5637) 
java.lang.reflect.Method.invoke(Native Method) 
java.lang.reflect.Method.invoke(Method.java:372) 
com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:960) 
com.android.internal.os.ZygoteInit.main(ZygoteInit.java:755)

前段时间升级直接导致 crash 收集平台被该 bug 刷屏，而测试过程又一次都没有复现。StackOverFlow 上也没有太好的解决方案。这里探索了一种固化资源 id 的解决方案，线上验证也是可行的，bug率明显下降。但是另一种类似的cannot expand view还未能解决。

通过反编译可以发现，Android App 会在 res/values/public.xml 里存储所有的资源文件名到资源文件 id 的映射关系。如果在编译前手动添加部分资源的 id 到 public.xml 下，那么这些资源的 id 就得以固化，升级以及添加修改资源都不会对这些 id 产生影响。此外，res/values/ids.xml 也起到了类似作用，只不过仅覆盖 id 资源。

因此，解决思路应该是反编译 Apk 包，获得最新的public.xml，讲所有RemoteView涉及到的资源文件，包括string, dimen, drawable, id, layout等，提取出来并保存在项目源码中的res/values/public.xml和res/values/ids.xml文件中。

注意：Gradle 自 1.3.0 以后版本编译时会默认忽略本地的 public.xml 文件，因此还需要添加 Gradle 脚本使 public.xml 生效。打开 app 的 build.gradle 文件，在最后添加如下脚本 (参考连接中也提到了利用 Gradle 插件的解决方案)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

afterEvaluate {
    for (variant in android.applicationVariants) {
        def scope = variant.getVariantData().getScope()
        String mergeTaskName = scope.getMergeResourcesTask().name
        def mergeTask = tasks.getByName(mergeTaskName)
        mergeTask.doLast {
            copy {
                int i=0
                from(['res']) {
                    include 'values/public.xml'
                    rename 'public.xml', (i == 0? "public.xml": "public_${i}.xml")
                    i++
                }
                into(mergeTask.outputDir)
            }
        }
    }
}

— Update
如果需要对submodule中的资源也增加id固化，则可以在上面代码['res']中增加相应资源路径即可。

参考：

1. android gradle plugin 1.3.0 以上使用 public.xml 固定 id

1. 文件验证：将一个 html 文件配置到 source 目录下，使之可以访问并获取其中的字符串。
2. HTML meta 标签验证：在主页的 html 头里增加一个 meta 标签，记录搜索引擎提供的字符串。

如果使用了 Next 主题，source 目录下所有的 html 都会按主题模板化，这使得文件验证生成的页面中字符串无法被搜索引擎识别。虽然理论上可以对单独的地址进行模板屏蔽，但一个网站冷不丁冒出来一个风格迥异的页面还是不能让人接受。所以，我最后选择了 HTML meta 标签验证方法。

Google 引擎验证申请地址
Baidu 引擎验证申请地址

Next 主题下，页面的 header 设置在themes/next/layout/_partials/head.swig内。默认也给我们提供了模板，感谢开发者 iissnan。我们只需要把下面标签补全即可：

1
2
3
4
5
6
7

{% if theme.google_site_verification %}
  <meta name="google-site-verification" content="IQs30MFrhmrm-Nfmv-_neEbXELyUuxvZtdin1ALJ4aA" />
{% endif %}
{% if theme.baidu_site_verification %}
  <meta name="baidu-site-verification" content="H1J5y75sN7" />
{% endif %}

同时，在themes/next/_config.yml中将google-site-verification和baidu_site_verification的值设置为true即可。

P.S.
百度现在不支持 https 网址的验证，ORZ。

感谢@小硕硕_ 的提醒，更正确的方法是在_config.xml里直接定义google-site-verification和baidu_site_verification的值为相应id。

Referrence:

1. hexo干货系列：（六）hexo提交搜索引擎（百度+谷歌）

Official Reference: LikeView Reference

##BUG 0x01: The developers or testers cannot access the Like Page

1. Check the internet connection.
2. Check if the page is allowed to be liked.
3. Check the account of developers or testers have the permission of developer or tester under the APP ID.
4. Check Facebook App support before initialize LikeView, and DO NOT just check the installation of Facebook App. For some lower version of Facebook App, things may not work properly. Using SDK for checking as following:

1
2
3
4

if (Build.VERSION.SDK_INT >= 15) {
    if (LikeDialog.canShowNativeDialog() || LikeDialog.canShowWebFallback()) {
    }
}

BUG 0x02: Crash when initializing

1. DO NOT initialize LikeView in your layout.xml as the Official guide recommended, which is unsafe for API level < 15. ( min version for FB SDK 4.10 ) All of the FB SDK method should be used after API level judgement.
2. If you only want to open LikeDialog in Facebook App and only use LikeDialog.canShowNativeDialog() for judgement, LikeDialog may fail to open after swipe all the data of Facebook App. I recommend to use web dialog just in case.

BUG 0x03: Crash in onActivityResult()

Stack overflow give a way to get the like result in onActivityResult() method. But it should add a data != null judgment, otherwise app will crash when not data returns.

BUG 0x04: Native Like Button permission

App Review should be done to get Native Like Button permission. Otherwise, only developers and test users can access like button.

(Moved from another blog site of my)

Buck is a build system developed and used by Facebook. It encourages the creation of small, reusable modules consisting of code and resources, and supports a variety of languages on many platforms.

Facebook 开源的东东，据说微信也在用。接手的项目以前是 Ant，现在转 Gradle。但由于项目本身携带了大量历史遗留代码，并且集合了数个 submodule，编译起来非常缓慢，拖延了开发效率。这里测试一下 Buck 替代的可能性。

0x01 安装

OS X 下使用 homebrew 安装：

1
2
3
4

brew update
brew tap facebook/fb
brew install buck
brew install watchman

Watchman 是 FB 强力推荐安装的，可以有效提高 Buck 的编译效率。此外，对于 Android 开发，我们还必须把 Android SDK 和 NDK 的路径告诉 Buck。设置方法只需配置好ANDROID_HOME，ANDROID_NDK，ANDROID_NDK_REPOSITORY 这几个环境变量即可，本文暂不累述。

0x02 创建本地配置

… // TODO

0x01 静态工厂方法

1. 方法示例：

1
2
3

public static Boolean valueOf(boolean b) {
	return b ? Boolean.TRUE : Boolean.FALSE;
}

2. 优点：

1. 有名称。构造器实际上只能用类名命名，无法更多地描述构造信息。并且实际使用中，同一个类常有数个不同的构造方法，如果不加以区分（缺少必要注释）则很容易使用错误。而静态工厂方法，可以使用方法名去描述构造实例的更多信息，易于区分。
2. 不必每次调用都创建一个新的对象。重复调用可以利用好预先构建好的实例，从而减少了重复创建的开支。这点我目前的理解是静态工厂方法类内部可以调用其他的单例实例。
3. 可以返回原类型的任何子类型。这样在选择返回对象时就有了更大的灵活性。
4. 创建参数化实例时代码更加简洁。举例说明，原始代码：

1

Map<String, List<String>> m = new HashMap<String, List<String>>;

假设HashMap提供了这样的静态工厂方法：

1
2
3

public static <K, V> HashMap<K, V> newInstance() {
	return new HashMap<K, V>();
}

那么原始代码就可以简化为：

1

Map<String, List<String>> m = HashMap.newInstance();

3. 缺点：

1. 类如果不含公有的或者受保护的构造器，就不能被子类化。
2. 与其他静态方法没有本质上的区别。这个主要是对JavaDoc不友好，无法像构造方法一样被标识。

使用

静态工厂方法常用的方法名称如下：

1. valueOf, of
2. getInstance, newInstance
3. getType, newType

1. Wifi传输概述
2. WifiP2pManager类的介绍和使用
3. Wifi热点创建相关技术
4. 基于Wifi的文件传输方法
5. Demo的展示与介绍
6. 小结

1. Wifi传输概述

1.1 步骤

1. 发现对方IP地址：涉及WifiP2pManager和Wifi热点的创建
2. 监听端口，建立Socket通讯
3. 传输文件或其他信息

1.2 应用

1. 应用、照片、视频等文件的分发和传输
2. 手机与手机，手机与PC网页的通讯、文件传输

2. WifiP2pManager类的介绍和使用

该方法提供了对WiFi peer-to-peer传输的管理API，从而使得应用可以发现可用的peer，设置到peer的连接以及查询peer列表。本质上其功能也可以通过UDP广播实现。

2.1 简介

WiFi p2p常用方法

1
2
3
4
5
6
7
8
9
10
11
12

// Initialization 
public Channel initialize(Context srcContext, Looper srcLooper, ChannelListener listener);
public void connect(Channel c, WifiP2pConfig config, ActionListener listener);
public void discoverPeers(Channel c, ActionListener listener);
public void createGroup(Channel c, ActionListener listener);
// Request Info
public void requestPeers(Channel c, PeerListListener listener);
public void requestConnectionInfo(Channel c, ConnectionInfoListener listener);
public void requestGroupInfo(Channel c, GroupInfoListener listener);
// ...

WiFi p2p常用监听器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public interface ActionListener {
    public void onSuccess();
    public void onFailure(int reason);
}
public interface PeerListListener {
    public void onPeersAvailable(WifiP2pDeviceList peers);
}
public interface ChannelListener {
    public void onChannelDisconnected();
}
public interface ConnectionInfoListener {
    public void onConnectionInfoAvailable(WifiP2pInfo info);
}
public interface GroupInfoListener {
    public void onGroupInfoAvailable(WifiP2pGroup group);
}
public interface ServiceResponseListener {
    public void onServiceAvailable(int protocolType,
            byte[] responseData, WifiP2pDevice srcDevice);
}
// ...
~~~   
WiFi p2p Intent
~~~java
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String WIFI_P2P_CONNECTION_CHANGED_ACTION;
public static final String WIFI_P2P_PEERS_CHANGED_ACTION;
public static final String WIFI_P2P_STATE_CHANGED_ACTION;
public static final String WIFI_P2P_THIS_DEVICE_CHANGED_ACTION;

2.2 初始化

2.2.1 对wifi p2p intent广播进行监听

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class WiFiDirectBroadcastReceiver extends BroadcastReceiver {
    private WifiP2pManager mManager;
    private Channel mChannel;
    private MyWiFiActivity mActivity;
    public WiFiDirectBroadcastReceiver(WifiP2pManager manager, Channel channel,
            MyWifiActivity activity) {
        super();
        this.mManager = manager;
        this.mChannel = channel;
        this.mActivity = activity;
    }
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
            // Check to see if Wi-Fi is enabled and notify appropriate activity
        } else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
            // Call WifiP2pManager.requestPeers() to get a list of current peers
        } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {
            // Respond to new connection or disconnections
        } else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) {
            // Respond to this device's wifi state changing
        }
    }
}

2.2.2 创建wifi p2p应用

1. 申请权限

1
2
3
4
5
6

<uses-sdk android:minSdkVersion="14" />
<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" />

1. 初始化WiFiP2PManager，设置IntentFilter并注册广播接收对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

IntentFilter mIntentFilter;
@Override
protected void onCreate(Bundle savedInstanceState){
    mManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
    mChannel = mManager.initialize(this, getMainLooper(), null);
    mReceiver = new WiFiDirectBroadcastReceiver(mManager, mChannel, this);
    
    mIntentFilter = new IntentFilter();
    mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
    mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
    mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
    mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
}
@Override
protected void onResume() {
    super.onResume();
    registerReceiver(mReceiver, mIntentFilter);
}
@Override
protected void onPause() {
    super.onPause();
    unregisterReceiver(mReceiver);
}

2.3 发现方法

1
2
3
4
5
6
7
8
9

// Descover methods
public void discoverPeers(Channel c, ActionListener listener);
public void discoverServices(Channel c, ActionListener listener)；
// Listeners
public interface ActionListener {
        public void onSuccess();
        public void onFailure(int reason);
}

3. Wifi热点创建相关技术

安卓系统将热点控制API设置为@hide属性，需要使用反射机制调用。Wifi热点的创建相关技术主要分为两步：

1. 创建WifiConfiguration， 调用setWifiApEnabled函数讲配置文件写入系统，从而开启Wifi热点。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

   private void createWifiAp(String ssid, String password) { if (mWifiManager.isWifiEnabled()) { mWifiManager.setWifiEnabled(false); } mNetConfig = new WifiConfiguration(); mNetConfig.SSID = ssid; mNetConfig.preSharedKey = password; mNetConfig.status = WifiConfiguration.Status.ENABLED; mNetConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN); mNetConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN); mNetConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA); mNetConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP); mNetConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP); mNetConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP); mNetConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP); mNetConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);//NONE); try { Method setWifiApMethod = mWifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class); boolean apstatus = (Boolean) setWifiApMethod.invoke(mWifiManager, mNetConfig, true); Method isWifiApEnabledmethod = mWifiManager.getClass().getMethod("isWifiApEnabled"); while (!(Boolean) isWifiApEnabledmethod.invoke(mWifiManager)) { } ; Method getWifiApStateMethod = mWifiManager.getClass().getMethod("getWifiApState"); int apstate = (Integer) getWifiApStateMethod.invoke(mWifiManager); Method getWifiApConfigurationMethod = mWifiManager.getClass().getMethod("getWifiApConfiguration"); mNetConfig = (WifiConfiguration) getWifiApConfigurationMethod.invoke(mWifiManager); Log.d("CLIENT", "\nSSID:" + mNetConfig.SSID + "\nPassword:" + mNetConfig.preSharedKey + "\n"); } catch (Exception e) { Log.e(TAG, e.toString()); e.printStackTrace(); } }

2. 下载端连接后，扫描/proc/net/arp文件获取连接到主机的IP。当然也可以等下载机访问我们指定的主机网址，再通过请求知道下载机的IP地址，这里暂不累述。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

   /** * Gets a list of the clients connected to the Hotspot * @param onlyReachables {@code false} if the list should contain unreachable (probably disconnected) clients, {@code true} otherwise * @param reachableTimeout Reachable Timout in miliseconds * @param finishListener, Interface called when the scan method finishes */ public void getClientList(final boolean onlyReachables, final int reachableTimeout, final FinishScanListener finishListener) { Runnable runnable = new Runnable() { public void run() { BufferedReader br = null; final ArrayList<ClientScanResult> result = new ArrayList<ClientScanResult>(); try { br = new BufferedReader(new FileReader("/proc/net/arp")); String line; while ((line = br.readLine()) != null) { String[] splitted = line.split(" +"); if ((splitted != null) && (splitted.length >= 4)) { // Basic sanity check String mac = splitted[3]; if (mac.matches("..:..:..:..:..:..")) { boolean isReachable = InetAddress.getByName(splitted[0]).isReachable(reachableTimeout); if (!onlyReachables || isReachable) { result.add(new ClientScanResult(splitted[0], splitted[3], splitted[5], isReachable)); } } } } } catch (Exception e) { Log.e(this.getClass().toString(), e.toString()); } finally { try { br.close(); } catch (IOException e) { Log.e(this.getClass().toString(), e.getMessage()); } } // Get a handler that can be used to post to the main thread Handler mainHandler = new Handler(context.getMainLooper()); Runnable myRunnable = new Runnable() { @Override public void run() { finishListener.onFinishScan(result); } }; mainHandler.post(myRunnable); } }; Thread mythread = new Thread(runnable); mythread.start(); }

4. 基于Wifi的文件传输方法

基于WiFi的数据传输主要有两个技术点：一方面是文件传输，另一方面是下载端的网页实时获得文件传输的进度。前者可以直接使用ServerSocket实现，后者对于双方均安装我们的下载app的情况没有难度，但对于一边是app发送文件，一边是网页打开连接下载文件，就需要基于JavaScript的XMLHttpRequest可以实现主机和下载机网页的信息交流。

4.1 使用ServerSocket传输数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

/**
 * Sends the HTTP response to the client, including headers (as applicable)
 * and content.
 */
private void processRequest(Socket client) throws IllegalStateException, IOException {
    Log.e(TAG, "Starting to process request");
    client.setKeepAlive(true);
    InputStream is = client.getInputStream();
    final int bufsize = 8192;
    byte[] buf = new byte[bufsize];
    int splitbyte = 0;
    int rlen = 0;
    {
        int read = is.read(buf, 0, bufsize);
        while (read > 0) {
            rlen += read;
            splitbyte = findHeaderEnd(buf, rlen);
            if (splitbyte > 0)
                break;
            read = is.read(buf, rlen, bufsize - rlen);
        }
    }
    // Create a BufferedReader for parsing the header.
    ByteArrayInputStream hbis = new ByteArrayInputStream(buf, 0, rlen);
    BufferedReader hin = new BufferedReader(new InputStreamReader(hbis));
    Properties pre = new Properties();
    Properties parms = new Properties();
    Properties header = new Properties();
    try {
        decodeHeader(hin, pre, parms, header);
    } catch (InterruptedException e1) {
        Log.e(TAG, "Exception: " + e1.getMessage());
        e1.printStackTrace();
    }
  
    String range = header.getProperty("range");
    cbSkip = 0;
    if (range != null) {
        Log.e(TAG, "range is: " + range);
        range = range.substring(6);
        int charPos = range.indexOf('-');
        if (charPos > 0) {
            range = range.substring(0, charPos);
        }
        cbSkip = Long.parseLong(range);
        Log.i(TAG, "range found!! " + cbSkip);
    }
    sendHTMLtext(HTMLManager.getDownloadingHTML(), client.getOutputStream());
    mSendState = SEND_STATE_SENDING;
}
private void sendHTMLtext(String htmlStr, OutputStream outputStream) {
    PrintWriter printWriter = new PrintWriter(outputStream);
    printWriter.println(htmlStr);
    printWriter.close();
}

4.2 使用XMLHttpRequest在网页上实时获取下载进度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

var xmlhttp = new XMLHttpRequest;
var url = "http://192.168.43.1:8080";
var timer = setInterval("loadurl(url)", 500); // 定时请求刷新
function loadurl(url) {
        if (xmlhttp != null) {
            xmlhttp.onreadystatechange = state_Change;
            xmlhttp.open("GET", url, true);
            xmlhttp.send(null);
        } else {
            alert("Your browser does not support XMLHTTP.");
        }
    }
function state_Change() {
    var infoBar = document.getElementsByClassName("cube")[0];
    if (xmlhttp.responseText == "") return;
    var percent = parseInt(xmlhttp.responseText.substring(0, 3));
    if (percent != NaN) {
        infoBar.innerHTML = xmlhttp.responseText; // 刷新DOM元素
        if (percent == 100) {
            clearInterval(timer);
            infoBar.innerHTML = "Complete. Please install it.";
        }
    }
}

5. Demo的展示与介绍

wifi热点的创建和文件传输

6. 小结

6.1 基于安卓的wifi传输 ==能做到什么==？

1. 局域网内，安装我们APP的手机之间的互相发现和连接
2. 热点的创建和定制
3. 免流量的高速、稳定的数据传输，相对于蓝牙和NFC具有很大优势
4. 一方安装了APP，另一方仍可通过热点连接，基于网页JS实现与主机APP的信息交互

6.2 基于安卓的wifi传输 ==不能做到什么==？==有哪些坑==？

1. 没有底层权限，很多服务器常见的设置都无法完成，比如无法设置IPTable
2. 安卓网页的局限，浏览器对JS的支持性和PC端不同，需要额外设计
3. 部分安卓厂商自己修改了官方的热点API，比如HTC，这使得在这些手机上创建热点需要额外配置

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment