atx-agent minicap、minitouch源碼分析

項目描述:

　　因為公司需要,特別研究了一下openatx系列手機群控源碼

　　源碼地址: https://github.com/openatx

　　該項目主要以go語言來編寫服務端、集成 OpenSTF中核心組件 minicap和minitouch來完成

 

今天主要來分析一下atx-agent服務源碼中 minicap和minitouch 相關接口源碼

 

1.minicap

　　簡介:　　　

　　minicap工具是用NDK開發的，屬於Android的底層開發，該工具分為兩個部分，一個是動態連接庫.so文件，一個是minicap可執行文件。但不是通用的，
因為CPU架構的不同分為不同的版本文件，STF提供的minicap文件根據CPU 的ABI分為如下4種：從上面可以看出，minicap可執行文件分為4種，
分別針對arm64-v8a、armeabi-v7a,x86,x86_64 架構。而minicap.so文件在這個基礎上還要分為不同的sdk版本。
　　minicap采集屏幕的原理很簡單：通過ndk的截屏接口不停的截屏並通過socket接口實時發送，這樣客戶端便可以得到一序列的圖片流，圖片流合成后就成為視頻。
　　使用原生screencap工具截屏並輸出到圖像需要4s多，對比minicap則只需要190ms，差距明顯。minicap使用了libjpeg-turbo作為編碼壓縮工具，
壓縮后的圖片體積更小1080P分辨率的手機截圖根據色彩豐富度不同一般只需要100k，sceencap則需要2M。

atx-agent minicap部分

m.HandleFunc("/minicap", singleFightNewerWebsocket(func(w http.ResponseWriter, r *http.Request, ws *websocket.Conn) {
        defer ws.Close()

        const wsWriteWait = 10 * time.Second
        wsWrite := func(messageType int, data []byte) error {
            //設置websocket寫入最長超時間
            ws.SetWriteDeadline(time.Now().Add(wsWriteWait))
            return ws.WriteMessage(messageType, data)
        }
        wsWrite(websocket.TextMessage, []byte("restart @minicap service"))
        //重啟minicap
        if err := service.Restart("minicap"); err != nil && err != cmdctrl.ErrAlreadyRunning {
            wsWrite(websocket.TextMessage, []byte("@minicap service start failed: "+err.Error()))
            return
        }

        wsWrite(websocket.TextMessage, []byte("dial unix:@minicap"))
        log.Printf("minicap connection: %v", r.RemoteAddr)
        dataC := make(chan []byte, 10)
        quitC := make(chan bool, 2)

        go func() {
            defer close(dataC)
            retries := 0
            for {
                if retries > 10 {
                    log.Println("unix @minicap connect failed")
                    dataC <- []byte("@minicap listen timeout, possibly minicap not installed")
                    break
                }
                conn, err := net.Dial("unix", "@minicap")
                if err != nil {
                    retries++
                    log.Printf("dial @minicap err: %v, wait 0.5s", err)
                    select {
                    case <-quitC:
                        return
                    case <-time.After(500 * time.Millisecond):
                    }
                    continue
                }
                dataC <- []byte("rotation " + strconv.Itoa(deviceRotation))
                retries = 0 // connected, reset retries
                if er := translateMinicap(conn, dataC, quitC); er == nil {
                    conn.Close()
                    log.Println("transfer closed")
                    break
                } else {
                    conn.Close()
                    log.Println("minicap read error, try to read again")
                }
            }
        }()
        go func() {
            for {
                if _, _, err := ws.ReadMessage(); err != nil {
                    quitC <- true
                    break
                }
            }
        }()
        var num int = 0
        //遍歷管道循環發送數據
        for data := range dataC {
            //丟棄一半的數據包降低幀率
            if string(data[:2]) == "\xff\xd8" { // jpeg data
                if num %2 == 0{
                    num ++
                    continue
                }
                if err := wsWrite(websocket.BinaryMessage, data); err != nil {
                    break
                }
                if err := wsWrite(websocket.TextMessage, []byte("data size: "+strconv.Itoa(len(data)))); err != nil {
                    break
                }
            } else {
                if err := wsWrite(websocket.TextMessage, data); err != nil {
                    break
                }
            }
        }
        quitC <- true
        log.Println("stream finished")
    })).Methods("GET")

　　大致邏輯是當有客戶端和agent的minicap接口建立websocket連接后會先開啟一個goroutine來和minicap進行通信，並將minicap返回的數據存放到dataC中，然后for循環遍歷該管道取出

所有數據，如果是圖片格式 直接通過websocket傳輸到客戶端進行展示

流量優化:

　　1.幀率優化

                if num %2 == 0{
                    num ++
                    continue
                }

　　考慮到網絡流量造成的帶寬問題 在這里做了一些小小優化 對minicap返回的圖片丟棄一半來達到優化效果

　　2.圖片質量優化

    //降低圖片畫質
    service.Add("minicap", cmdctrl.CommandInfo{
        Environ: []string{"LD_LIBRARY_PATH=/data/local/tmp"},
        Args: []string{"/data/local/tmp/minicap", "-S", "-P",
            fmt.Sprintf("%dx%d@%dx%d/0", width, height, displayMaxWidthHeight, displayMaxWidthHeight),
        "-Q", "50"},
    })

 

　　在atx-agent項目源碼main.go中 有啟動minicap的腳本命令  其中-Q 為圖片質量范圍在(0-100)之間 詳細解釋在minicap源碼中 我在這里設置為50 大概傳輸200張圖片在4M，從而緩解網絡占用問題 參考文章(https://www.jianshu.com/p/5b5fef0241af)

 

 

2.minitouch

　　簡介:

　　跟minicap一樣，minitouch也是用NDK開發的，跟minicap使用方法類似，不過它只要上傳一個minitouch文件就可以了。對應的文件路徑樹跟minicap一樣就不重復
介紹(不過它只需要對應不同的CPU的ABI，而不需要對應SDK版本)。實際測試這個觸摸操作和minicap一樣，實時性很高沒什么卡頓。

atx-agent minitouch部分

m.HandleFunc("/minitouch", singleFightNewerWebsocket(func(w http.ResponseWriter, r *http.Request, ws *websocket.Conn) {
        defer ws.Close()
        const wsWriteWait = 10 * time.Second
        wsWrite := func(messageType int, data []byte) error {
            ws.SetWriteDeadline(time.Now().Add(wsWriteWait))
            return ws.WriteMessage(messageType, data)
        }
        wsWrite(websocket.TextMessage, []byte("start @minitouch service"))
        if err := service.Start("minitouch"); err != nil && err != cmdctrl.ErrAlreadyRunning {
            wsWrite(websocket.TextMessage, []byte("@minitouch service start failed: "+err.Error()))
            return
        }
        wsWrite(websocket.TextMessage, []byte("dial unix:@minitouch"))
        log.Printf("minitouch connection: %v", r.RemoteAddr)
        retries := 0
        quitC := make(chan bool, 2)
        operC := make(chan TouchRequest, 10)
        defer func() {
            wsWrite(websocket.TextMessage, []byte("unix:@minitouch websocket closed"))
            close(operC)
        }()
        go func() {
            for {
                if retries > 10 {
                    log.Println("unix @minitouch connect failed")
                    wsWrite(websocket.TextMessage, []byte("@minitouch listen timeout, possibly minitouch not installed"))
                    ws.Close()
                    break
                }
                conn, err := net.Dial("unix", "@minitouch")
                if err != nil {
                    retries++
                    log.Printf("dial @minitouch error: %v, wait 0.5s", err)
                    select {
                    case <-quitC:
                        return
                    case <-time.After(500 * time.Millisecond):
                    }
                    continue
                }
                log.Println("unix @minitouch connected, accepting requests")
                retries = 0 // connected, reset retries
                err = drainTouchRequests(conn, operC)
                conn.Close()
                if err != nil {
                    log.Println("drain touch requests err:", err)
                } else {
                    log.Println("unix @minitouch disconnected")
                    break // operC closed
                }
            }
        }()
        var touchRequest TouchRequest
        //輪詢
        for {
            err := ws.ReadJSON(&touchRequest)
            if err != nil {
                log.Println("readJson err:", err)
                quitC <- true
                break
            }
            select {
            case operC <- touchRequest:
            //兩秒鍾
            case <-time.After(2 * time.Second):
                wsWrite(websocket.TextMessage, []byte("touch request buffer full"))
            }
        }
    })).Methods("GET")

func drainTouchRequests(conn net.Conn, reqC chan TouchRequest) error {
    var maxX, maxY int
    var flag string
    var ver int
    var maxContacts, maxPressure int
    var pid int

    lineRd := lineFormatReader{bufrd: bufio.NewReader(conn)}
    lineRd.Scanf("%s %d", &flag, &ver)
    lineRd.Scanf("%s %d %d %d %d", &flag, &maxContacts, &maxX, &maxY, &maxPressure)
    if err := lineRd.Scanf("%s %d", &flag, &pid); err != nil {
        return err
    }

    log.Debugf("handle touch requests maxX:%d maxY:%d maxPressure:%d maxContacts:%d", maxX, maxY, maxPressure, maxContacts)
    go io.Copy(ioutil.Discard, conn) // ignore the rest output
    var posX, posY int
    for req := range reqC {
        var err error
        switch req.Operation {
        case "r": // reset
            _, err = conn.Write([]byte("r\n"))
        case "d":
            fallthrough
        case "m":
            //計算點擊位置   req.PercentX 前端傳過來的值 乘 最大x值
            posX = int(req.PercentX * float64(maxX))
            posY = int(req.PercentY * float64(maxY))
            pressure := int(req.Pressure * float64(maxPressure))
            if pressure == 0 {
                pressure = maxPressure - 1
            }
            line := fmt.Sprintf("%s %d %d %d %d\n", req.Operation, req.Index, posX, posY, pressure)
            log.Debugf("write to @minitouch %v", line)
            _, err = conn.Write([]byte(line))
        case "u":
            _, err = conn.Write([]byte(fmt.Sprintf("u %d\n", req.Index)))
        case "c":
            _, err = conn.Write([]byte("c\n"))
        case "w":
            _, err = conn.Write([]byte(fmt.Sprintf("w %d\n", req.Milliseconds)))
        default:
            err = errors.New("unsupported operation: " + req.Operation)
        }
        if err != nil {
            return err
        }
    }
    return nil
}

大致邏輯為接收客戶端發送過來的json數據並將數據存儲到operC管道中, 開啟一個goroutine來和minitouch建立連接並根據不同的類型來執行不同的操作