# EasyClick请求实例讲解
EasyClick请求实例
# 概览
本文主讲EasyClick请求实例,带POST,GET 请求,开发者可自行封装模块,工具类调用,参数有详细讲解
当前方法为GET请求,json请求格式
// 这里是验签字符串
const signStr="这里是验签字符串";
// 请求地址
const potatoUrl = "https://api.potatocloud.cn/api";
// 加解密字符串
const encryptStr="你的加解密字符串";
// askKey
const askKey="你的askKey"
function get(url) {
let time=Date.now()
let header={
//您的askKey ,app令牌
'askKey': askKey,
//请求格式默认json
'Content-Type': 'application/json',
// 签,如果开启验签是必传
"sign":encrypt(signStr+time)+"",
// 当前系统时间,如果开启验签是必传
"time":time.toString(),
// 用户令牌,文档有描述是否必传
"apiUserToken":""
}
let result = http.httpGetDefault(potatoUrl+url, 10 * 1000, header);
// 解密
return AEC_DECRYPT(result,encryptStr);
}
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
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
当前方法为POST请求,json请求格式
// 这里是验签字符串
const signStr="这里是验签字符串";
// 请求地址
const potatoUrl = "https://api.potatocloud.cn/api";
// 加解密字符串
const encryptStr="你的加解密字符串";
// askKey
const askKey="你的askKey"
function post(url,param) {
let time=Date.now()
let header={
//您的askKey ,app令牌
'askKey': askKey,
//请求格式默认json
'Content-Type': 'application/json',
// 签,如果开启验签是必传
"sign":encrypt(signStr+time)+"",
// 当前系统时间,如果开启验签是必传
"time":time.toString(),
// 用户令牌,文档有描述是否必传
"apiUserToken":""
}
let result = http.postJSON(potatoUrl+url,param,10 * 1000, header);
logd(result)
// 解密,如果不需要解密可直接返回
return AEC_DECRYPT(result,encryptStr);
}
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
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
# 调用实例
调用实例GET
function 检测更新() {
logd("检测更新");
let result=get('/updateApp?version='+version)
let jsonData = JSON.parse(result);
if (jsonData.code=='200') {
if (jsonData.data.isUpdate) {
toast("正在更新.....")
if (jsonData.data.data.updateUrl) {
var downloadResult = http.downloadFile(jsonData.data.data.updateUrl, "/sdcard/release.iec", 10 * 1000, {"User-Agent": "test"});
toast("更新结果" + downloadResult);
setIECPath("/sdcard/release.iec");
toast("云更新完成......")
}
}
}else {
toast("更新检测失败:"+jsonData.message)
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
调用实例POST
function 验证卡密() {
createSystemStr()
let card=readConfigString("cardMy")
let mac=file.readLine("/sdcard/xgd/system.txt",1)
const param={
"mac":mac,
"cardStr":card
}
let result=post('/verifyCardV2',param)
let jsonData = JSON.parse(result);
if (jsonData.code=='200') {
if (jsonData.data.verify) {
toast("卡密验证成功,到期日"+jsonData.data.exTime)
updateConfig("cardMy",card)
return true
}else{
toast("卡密验证失败")
}
}else {
toast("卡密验证失败:"+jsonData.message)
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 加解密
MD5加密
// 将二进制数据转换成16进制字符串
function byteArrayToHexString(bytes) {
var val = "";
for (var i = 0; i < bytes.length; i++) {
var tmp = bytes[i];
if (tmp < 0) {
tmp = 256 + tmp;
}
tmp = tmp.toString(16);
if ((tmp + "").length == 1) {
tmp = "0" + tmp;
}
val += tmp;
}
return val;
}
function encrypt(string){
// 生成一个MD5加密计算摘要
let md = java.security.MessageDigest.getInstance("MD5");
// 计算md5函数，字符编码是 UTF-8
md.update(java.lang.String(string).getBytes("UTF-8"));
return byteArrayToHexString(md.digest());
};
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
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
AEC加密
const CIPHER_ALGORITHM="AES/ECB/PKCS5Padding";
const DEFAULT_VALUE="0";
const CHARSET_UTF8=java.nio.charset.StandardCharsets.UTF_8;
const SECRET_KEY_LENGTH=32;
const KEY_ALGORITHM = "AES";
function AEC_ENCRYPT(data,secretKey) {
try {
//创建密码器
let cipher = javax.crypto.Cipher.getInstance(CIPHER_ALGORITHM);
//初始化为加密密码器
cipher.init(javax.crypto.Cipher.ENCRYPT_MODE, getSecretKey(secretKey));
let encryptByte = cipher.doFinal(stringToByte(data));
// 将加密以后的数据进行 Base64 编码
return base64Encode(encryptByte);
} catch (e) {
toast("数据解密失败")
}
return null;
}
function AEC_DECRYPT(base64Data,secretKey) {
try {
let data = base64Decode(base64Data);
let cipher = javax.crypto.Cipher.getInstance(CIPHER_ALGORITHM);
//设置为解密模式
cipher.init(javax.crypto.Cipher.DECRYPT_MODE, getSecretKey(secretKey));
//执行解密操作
let result = cipher.doFinal(data);
//let str=Uint8ArrayToString(result);
let str=new java.lang.String(result,CHARSET_UTF8);
return str;
} catch (e) {
toast("数据解密失败")
}
return null;
}
/**
* 将 Base64 字符串 解码成 字节数组
*/
function base64Decode(data) {
return android.util.Base64.decode(data, android.util.Base64.NO_WRAP);
}
/**
* 将 字节数组 转换成 Base64 编码
*/
function base64Encode(data) {
return android.util.Base64.encodeToString(data, android.util.Base64.NO_WRAP);
}
function getSecretKey(secretKey) {
secretKey = toMakeKey(secretKey, SECRET_KEY_LENGTH, DEFAULT_VALUE);
let dto=new javax.crypto.spec.SecretKeySpec(secretKey.getBytes("UTF-8"), KEY_ALGORITHM)
return dto;
}
function toMakeKey(secretKey,length,text) {
// 获取密钥长度
let strLen = secretKey.length;
// 判断长度是否小于应有的长度
if (strLen < length) {
// 补全位数
let builder = new java.lang.StringBuilder();
// 将key添加至builder中
builder.append(secretKey);
// 遍历添加默认文本
for (let i = 0; i < length - strLen; i++) {
builder.append(text);
}
// 赋值
secretKey = builder.toString();
}
return secretKey;
}
// 字符串转数组
function stringToByte(str) {
let len, c;
len = str.length;
let bytes = [];
for(let i = 0; i < len; i++) {
c = str.charCodeAt(i);
if(c >= 0x010000 && c <= 0x10FFFF) {
bytes.push(((c >> 18) & 0x07) | 0xF0);
bytes.push(((c >> 12) & 0x3F) | 0x80);
bytes.push(((c >> 6) & 0x3F) | 0x80);
bytes.push((c & 0x3F) | 0x80);
} else if(c >= 0x000800 && c <= 0x00FFFF) {
bytes.push(((c >> 12) & 0x0F) | 0xE0);
bytes.push(((c >> 6) & 0x3F) | 0x80);
bytes.push((c & 0x3F) | 0x80);
} else if(c >= 0x000080 && c <= 0x0007FF) {
bytes.push(((c >> 6) & 0x1F) | 0xC0);
bytes.push((c & 0x3F) | 0x80);
} else {
bytes.push(c & 0xFF);
}
}
return bytes;
}
function Uint8ArrayToString(fileData){
let dataString = "";
for (let i = 0; i < fileData.length; i++) {
dataString += String.fromCharCode(fileData[i]);
}
return dataString
}
function byteToString(arr) {
if(typeof arr === 'string') {
return arr;
}
let str = '',
_arr = arr;
for(let i = 0; i < _arr.length; i++) {
let one = _arr[i].toString(2),
v = one.match(/^1+?(?=0)/);
if(v && one.length == 8) {
let bytesLength = v[0].length;
let store = _arr[i].toString(2).slice(7 - bytesLength);
for(let st = 1; st < bytesLength; st++) {
store += _arr[st + i].toString(2).slice(2);
}
str += String.fromCharCode(parseInt(store, 2));
i += bytesLength - 1;
} else {
str += String.fromCharCode(_arr[i]);
}
}
return str;
}
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
124
125
126
127
128
129
130
131
132
133
134
135
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
124
125
126
127
128
129
130
131
132
133
134
135
Base64加密
/**
* 将 字节数组 转换成 Base64 编码
*/
function base64Encode(data) {
return Base64.encodeToString(data, Base64.NO_WRAP);
}
1
2
3
4
5
6
7
2
3
4
5
6
7
Base64解密
/**
* 将 Base64 字符串 解码成 字节数组
*/
function base64Decode(data) {
return Base64.decode(data, Base64.NO_WRAP);
}
1
2
3
4
5
6
2
3
4
5
6