項目背景

今年，相信很多人都會在各個商場或者是電影院中可以看到各種娃娃機、幸運盒子、口紅挑戰等等類似機器。在抖音上《口紅挑戰》這款機子也是火的一塌糊塗，你只要花 10 塊錢就有可能贏走一個 YSL 口紅，想想就覺得很有誘惑力。或許這些機器被程序員一瞧就知道其中的貓膩，但是這個機器瞄準的是那些容易衝動消費的消費者，比如情侶、女生、帶小孩的大人；像程序員這麼奇葩的生物，一般都是直接被無視的哈哈。

然後呢，我們公司就是爲這些設備的正常運行提供解決方案的。因此纔有我今天的爬坑總結，哈哈哈哈哈.....

我們提供的解決方案是這樣的，在一個門店裏面會包含如下的設備：娃娃機、口紅挑戰、排行榜、中控，當然其中還有我們的後臺服務。那麼首先我會先介紹一下整個系統的架構以及各個設備的職責：

系統架構圖

服務後臺
- 服務後臺不屬於 Android 這端負責的，因此不需要去關注太多，服務後臺相對於門店設備而言，它的一個職責是負責給機器發送上分質量，監測設備狀態，及一些其他的信息。
中控（本地服務：不連接外網）：這個中控也是也 Android 設備，它的功能有兩個：
1. 排行榜：用來接收娃娃機中發送過來的用戶夾中娃娃的信息，並最後將其顯示在排行榜上。
2. 資源分發中控：作爲資源的分發中心，中控需要分發 apk 安裝包、圖片、
娃娃機：這一塊其實包含了兩個部分，一個是 Android 設備，另外一個硬件設備。
1. Android 設備主要是用來顯示 banner、處理服務器數據（例如：上分）、對接中控（資源更新、數據反饋等）、對接硬件設備
2. 硬件設備主要是處理用戶上分、出禮、心跳等信息，並將這些信息交給 Android 設備處理。
口紅挑戰：關於口紅挑戰這個設備可以劃分爲 3 個模塊，分別爲見縫插針遊戲、常規程序模塊、硬件模塊
1. 關於見縫插針的這個遊戲是用白鷺引擎做的，最後以 h5 的形式嵌入到 APP 中，主要負責遊戲的主邏輯以及和程序主模塊進行遊戲邏輯數據的反饋。
2. 常規模塊主要是有處理服務後臺的數據、對接硬件模塊（格子選中、打開格子等）、對接遊戲（啓動遊戲、遊戲結果反饋等）、物料後臺管理。
rocket：這個程序有點特殊，因爲用戶是看不到它的，在出廠的時候，這個程序就被寫進去了，那麼它負責的工作如下：
1. 屏蔽設備的 systemui 程序和 launcher 程序，防止用戶做一些非法的操作。
2. 檢測 U 盤是否插入，然後移動或者負責制定文件（apk 安裝包、ipconfig.json 文件、三元組配資文件config.json、h5 資源文件等）
3. 接收廣播，自動安裝或者更新娃娃機或者口紅挑戰程序

要解決的問題

同步加載資源

關於資源同步的，首先我們先理一下我們需要同步的資源有哪些，這些資源分別爲： apk 安裝包、圖片、h5 相關的 index 資源。

資源更新的方式

關於更新的方式，這裏其實就有一個比較坑的地方了，一開始的時候我們選擇的資源更新方式比較傻，直接使用 websocket 進行資源更新的，一開始的時候只有一個設備進行連接，問題倒是不大，但是後來發現多臺設備連接同時更新資源的時候問題特別大，連接經常斷開，導致資源更新失敗。那麼這裏是我遇到的第一個坑。發現這個坑之後呢，我的選擇資源更新的方式就更改爲：NanoHttpd。NanoHttpd 是一個開源庫，是用 Java 實現的，它可以在 Android 設備上建立一個輕量級的 web server。其實在 Android 設備上創建一個輕量級的 web server 纔是我們一開始就應該要選擇的方向。爲什麼呢？首先 NanoHttpd 的使用是比較簡單的，因此我們只需要幾行代碼就可以實現一個 web server 了；其次呢，NanoHttpd 是比較穩定的，相對於我們手動使用 websocket 去實現一個資源分發要穩定太多了。

那麼在我們選擇了資源的更新方式之後，有另外一個問題浮出水面了，關於服務器的 IP 地址。我們都知道，關於 Android 設備連接上移動互聯網或者 WiFi 的時候都會被自動分配一個 IP 地址，因此這個 IP 地址是會變化的，我們的設備在每天晚上都會關機，然後在第二天開啓重啓的時候又會被分配到一個新的 IP 地址，因此服務器的 IP 地址是一直在變化的，所以這裏我們需要做的是想辦法把某個設備的 IP 地址給固定下來。那麼接下來就來講講關於 NanoHttpd 創建輕量級的 web server 和如何解決 IP 變化的問題。

NanoHttpd 實現 web server

NanoHttpd 項目地址
- https://github.com/NanoHttpd/nanohttpd
gradle 依賴

    implementation 'org.nanohttpd:nanohttpd-webserver:2.3.1'

實現方式

    File resourceDir = new File(Environment.getExternalStorageDirectory(), "myRootDir");
    SimpleWebServer httpServer = new SimpleWebServer(null, 18103, resourceDir, true, "*");
    httpServer.start(NanoHTTPD.SOCKET_READ_TIMEOUT, true);

SimpleWebServer 構造函數的參數
- host：服務器 ip 地址
- port：端口號（取值範圍：1024~65535）
- wwwroot：放置靜態資源的根目錄
- quiet：是否爲安靜模式
- cors：
訪問方式
- 在同個局域網下，那麼我們在瀏覽器中輸入地址：http://10.0.0.34:18103，我們就可以訪問到我們服務器中的資源了，當然目前實現的服務器是靜態的，只能處理 get 資源請求，不能夠處理 post、put 等其他請求，目前是處理不了的，如果需要自己再處理 post 和 put 等其他的請求的話，那麼可以自己去項目原地址中參考它的用法去實現，在這裏就不多講了。

解決 IP 變化的問題

在 Android 設備中，它的一個 IP 地址是會變化的，而且每個門店都會有一個自己的內部中控機，那麼我們是必須要處理 IP 地址變化的這個問題的。我們的解決方案有如下兩個步驟：

在路由器中根據 Mac 地址，爲門店內的中控設備設置固定的 IP 地址
爲每個娃娃機和口紅挑戰設備提供一個 IP 地址的配置文件，這個文件裏面有門店中控的 IP 地址信息，放在 U 盤的指定目錄下，但插入設備的時候，由 Rocket 程序將文件從 U 盤中將配置文件 copy 到設備的制定目錄下，設備每次啓動的時候都需要先讀取配置文件，再連接本地的服務器。

資源什麼時候更新

關於資源更新的，我們首先需要明確我們需要更新的資源有哪些以及我們需要更新的方式。

更新的資源

Resource.json
apk 包
娃娃機中的顯示器輪播圖
娃娃機中顯示 banner 的 h5 資源

更新的配置文件

關於我們資源跟新的所有數據都是保存在 Resource.json 這個文件夾裏面的，那麼我們每隔 5min 就從中控服務端（局域網內）獲取 Resource.json，然後每個類型的資源就根據寫在 Resource.json 中的數據進行判斷。那麼寫入 Resource.json 文件中的實現及具體內容如下：

資源的 ResList model

public class ResListModel {
    // 娃娃機 banner 的 h5 資源（index.html等文件）
    public HashMap<String, String> bannerFiles = new HashMap();
    // 門店中所有娃娃機都會顯示的輪播圖
    // key 爲 圖片的 hash 值
    // value 爲圖片的在服務器中的相對路徑
    public HashMap<String, String> PublicFiles = new HashMap();
    // 門店中特定娃娃機的私有顯示輪播圖
    // key 爲設備的 id
    // value 爲圖片圖片的 hash 及路徑信息（對應 PublicFiles）
    public HashMap<String, HashMap<String, String>> PrivateFiles = new HashMap();
    // 更新的 apk 路徑
    public String UpdateApk;
    // 更新的 apk 包名
    public String UpdateApkPackageName;
    // 更新的 apk 版本名
    public String UpdateApkVersion;
    // 更新的 apk 版本號
    public int UpdateApkVersionCode;
}

寫入到 Resourse.json 文件

    ResListModel res = new ResListModel();
    // 略過添加數據的過程
    ...;
    File resourceFile = new File(baseDir, "Resource.json");
    RandomAccessFile out = new RandomAccessFile(resourceFile, "rw");
    byte[] json = JsonStream.serialize(res).getBytes("utf-8");
    out.setLength(json.length);
    out.write(json);
    out.close();

Resourse.json 的內容

{
    "PrivateFiles":{},
    "PublicFiles":
        {
            "1A7D3394A6F10D3668FB29D8CCA1CA8B":"Public/timg.jpg"
        },
    "UpdateApk":null,
    "UpdateApkPackageName":null,
    "UpdateApkVersion":null,
    "UpdateApkVersionCode":0,
    "bannerFiles":
        {
            "C609D70832710E3DCF0FB88918113B18":"banner/Resource.json",
            "FC1CF2C83E898357E1AD60CEF87BE6EB":"banner/app.8113390c.js",
            "27FBF214DF1E66D0307B7F78FEB8266F":"banner/manifest.json",
            "A192A95BFF57FF326185543A27058DE5":"banner/index.html",
            "61469B10DBD17FDEEB14C35C730E03C7":"banner/app.8113390c.css"
            
        }
}

資源圖片和 banner 的資源文件的更新

關於圖片和 banner 的資源文件的更新方式是類似的，只是存放的路徑不在同一個目錄下而已。那麼對這類資源的更新，我們是通過技術資源的 hash 值和文件名來進行判斷的。娃娃機或者口紅挑戰設備會每隔 5min 從中控中獲取 Resourse.json 文件，然後取出 ResListModel，ResListModel 在之前介紹過了，是保存資源更新的配置文件；之後我們從中取出相對於的配置，首先根據文件名判斷該文件是否已經存在本地了，如果不存在，則直接添加到資源更新的列表中，如果存在則再判斷 hash 值是否相同，相同就不更新，不相同先將本地的文件刪除，然後再將其就添加到更新資源的列表中。
圖片和 banner 資源更新流程圖：

中控中計算資源你的 hash 值

    try {
        // banner 資源文件
        String fileName = fileFilter.getAbsolutePath().substring(baseDirLength);
        RandomAccessFile randomAccessFile = new RandomAccessFile(fileFilter,"r");
        byte[] buf = new byte[(int) randomAccessFile.length()];
        randomAccessFile.read(buf);
        randomAccessFile.close();
        MessageDigest md5 = MessageDigest.getInstance("md5");
        byte[] hash = md5.digest(buf);
        String hashStr = ByteToHex(hash,0,hash.length);
        res.bannerFiles.put(hashStr,fileName);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

    // 字節轉換爲 16 進制
    public static String ByteToHex(byte[] bt, int offset, int len) {
        StringBuffer sb = new StringBuffer();
        for (int i = offset; i < offset + len; i++) {
            int tmp = bt[i] & 0xff;
            String tmpStr = Integer.toHexString(tmp);
            if (tmpStr.length() < 2)
                sb.append("0");
            sb.append(tmpStr);
        }
        return sb.toString().toUpperCase();
    }

娃娃機設備檢查更新（例如：banner 資源文件）

    public static Observable<Boolean> updateBannerRes(ResListBean resListBean) throws IOException, NoSuchAlgorithmException {
        // 獲取遠程 banner 的文件
        HashMap<File, String> remoteFiles = new HashMap();
        for (HashMap.Entry<String, String> entry : resListBean.bannerFiles.entrySet()) {
            remoteFiles.put(new File(entry.getValue()), entry.getKey());
        }

        FileUtils.GetFilesInDir(bannerDir,localBannerList,null);
        int baseDirLength = resDir.getAbsolutePath().length()+1;
        // step1：刪除本地文件（遠程 banner 中沒有的文件）
        for (File localFile : localBannerList) {
            File chileFile = new File(localFile.getAbsolutePath().substring(baseDirLength));
            if (!remoteFiles.containsKey(chileFile)) {
                MainActivity.appendAndScrollLog(String.format("刪除 banner 資源文件 %s\n", localFile.getAbsolutePath()));
                localFile.delete();
            }
        }

        // 下載本地沒有的文件
        ArrayList<Observable<File>> taskList = new ArrayList();
        for (Map.Entry<File, String> fileEntry : remoteFiles.entrySet()) {
            File file = new File(resDir,fileEntry.getKey().getAbsolutePath());

            // step2：本地中存在和遠程相同的文件名
            if (localBannerList.contains(file)) {
                // step3：根據 hash 值判斷是否爲同一文件
                String hashStr = FileUtils.getFileHashStr(file);
                if (TextUtils.equals(hashStr,fileEntry.getValue())){
                    MainActivity.appendAndScrollLog(String.format("保留 banner 文件 %s\n", file.getAbsolutePath()));
                    taskList.add(Observable.just(file));
                    continue;
                }
            }

            // step4：下載本地沒有的文件
            String url = new URL("http", Config.instance.centralServerAddress,
                    Config.instance.httpPort,
                    new File(BuildConfig.APPLICATION_ID, fileEntry.getKey().getAbsolutePath()).getAbsolutePath()).toString();
            // step5：加入文件下載列表
            taskList.add(DownLoadUtils.getDownLoadFile(url,file));
        }

        return Observable.concat(taskList)
                .toFlowable(BackpressureStrategy.MISSING)
                .parallel()
                .runOn(Schedulers.io())
                .sequential()
                .toList()
                .observeOn(Schedulers.computation())
                .map(new Function<List<File>, ArrayList<File>>() {
                    @Override
                    public ArrayList<File> apply(List<File> files) throws Exception {
                        ArrayList<File> list = new ArrayList();
                        for (File file : files) {
                            if (!file.getAbsolutePath().isEmpty()) {
                                list.add(file);
                            }
                        }
                        if (list.size() > 0) {
                            if (!Utils.EqualCollection(list, localBannerList)) {
                                Collections.sort(list);
                            } else {
                                list.clear();
                            }
                        }
                        return list;
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Function<ArrayList<File>, Boolean>() {
                    @Override
                    public Boolean apply(ArrayList<File> list) throws Exception {
                        if (list.size() > 0) {
                            localBannerList = list;
                            webViewHasLoad = false;
                            loadH5();
                        }
                        return true;
                    }
                })
                .observeOn(Schedulers.io())
                .map(new Function<Boolean, Boolean>() {
                    @Override
                    public Boolean apply(Boolean aBoolean) throws Exception {
                        FileUtils.DelEmptyDir(resDir);
                        return true;
                    }
                })
                .toObservable();
    }

程序升級的問題

關於程序的升級，相比較於圖片資源的更新要簡單許多。

我們的實現版本更新的步驟如下：
- step1：找出本地存在的 apk 文件（設備的中的 apk 都是制定路徑和制定文件名的），將其刪除。
- step2：判斷中控中的安裝包的版本號是否大於本地程序的版本號，如果是則進入 step3；否則忽略，不需要程序升級
- step3：下載最新版本的 apk 安裝包
- step4：下載成功後，發送廣播（action：包名；extra：apk文件路徑）給 rocket 程序
- step5：rocket 程序接收到廣播之後就升級程序
程序升級流程圖

具體代碼實現


    public static Observable<Boolean> updateGame(ResListBean res) throws IOException, InterruptedException {
        ArrayList<File> apkList = new ArrayList();
        FileUtils.GetFilesInDir(resDir, apkList, new String[]{
                ".apk",
        });
        // 刪除本地存在的 apk 包
        for (File file : apkList) {
            file.delete();
        }
        do {
            if (res.UpdateApk == null || res.UpdateApkVersion == null) {
                break;
            }
            // 判斷是否需要升級
            if (BuildConfig.VERSION_CODE >= res.UpdateApkVersionCode) {
                break;
            }
            
            // apk 的 URL
            final String url = new URL("http", Config.instance.centralServerAddress, Config.instance.httpPort, new File(BuildConfig.APPLICATION_ID, res.UpdateApk).getAbsolutePath()).toString();
            MainActivity.appendAndScrollLog(String.format("下載升級文件 %s\n", url));
            // 下載 apk 文件
            return DownLoadUtils.getDownLoadFile(url,resDir.getAbsolutePath(),res.UpdateApk)
                    .subscribeOn(Schedulers.io())
                    .observeOn(Schedulers.io())
                    .flatMap(new Function<File, ObservableSource<String>>() {
                        @Override
                        public ObservableSource<String> apply(File file) throws Exception {
                            String path = file.getAbsolutePath();
                            MainActivity.appendAndScrollLog(String.format("升級文件下載完成 %s %s\n", path, url));
                            PackageManager pm = MainActivity.instance.getPackageManager();
                            PackageInfo pi = pm.getPackageArchiveInfo(path, 0);
                            if (pi == null) {
                                MainActivity.appendAndScrollLog(String.format("升級文件打開失敗 %s\n", path));
                                return Observable.just("");
                            }
                            MainActivity.appendAndScrollLog(String.format("升級文件對比：Native(%s %s)/Remote(%s %s)\n", BuildConfig.APPLICATION_ID, BuildConfig.VERSION_NAME, pi.packageName, pi.versionName));
                            if (!BuildConfig.APPLICATION_ID.equals(pi.packageName)
                                    || BuildConfig.VERSION_CODE >= pi.versionCode) {
                                return Observable.just("");
                            }
                            return Observable.just(path);
                        }
                    })
                    .flatMap(new Function<String, Observable<Boolean>>() {
                        @Override
                        public Observable<Boolean> apply(String updateApk) throws Exception {
                            if (!updateApk.isEmpty()) {
                                Log.e(TAG, "等待遊戲結束後安裝升級文件...");
                                MainActivity.appendAndScrollLog("等待遊戲結束後安裝升級文件...\n");
                                synchronized (GamePlay.class) {//防止在遊戲運行時更新版本
                                    Log.e(TAG, "發佈廣播");
                                    Intent intent = new Intent();
                                    intent.setAction(Config.updateBroadcast);
                                    intent.putExtra("apk", updateApk);
                                    MainActivity.instance.sendBroadcast(intent);
                                    System.exit(0);
                                }
                            }
                            return Observable.just(true);
                        }
                    });
        } while (false);
        return Observable.just(true);
    }

資源文件下載

關於資源文件的下載，我是選擇 okdownload。okdownload 是一個支持多線程，多任務，斷點續傳，可靠，靈活，高性能以及強大的下載引擎。詳情可以去看 okdownload GitHub 地址

依賴方式

    implementation 'com.liulishuo.okdownload:okdownload:1.0.5'
    implementation 'com.liulishuo.okdownload:okhttp:1.0.5'

簡單實用示例

單文件下載

DownloadTask task = new DownloadTask.Builder(url, parentFile)
         .setFilename(filename)
         // the minimal interval millisecond for callback progress
         .setMinIntervalMillisCallbackProcess(30)
         // do re-download even if the task has already been completed in the past.
         .setPassIfAlreadyCompleted(false)
         .build();
 
 
task.enqueue(listener);
 
// cancel
task.cancel();
 
// execute task synchronized
task.execute(listener);

多文件下載

final DownloadTask[] tasks = new DownloadTask[2];
tasks[0] = new DownloadTask.Builder("url1", "path", "filename1").build();
tasks[1] = new DownloadTask.Builder("url2", "path", "filename1").build();
DownloadTask.enqueue(tasks, listener);

結合 Rxjava 實現文件下載


public class DownLoadUtils {

    /**
     * 從中控下載文件到本地
     * @param url
     * @param parentPath            保存到本地文件的父文件路徑
     * @param downloadFileName      保存到本地的文件名
     * @return
     */
    public static Observable<File> getDownLoadFile(String url,String parentPath,String downloadFileName){
        // 下載本地沒有的文件
        MainActivity.appendAndScrollLog(String.format("開始下載資源文件 %s\n", url));
        final DownloadTask task = new DownloadTask.Builder(url, parentPath, downloadFileName).build();
        return Observable.create(new ObservableOnSubscribe<File>() {
            @Override
            public void subscribe(final ObservableEmitter<File> emitter) throws Exception {
                task.enqueue(new DownloadListener2() {
                    @Override
                    public void taskStart(DownloadTask task) {

                    }

                    @Override
                    public void taskEnd(DownloadTask task, EndCause cause, Exception realCause) {
                        if (cause != EndCause.COMPLETED) {
                            MainActivity.appendAndScrollLog(String.format("資源文件下載失敗 %s %s\n", cause.toString(), task.getUrl()));
                            emitter.onNext(new File(""));
                            emitter.onComplete();
                            return;
                        }
                        File file = task.getFile();
                        MainActivity.appendAndScrollLog(String.format("資源文件下載完成 %s\n", file.getAbsolutePath()));
                        emitter.onNext(file);
                        emitter.onComplete();
                    }
                });
            }
        }).retry();
    }

    /**
     * 從中控下載文件到本地
     * @param url
     * @param saveFile  保存到本地的文件
     * @return
     */
    public static Observable<File> getDownLoadFile(String url, File saveFile){
        return getDownLoadFile(url,saveFile.getParentFile().getAbsolutePath(),saveFile.getName());
    }
}

屏蔽下拉菜單和底部導航欄

像娃娃機和格子機這些設備都是在線下直接面向用戶的，因此我們不能將我們的 Android 設備全部都展現給我們的用戶，我們需要對用戶的行爲做些限制，例如禁止用戶通過導航欄或者下拉菜單退出當前程序，防止他們做出一些危險的操作。我的解決方案是把當前的 rocket 程序設置爲默認啓動和桌面應用程序，並將 Android 設備中自帶的 launcher 程序和 systemui 程序給禁用掉，那麼設備一開始啓動的時候就會啓動我們的 rocket 應用，併成功的禁止了用戶使用導航欄和下拉菜單來做非法的操作。

查找 Android 設備中自帶的 launcher 程序和 systemui 程序的對應包名
- 我們使用 adb shell pm list packages 就可以找出設備中已經安裝的程序列表，主要是以包名顯示的。
- 查找 launcher 程序的包名，找出包名爲：com.android.launcher3
```
LW-PC0920@lw1002022 MINGW64 ~/Desktop
$ adb shell pm list packages | grep launcher
package:com.android.launcher3
```
- 查找 systemui 程序的包名：找出包名爲：com.android.systemui
```
LW-PC0920@lw1002022 MINGW64 ~/Desktop
$ adb shell pm list packages | grep systemui
package:com.android.systemui
```
禁止 Android 設備中自帶的 launcher 程序和 systemui 程序的使用
- 禁止 launcher 程序的使用
```
adb shell pm disable com.android.launcher3
```

- 禁止 systemui 程序的使用
```
adb shell pm disable com.android.systemui
```

代碼實現禁止 Android 設備中自帶的 launcher 程序和 systemui 程序的使用

    public static void enableLauncher(Boolean enabled) {
        List<PackageInfo> piList = MainActivity.instance.packageManager.getInstalledPackages(0);
        ArrayList<String> packages = new ArrayList();
        for (PackageInfo pi : piList) {
            String name = pi.packageName;
            if (name.contains("systemui") || name.contains("launcher")) {
                packages.add(name);
            }
        }
        for (String packageName : packages) {
            su(String.format("pm %s %s\n", enabled ? "enable" : "disable", packageName));
        }
    }
    
    /**
     *  執行 adb 指令
     *
     */
    public static int su(String cmd) {
        try {
            Process p = Runtime.getRuntime().exec("su");
            DataOutputStream os = new DataOutputStream(p.getOutputStream());
            os.writeBytes(cmd);
            os.writeBytes("exit\n");
            os.flush();
            os.close();
            return p.waitFor();
        } catch (Exception ex) {
            return -1;
        }
    }

Iot 的實現

關於 IoT 的實現，我們這邊使用的是阿里的《微消息隊列 for IoT》服務，關於《微消息隊列 for IoT》服務，阿里的解釋如下：

微消息隊列 for IoT 是消息隊列（MQ）的子產品。針對用戶在移動互聯網以及物聯網領域的存在的特殊消息傳輸需求，消息隊列（MQ）通過推出微消息隊列 for IoT 開放了對 MQTT 協議的完整支持

MQTT 協議？
- MQTT 的全稱是：Message Queuing Telemetry Transport（消息隊列遙測傳輸），是一種輕量的，基於發佈訂閱模型的即時通訊協議。該協議設計開放，協議簡單，平臺支持豐富，幾乎可以把所有聯網物品和外部連接起來，因此在移動互聯網和物聯網領域擁有衆多優勢。
MQTT 的特點
- 使用發佈/訂閱（Pub/Sub）消息模式，提供一對多的消息分發，解除了應用程序之間的耦合；
- 對負載內容屏蔽的消息傳輸；
- 使用 TCP/IP 提供基礎的網絡連接；
- 有三種級別的消息傳遞服務；
- 小型傳輸，開銷很小（頭部長度固定爲 2 字節），協議交換最小化，以降低網絡流量。

關鍵名詞的解釋

名詞	解釋
Parent Topic	MQTT 協議基於 Pub/Sub 模型，因此任何消息都屬於一個 Topic。根據 MQTT 協議，Topic 存在多級，定義第一級 Topic 爲父 Topic（Parent Topic），使用 MQTT 前，該 Parent Topic 需要先在 MQ 控制檯創建。
Subtopic	MQTT 的二級 Topic，甚至三級 Topic 都是父 Topic 下的子類。使用時，直接在代碼裏設置，無需創建。需要注意的是 MQTT 限制 Parent Topic 和 Subtopic 的總長度爲64個字符，如果超出長度限制將會導致客戶端異常。
Client ID	MQTT 的 Client ID 是每個客戶端的唯一標識，要求全局唯一，使用相同的 Client ID 連接 MQTT 服務會被拒絕

Android 中實現 iot

關於顯示 iot 連接的實現過程是這樣的：首先我們將設備的三元組從管理後臺中批量生成，文件名的格式爲 deviceName.json(例如：00001.json)，裏面是關於每個設備的三元組信息；接着我們將裝有三元組文件的 U 盤插入到 Android 設備中（娃娃機或者口紅挑戰）；rocket 程序會自動監測到 U 盤的插入並將文件剪切到 Android 設備的制定目錄下；再接着 Android 設備可以去讀取指定文件中三元組信息；最後使用此三元組進行連接 mqtt。

添加依賴

    implementation 'org.eclipse.paho:org.eclipse.paho.client.mqttv3:1.2.0'

關於三元組
- 在 Android 設備中需要關心的三個東西，mqtt 協議中用來識別一個設備的必要三要素，如果存在相同的三元組，那麼必然出錯，導致mqtt 頻繁斷開重連。三元組這個主要是在阿里的管理後臺生成的，Android 設備這端只需要拿來用就可以了。

屬性|用處
--|--
productKey|對應程序的 key，類似於 appid
deviceName|對應上述的 Client ID，用來唯一識別一臺 Android 設備的
deviceSecret|使用 HmacSHA1 算法計算簽名字符串，並將簽名字符串設置到 Password 參數中用於鑑權

關於訂閱的 topic
- 關於 topic 是在阿里雲的後臺管理中進行設置的，我們的收發消息都是通過這些 topic 來進行的。

代碼實現 iot 連接

剪切三元組配置文件


/**
 * 剪切配置文件（三元組）
 * @param packageName
 */
public static void moveConfig(String packageName) {
    File usbConfigDir = new File(UsbStorage.usbPath, Config.wejoyConfigDirInUsb);
    File extProjectDir = new File(Environment.getExternalStorageDirectory(), Config.resourceDirName);
    File extConfigFile = new File(extProjectDir, Config.wejoyConfigFileInSdcard);
    if (!usbConfigDir.exists() || extConfigFile.exists()) {
        return;
    }
    extProjectDir.mkdirs();
    File[] configFiles = usbConfigDir.listFiles();
    if (configFiles.length > 0) {
        Arrays.sort(configFiles);
        moveFile(configFiles[0], extConfigFile);
    }
}

public static void moveFile(File src, File dst) {
    su(String.format("mv -f %s %s\n", src.getAbsolutePath(), dst.getAbsolutePath()));
}

讀取指定路徑的配置文件信息(三元組）

public static File configFile = new File(new File(Environment.getExternalStorageDirectory(), "WejoyRes"), "Config.json");

static void read() throws IOException {
    if (configFile.exists()) {
        RandomAccessFile in = new RandomAccessFile(configFile, "r");
        byte[] buf = new byte[(int) configFile.length()];
        in.read(buf);
        in.close();
        instance = JsonIterator.deserialize(new String(buf, "utf-8"), Config.class);
    } else {
        instance = new Config();
    }
    mqttRequestTopic = String.format("/sys/%s/%s/rrpc/request/", instance.productKey, instance.deviceName);
    mqttResponseTopic = String.format("/sys/%s/%s/rrpc/response/", instance.productKey, instance.deviceName);
    mqttPublishTopic = String.format("/%s/%s/update", instance.productKey, instance.deviceName);
}

- **連接 mqtt**

```

static void init() {
    instance = new IoT();
    DeviceInfo deviceInfo = new DeviceInfo();
    deviceInfo.productKey = Config.instance.productKey;
    deviceInfo.deviceName = Config.instance.deviceName;
    deviceInfo.deviceSecret = Config.instance.deviceSecret;
    final LinkKitInitParams params = new LinkKitInitParams();
    params.deviceInfo = deviceInfo;
    params.connectConfig = new IoTApiClientConfig();
    LinkKit.getInstance().registerOnPushListener(instance);
    initDisposable = Observable.interval(0, Config.instance.mqttConnectIntervalSeconds, TimeUnit.SECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(Schedulers.io())
            .map(new Function<Long, Boolean>() {
                @Override
                public Boolean apply(Long aLong) throws Exception {
                    if (!initialized) {
                        LinkKit.getInstance().init(MainActivity.instance, params, instance);
                    }
                    return initialized;
                }
            })
            .subscribe(new Consumer<Boolean>() {
                @Override
                public void accept(Boolean aBoolean) throws Exception {
                    if (aBoolean) {
                        initDisposable.dispose();
                    }
                }
            });
}
```

- **發送消息：**
發送消息的時候，我們需要指定 topic，否則服務器無法接收到我們的消息。
```
    static void publish(String json) {
    Log.e(TAG, "publish: "+json );
    MqttPublishRequest res = new MqttPublishRequest();
    res.isRPC = false;
    res.topic = Config.mqttPublishTopic;
    res.payloadObj = json;
    LinkKit.getInstance().publish(res, new IConnectSendListener() {
        @Override
        public void onResponse(ARequest aRequest, AResponse aResponse) {
        }

        @Override
        public void onFailure(ARequest aRequest, AError aError) {
        }
    });
}
```

- **接收消息：** 接收消息的時候，我們也需要判斷是來自哪個 topic 中的，除了我們指定的 topic，其他的 topic 我們都不做處理；當我們接收到服務器中發送來的消息的時候，我們是先判斷消息的類型，然後根據相對應的類型做出不同的反應。例如我們收到後臺請求給娃娃機的上分的指令，那麼我們就向設備中的硬件模塊發送上分的指令，並等待設備反應並給後臺發送一條響應信息。這條響應的消息是需要在指定的時間內完成，否則認爲超時。

```

@Override
public void onNotify(String s, final String topic, final AMessage aMessage) {
    if (!topic.startsWith(Config.mqttRequestTopic)) {
        return;
    }
    Observable.create(new ObservableOnSubscribe<MqttMessage>() {
        @Override
        public void subscribe(ObservableEmitter<MqttMessage> emitter) throws Exception {
            MqttMessage msg = JsonIterator.deserialize(new String((byte[]) aMessage.data, "utf-8"), MqttMessage.class);
            if (msg == null) {
                return;
            }
            emitter.onNext(msg);
            emitter.onComplete();
        }
    })
            .subscribeOn(Schedulers.io())
            .observeOn(Schedulers.io())
            .flatMap(new Function<MqttMessage, ObservableSource<MqttMessage>>() {
                @Override
                public ObservableSource<MqttMessage> apply(MqttMessage msg) throws Exception {
                    Log.e(TAG, "收到消息  key:"+msg.key+" msg:"+msg.body.m);
                    switch (msg.key) {
                        case "h": {//
                            SetHeartBeatDownstream setHeartBeatDownstream = msg.body.m.as(SetHeartBeatDownstream.class);
                            // 和設備進行通信，並等待設備的響應
                            return Device.setHeartBeat(setHeartBeatDownstream);
                        }
                        case "b": {//
                            AddCoinsDownstream addCoinsDownstream = msg.body.m.as(AddCoinsDownstream.class);
                            // 和設備進行通信，並等待設備的響應
                            return Device.addCoins(addCoinsDownstream);
                        }
                        case "g": {//
                            // 和設備進行通信，並等待設備的響應
                            return Device.getParam();
                        }
                        case "s": {//
                            SetParamDownstream setParamDownstream = msg.body.m.as(SetParamDownstream.class);
                            // 和設備進行通信，並等待設備的響應
                            return Device.setParam(setParamDownstream);
                        }
                    }
                    return Observable.never();
                }
            })
            .observeOn(Schedulers.io())
            .map(new Function<MqttMessage, Boolean>() {
                @Override
                public Boolean apply(MqttMessage msg) throws Exception {
                    MqttPublishRequest res = new MqttPublishRequest();
                    res.isRPC = false;
                    res.topic = topic.replace("request", "response");
                    //res.msgId = topic.split("/")[6];
                    res.payloadObj = JsonStream.serialize(msg);
                    LinkKit.getInstance().publish(res, new IConnectSendListener() {
                        @Override
                        public void onResponse(ARequest aRequest, AResponse aResponse) {
                        }

                        @Override
                        public void onFailure(ARequest aRequest, AError aError) {
                        }
                    });
                    return true;
                }
            })
            .subscribe();
}
```

Android 和硬件通信

在娃娃機和口紅挑戰的這兩個設備中，我們都需要和設備進行通信，例如：娃娃機投幣、娃娃機出禮反饋、按下選中口紅的格子等等這些都是需要和硬件模塊進行通信的。在關於串口通信的框架選擇方面，我們主要是選擇 Google 的 android-serialport-api 來實現。項目原地址

依賴方式

在根build.gradle中添加

allprojects {
    repositories {
        ...
        maven { url 'https://jitpack.io' }
    }
}

子module添加依賴

dependencies {
    implementation 'com.github.licheedev.Android-SerialPort-API:serialport:1.0.1'
}

修改su路徑

// su默認路徑爲 "/system/bin/su"
// 可通過此方法修改
SerialPort.setSuPath("/system/xbin/su");

連接方式

連接串口的時候需要指定串口號以及波特率，之後定時處理機器發送的指令。

    static void init() throws IOException {
        SerialPort.setSuPath("/system/xbin/su");
        // 設置串口號及波特率
        serialPort = new SerialPort(Config.serialPort, Config.baudrate);
        // 接收指令流
        inputStream = serialPort.getInputStream();
        // 發送指令流
        outputStream = serialPort.getOutputStream();
        // 每隔 100ms 處理機器信息
        Observable.interval(100, TimeUnit.MILLISECONDS)
                .observeOn(serialScheduler)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        // 處理機器發送的指令
                        handleRecv();
                    }
                });
    }

向機器發送指令

向機器發送指令的時候是結合 Rxjava 來實現的。除此之外，向機器發送指令是需要有規定格式的（內部制定的通信協議），我們發送及接收數據都是一個字節數組，因此我們格式是需要嚴格按照我們制定的協議進行的，如下是娃娃機投幣的簡單示例：

    static ObservableSource<MqttMessage> addCoins(final AddCoinsDownstream msg) {
        return Observable.create(new ObservableOnSubscribe<MqttMessage>() {
            @Override
            public void subscribe(ObservableEmitter<MqttMessage> emitter) throws Exception {
                currentUser = msg.u;
                currentHeadUrl = msg.h;
                currentNickname = msg.nk;
                byte[] buf = new byte[]{0x11, addCoinsCmd, msg.num, msg.c, 0, 0x00, 0x00};
                byte[] ret = sign(buf);
                try {
                    outputStream.write(ret);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                penddingCmd = addCoinsCmd;
                penddingEmitter = emitter;
            }
        })
                .subscribeOn(serialScheduler);
    }

接收機器指令

關於接受機器消息這一塊是每隔 100ms 進行的，在處理機器指令的時候，首先需要過濾到無效的字節，之後再按照我們制定的協議來處理消息，判斷是娃娃機上分，還是遊戲結果等信息，最後並對機器的數據返回進行 CRC16 校驗。


    static void handleRecv() {
        try {
            for (; ; ) {
                int len = inputStream.available();
                if (len <= 0) {
                    break;
                }
                len = inputStream.read(buf, bufReadOffset, buf.length - bufReadOffset);
                //Log.d("serialPort", String.format("read: %s", byteToHex(buf, bufReadOffset, len)));
                bufReadOffset += len;
                for (; ; ) {
                    if (bufParseEnd == -1) {
                        for (; bufParseStart < bufReadOffset; bufParseStart++) {
                            if (buf[bufParseStart] == (byte) 0xAA) {
                                bufParseEnd = bufParseStart + 1;
                                break;
                            }
                        }
                    }
                    if (bufParseEnd != -1) {
                        for (; bufParseEnd < bufReadOffset; bufParseEnd++) {
                            if (buf[bufParseEnd] == (byte) 0xAA) {
                                bufParseStart = bufParseEnd;
                                bufParseEnd += 1;
                                continue;
                            }
                            if (buf[bufParseEnd] == (byte) 0xDD) {
                                if (bufParseEnd - bufParseStart >= 5) {
                                    bufParseEnd += 1;
                                    byte size = buf[bufParseStart + 1];
                                    byte index = buf[bufParseStart + 2];
                                    byte cmd = buf[bufParseStart + 3];
                                    byte check = (byte) (size ^ index ^ cmd);
                                    for (int i = bufParseStart + 4; i < bufParseEnd - 2; i++) {
                                        check ^= buf[i];
                                    }
                                    if (check == buf[bufParseEnd - 2]) {
                                        //Log.d("serialPort", String.format("protocol: %s, size: %d, index: %d, cmd: %d, check: %d, data: %s", byteToHex(buf, bufParseStart, bufParseEnd - bufParseStart), size, index, cmd, check, byteToHex(buf, bufParseStart + 4, size - 3)));
                                        switch (cmd) {
                                            // 心跳
                                            case heartBeatCmd: {
                                            }
                                            break;
                                            
                                            // 上分
                                            case addCoinsCmd: {
                                                
                                            }
                                            break;
                                            
                                            // 遊戲結果
                                            case gameResultCmd: {
                                                boolean gift = buf[bufParseStart + 7] != 0;
                                                IoT.sendGameResult(gift);
                                                if (gift) {
                                                    // 發送用戶信息到中控，進行排行榜顯示
                                                    WSSender.getInstance().sendUserInfo(currentUser, currentHeadUrl, currentNickname);
                                                }
                                            }
                                            break;
                                            default:
                                                break;
                                        }
                                    }
                                }
                                bufParseStart = bufParseEnd;
                                bufParseEnd = -1;
                                break;
                            }
                        }
                    }
                    if (bufParseStart >= bufReadOffset || bufParseEnd >= bufReadOffset) {
                        break;
                    }
                }
                if (bufReadOffset == buf.length) {
                    System.arraycopy(buf, bufParseStart, buf, 0, bufReadOffset - bufParseStart);
                    if (bufParseEnd != -1) {
                        bufParseEnd -= bufParseStart;
                        bufReadOffset = bufParseEnd;
                    } else {
                        bufReadOffset = 0;
                    }
                    bufParseStart = 0;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

websocket 通信

在中控和娃娃機進行通信的方式我們是選擇 websocket 進行的。中控端是 server，然後娃娃機是 client。

server

Server 的實現：目前 server 的實現只是爲了接收娃娃機的數據反饋，所以並沒有什麼複雜的操作。


class WSServer extends WebSocketServer {
    private MainActivity mainActivity;

    public void setMainActivity(MainActivity mainActivity) {
        this.mainActivity = mainActivity;
    }

    WSServer(InetSocketAddress address) {
        super(address);
    }

    @Override
    public void onOpen(WebSocket conn, ClientHandshake handshake) {
        mainActivity.appendAndScrollLog("客戶端：" + conn.getRemoteSocketAddress() + " 已連接\n");
    }

    @Override
    public void onClose(WebSocket conn, int code, String reason, boolean remote) {
        mainActivity.appendAndScrollLog("客戶端：" + conn.getRemoteSocketAddress() + " 已斷開\n");
    }

    @Override
    public void onMessage(WebSocket conn, final String message) {
        Observable.create(new ObservableOnSubscribe<SocketMessage>() {
            @Override
            public void subscribe(ObservableEmitter<SocketMessage> emitter) throws Exception {
                final SocketMessage socketMessage = JsonIterator.deserialize(message, SocketMessage.class);
                emitter.onNext(socketMessage);
                emitter.onComplete();
            }
        })
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<SocketMessage>() {
                    @Override
                    public void accept(SocketMessage socketMessage) throws Exception {
                        if (socketMessage.getCode() == SocketMessage.TYPE_USER) {
                            // 夾到娃娃
                            
                        } else if (socketMessage.getCode() == SocketMessage.TYPE_SAY_HELLO) {
                            // 連接招呼語
                        }
                    }
                });


    }

    @Override
    public void onError(WebSocket conn, Exception ex) {
    }

    @Override
    public void onStart() {

    }
}

簡單使用方式

    appendAndScrollLog("初始化WebSocket服務...\n");
    WSServer wsServer = new WSServer(18104);
    wsServer.setMainActivity(MainActivity.this);
    wsServer.setConnectionLostTimeout(5);
    wsServer.setReuseAddr(true);
    wsServer.start();
    appendAndScrollLog("初始化WebSocket服務完成\n");

client

在 client 端，目前需要做的人物有斷開重連以及數據發送的操作。斷開重連的時候需要在新的子線程中進行，否則會報如下錯誤：

You cannot initialize a reconnect out of the websocket thread. Use reconnect in another thread to insure a successful cleanup

因此，我們每次斷開重新的時候是需要在新的子線程中進行的。除此之外，在發送數據的時候，如果剛好 socket 沒有連接上，那麼發送數據是會報異常的，因此我們有數據要發送的時候如果 socket 沒有連接，那麼就先緩存到本地，等到 socket 連接上之後再把滯留的數據一次性發送出去。

依賴配置

    implementation 'org.java-websocket:Java-WebSocket:1.3.9'

WSClient.java


class WSClient extends WebSocketClient {

    private static final String TAG = "WSClient";
    private static WSClient instance;
    private static URI sUri;
    private WSReceiver mWSReceiver;
    private Disposable mReconnectDisposable;
    private ConnectCallback mConnectCallback;

    /**
     * step 1:需要先調用，設置 url
     * @param uri
     */
    public static void setUri(URI uri){
        sUri = uri;
    }

    /**
     * step 1:
     * 需要先調用，設置服務端的 url
     * @param ipAddress
     * @param port
     */
    public static void setUri(String ipAddress,int port){
        try {
            sUri = new URI(String.format("ws://%s:%d", ipAddress, port));
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
    }


    public static WSClient getInstance(){
        if (instance == null) {
            synchronized (WSClient.class){
                if (instance == null) {
                    instance = new WSClient(sUri);
                }
            }
        }
        return instance;
    }

    /**
     * step 2：連接 websocket
     */
    public void onConnect(){
        setConnectionLostTimeout(Config.instance.webSocketTimeoutSeconds);
        setReuseAddr(true);
        connect();
    }

    private WSClient(URI server) {
        super(server);
        // 初始化消息發送者
        WSSender.getInstance().setWSClient(this);
        // 初始化消息接收者
        mWSReceiver = new WSReceiver();
        mWSReceiver.setWSClient(this);
        mWSReceiver.setWSSender(WSSender.getInstance());

    }


    @Override
    public void onOpen(ServerHandshake handshakedata) {
        Log.d(TAG, "onOpen: ");
        MainActivity.appendAndScrollLog("websocket 已連接\n");
        Observable.just("")
                .subscribeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Object>() {
                    @Override
                    public void accept(Object o) throws Exception {
                        if (mConnectCallback != null) {
                            mConnectCallback.onWebsocketConnected();
                        }
                    }
                });

        // 清除滯留的所有消息
        WSSender.getInstance().clearAllMessage();
        
    }

    @Override
    public void onMessage(String message) {
        Log.d(TAG, "onMessage: ");
        mWSReceiver.handlerMessage(message);
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {
        Log.d(TAG, "onClose: ");
        MainActivity.appendAndScrollLog(String.format("websocket 已斷開,斷開原因：%s\n",reason));
        Observable.just("")
                .subscribeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Object>() {
                    @Override
                    public void accept(Object o) throws Exception {
                        if (mConnectCallback != null) {
                            mConnectCallback.onWebsocketClosed();
                        }
                    }
                });
        onReconnect();
    }

    @Override
    public void onError(Exception ex) {
        if (ex != null) {
            Log.d(TAG, "onError: "+ex.getMessage());
            MainActivity.appendAndScrollLog(String.format("websocket 出現錯誤,錯誤原因：%s\n",ex.getMessage()));
        }
        onReconnect();
    }


    public void onReconnect() {
        if (mReconnectDisposable != null
                && !mReconnectDisposable.isDisposed()){
            return;
        }
        mReconnectDisposable = Observable.timer(1, TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d(TAG, "websocket reconnect");
                        WSClient.this.reconnect();
                        mReconnectDisposable.dispose();
                    }
                });

    }

    public void setConnectCallback(ConnectCallback mConnectCallback) {
        this.mConnectCallback = mConnectCallback;
    }

    public interface ConnectCallback{
        void onWebsocketConnected();
        void onWebsocketClosed();
    }
}

WSSender.java


/**
 * Created by runla on 2018/10/26.
 * 文件描述：Websocket 的消息發送者
 */

public class WSSender {
    private static final String TAG = "WSSender";
    public static final int MAX_MESSAGE_COUNT = 128;
    private static WSSender instance;
    private WSClient mWSClientManager;
    // 消息隊列
    private LinkedList<String> mMessageList = new LinkedList<>();

    private WSSender() {
    }

    public static WSSender getInstance() {
        if (instance == null) {
            synchronized (WSSender.class) {
                if (instance == null) {
                    instance = new WSSender();
                }
            }
        }
        return instance;
    }

    public void setWSClient(WSClient wsClientManager) {
        this.mWSClientManager = wsClientManager;
    }

    /**
     * 發送所有滯留的消息
     */
    public void clearAllMessage() {
        if (mWSClientManager == null) {
            return;
        }

        while (mMessageList.size() > 0
                && mMessageList.getFirst() != null) {
            Log.d(TAG, "sendMessage: " + mMessageList.size());
            mWSClientManager.send(mMessageList.getFirst());
            mMessageList.removeFirst();
        }
    }

    /**
     * 發送消息，如果消息發送不出去，那麼就等到連接成功後再次嘗試發送
     *
     * @param msg
     * @return
     */
    public boolean sendMessage(String msg) {
        if (mWSClientManager == null) {
            throw new NullPointerException("websocket client is null");
        }
        if (TextUtils.isEmpty(msg)) {
            return false;
        }
        // 將需要發送的數據添加到隊列的尾部
        mMessageList.addLast(msg);

        while (mMessageList.size() > 0
                && mMessageList.getFirst() != null) {
            Log.d(TAG, "sendMessage: " + mMessageList.size());
            if (!mWSClientManager.isOpen()) {
                // 嘗試重連
                mWSClientManager.onReconnect();
                break;
            } else {
                mWSClientManager.send(mMessageList.getFirst());
                mMessageList.removeFirst();
            }
        }

        // 如果消息隊列中超過我們設置的最大容量，那麼移除最先添加進去的消息
        if (mMessageList.size() >= MAX_MESSAGE_COUNT) {
            mMessageList.removeFirst();
        }
        return false;
    }
}

WSReceiver.java


/**
 * Created by runla on 2018/10/26.
 * 文件描述：Websocket 的消息接收者
 */

public class WSReceiver {
    private WSClient mWSClientManager;
    private WSSender mWSSender;
    private OnMessageCallback onMessageCallback;
    public WSReceiver() {
    }


    public void setWSClient(WSClient mWSClientManager) {
        this.mWSClientManager = mWSClientManager;
    }

    public void setWSSender(WSSender mWSSender) {
        this.mWSSender = mWSSender;
    }

    /**
     * 處理接收消息
     * @param message
     */
    public void handlerMessage(String message){

        if (onMessageCallback != null){
            onMessageCallback.onHandlerMessage(message);
        }
    }

    public void setOnMessageCallback(OnMessageCallback onMessageCallback) {
        this.onMessageCallback = onMessageCallback;
    }

    public interface OnMessageCallback{
        void onHandlerMessage(String message);
    }
}

連接調用

    appendAndScrollLog("初始化WebSocket客戶端...\n");
    WSClient.setUri( Config.instance.centralServerAddress, Config.instance.webSocketPort);
    WSClient.getInstance().onConnect();
    WSClient.getInstance().setConnectCallback(MainActivity.this);
    appendAndScrollLog("初始化WebSocket客戶端完成\n");

數據發送

// 清除滯留的所有消息
WSSender.getInstance().clearAllMessage();

// 發送消息
WSSender.getInstance().sendMessage(msg);

數據庫存儲

在中控端，我們需要顯示排行版，用來顯示夾中娃娃機的用戶在本月及本週夾中娃娃的排行，因此我們需要再中控端保存用戶的夾中娃娃數量以及個人的其他信息，GreenDAO 是一款開源的面向 Android 的輕便、快捷的 ORM 框架，將 Java 對象映射到 SQLite 數據庫中，我們操作數據庫的時候，不在需要編寫複雜的 SQL語句，在性能方面，GreenDAO 針對 Android 進行了高度優化，最小的內存開銷、依賴體積小，同時還是支持數據庫加密。關於 GreenDAO 的用法我就不在這裏做，具體的用法可以參考官網 GreenDAO。

寫在最後

關於整個系統的架構搭建過程中遇到了好多坑，以上是我爲這個項目提供的部分解決方案，當前全部的是不可能都放寫出來的，此項目目前已經在西安和成都等地都有門店點了，據反饋，利潤極大，不過這種類型的項目紅利期不會太長，估計也是 2~3 年左右吧。如果有需要我們爲 口紅機開發 或者是 娃娃機開發 提供解決方案的，可以聯繫我們，目前我們在這個方面已經有相對較爲成熟的解決方案了。

Android 抖音爆紅的口紅挑戰爬坑總結