'f'

mh-two-thousand-and-two

2024-04-12 26f2711ef9461961fb953e2b497bd314ef95e345

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
"use strict";
const adb_driver_1 = require("adb-driver");
class ADBCommander {
    async _commandFactory(command) {
        const cmdResult = await adb_driver_1.execADBCommand(command);
        const isError = cmdResult instanceof Error || (cmdResult.stack && cmdResult.message);
        if (isError) {
            return { err: cmdResult };
        }
        else {
            return { result: cmdResult };
        }
    }
    async deviceList() {
        const { result, err } = await this._commandFactory(`adb devices`);
        return {
            deviceList: _parseDeviceInfo(result),
            err,
        };
        function _parseDeviceInfo(stdout) {
            if (!stdout) {
                return [];
            }
            const lines = stdout.replace(/(\n|\r\n){1,}/g, '\n').split('\n');
            const result = lines
                .filter((item, idx) => {
                const oneDevice = item.split('\t');
                return idx !== 0 && oneDevice[1] === 'device';
            })
                .map(item => {
                return item.split('\t')[0];
            });
            return result;
        }
    }
    async reverse(deviceSN, localPort, remotePort) {
        const cmd = `adb -s ${deviceSN} reverse tcp:${remotePort} tcp:${localPort}`;
        return await this._commandFactory(cmd);
    }
    async forward(deviceSN, localPort, remotePort) {
        const cmd = `adb -s ${deviceSN} forward tcp:${localPort} tcp:${remotePort}`;
        return await this._commandFactory(cmd);
    }
    async version() {
        const { result, err } = await this._commandFactory(`adb version`);
        return { version: result, err };
    }
    async print(cmd) {
        const { err } = await this._commandFactory(cmd);
        if (err) {
            console.error(`### App Server ### print(): adb error: ${err.message}`);
        }
    }
    async uninstall(deviceSN, pkg) {
        const { result, err } = await this._commandFactory(`adb -s ${deviceSN} uninstall ${pkg}`);
        return { result, err };
    }
    async install(deviceSN, apkPath) {
        const { result, err } = await this._commandFactory(`adb -s ${deviceSN} install ${apkPath}`);
        return { result, err };
    }
    async isInstalled(deviceSN, pkg) {
        const { result, err } = await this._commandFactory(`adb -s ${deviceSN} shell pm path ${pkg}`);
        let isInstalled = false;
        if (result && result.indexOf('package:') > -1) {
            isInstalled = true;
        }
        return { isInstalled, err };
    }
    async startActivity(deviceSN, action, component, extra) {
        let commandArray = [];
        commandArray.push('adb', '-s', deviceSN, 'shell', 'am', 'start');
        if (action !== undefined) {
            commandArray.push('-a', action);
        }
        if (component !== undefined) {
            commandArray.push('-n', component);
        }
        function parseExtra(extra) {
            const typeMap = {
                string: '--es',
                null: '--esn',
                boolean: '--ez',
                int: '--ei',
                float: '--ef',
                uri: '--eu',
                component: '--ecn',
                'String[]': '--esa',
                'int[]': '--eia',
                'long[]': '--ela',
                'float[]': '--efa',
            };
            let extraCommands = [];
            extra.forEach(item => {
                if (item.type in typeMap) {
                    extraCommands.push(typeMap[item.type]);
                    extraCommands.push(item.key);
                    if (item.type.endsWith('[]')) {
                        extraCommands.push(item.value.join(','));
                    }
                    else {
                        extraCommands.push(item.value);
                    }
                }
            });
            return extraCommands;
        }
        if (extra) {
            commandArray.push(parseExtra(extra).join(' '));
        }
        const { result, err } = await this._commandFactory(commandArray.join(' '));
        return { result, err };
    }
    async exeCommand(command) {
        return await this._commandFactory(command);
    }
    async getProp(deviceSN) {
        const { result, err } = await this._commandFactory(`adb -s ${deviceSN} shell getprop ro.serialno`);
        return { result, err };
    }
}
const adbCommander = new ADBCommander();
module.exports = adbCommander;