├── README.md
├── TTXS_Pro
    ├── 1
    ├── TTXS_CODDE
    │   ├── READ
    │   ├── V10.1(有弹窗).js
    │   ├── V10.11.js
    │   ├── V10.8.js
    │   └── V9.0(有弹窗).js
    ├── dati_tiku_json.txt
    ├── info.json
    └── tiku_json.txt
├── main.js
├── project.json
└── xxqg.js


/README.md:
--------------------------------------------------------------------------------
 1 | # AUTO-XXQG-FIXED
 2 | # 适用于安卓手机，鸿蒙系统，不适用ios
 3 | # 基于better修改，仅用于学习，禁止商业。
 4 | # 每天61分，支持多账户
 5 | # 支持微信公众号推送
 6 | # 基于autox.js v6  打包
 7 | # 强国助手_V1.0.4 已更新 下载 
 8 | # https://wwi.lanzoup.com/i2dMs0dyq5yd
 9 | # 提供学习强国对应版本，去强制更新，去滑块验证，仅在Q群提供下载
10 | # 更新三人行答题
11 | 


--------------------------------------------------------------------------------
/TTXS_Pro/1:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/TTXS_Pro/TTXS_CODDE/READ:
--------------------------------------------------------------------------------
1 | 源码保存
2 | 


--------------------------------------------------------------------------------
/TTXS_Pro/TTXS_CODDE/V10.1(有弹窗).js:
--------------------------------------------------------------------------------
   1 | 
   2 | var hamibot={env:{fenxiang:"true",wenzhang:"true",meizhou:"daoxu",zhuanxiang:"daoxu",dingyue:"zhengxu",shipin:"true",meiri:"true",siren:"true",bendi:"true",shuangren:"true",dacuo_num:"2",yinliang:"0",tiaozhan:"true",duizhan_mode:"suiji",guaji:true,is_exit:true,watchdog:"",ddtong:false,jisu:"",ocr_maxtime:"",yl_on:true,zhanghao:"11111111111:11111111111\n22222222222:22222222222",APP_ENV:"production",USER_ID:"",ROBOT_ID:"",SCRIPT_ID:"",TIMESTAMP:""},plan:{name:"免费",onFreeTrial:false,model:"free"},robotName:"",};
   3 | hamibot.postMessage=function(){};hamibot.exit=function(){exit();};
   4 | auto.waitFor();//mode = "fast"
   5 | var delay_time = 3000;
   6 | device.wakeUpIfNeeded();
   7 | // 读取自定义配置
   8 | const { watchdog, fast_mode, ddtong, is_exit, fenxiang, shipin, wenzhang, meiri, meizhou, zhuanxiang, tiaozhan, ocr_plugin,
   9 |        ocr_maxtime, duizhan_mode, jisu, guaji, siren, dacuo_num, shuangren, bendi, dingyue, pushplus, yl_on, yinliang, zhanghao } = hamibot.env;
  10 | if (fast_mode) { auto.setMode("fast"); }
  11 | events.observeToast();
  12 | launch('com.hamibot.hamibot');
  13 | // text("Hamibot").waitFor();
  14 | textMatches(/Hamibot|日志/).waitFor();
  15 | sleep(delay_time);
  16 | /*****************更新内容弹窗部分*****************/
  17 | var storage = storages.create('songgedodo');
  18 | // 脚本版本号
  19 | var last_version = "V10.0";
  20 | var engine_version = "V10.1";
  21 | var newest_version = "V10.1";
  22 | if (storage.get(engine_version, true)) {
  23 |   storage.remove(last_version);
  24 | //   以下为自定义弹窗代码
  25 | //   let checked = gengxin_show();
  26 | //   if (checked) {storage.put(engine_version, false);}
  27 |   let gengxin_rows = ["强国APP版本v2.33.0以上不支持订阅，可以在豌豆荚中下载历史版本",
  28 |                       "1.傻瓜版取消OCR过慢跳过对战",
  29 |                       "2.Pro版加入自定义跳过对战OCR识别门槛",
  30 |                       "3.微调滑动验证",
  31 |                       "联系方式：qq群: 586076765；tg: t.me/wyqg_ttxs",
  32 |                       "（点击取消不再提示）"];
  33 |   let is_show = confirm(engine_version + "版更新内容", gengxin_rows.join("\n"));
  34 |   if (!is_show) {storage.put(engine_version, false);}
  35 | }
  36 | var w = fInit();
  37 | // console.setTitle("天天向上");
  38 | // console.show();
  39 | fInfo("天天向上Pro"+newest_version+"脚本初始化");
  40 | fInfo("版本号检测："+ app.versionCode);
  41 | if (app.versionCode < 110) {
  42 |   alert("请进入下载页下载最新版本！！");
  43 | //   let req = http.get("https://hamibot.com/download");
  44 | //   let resp_str = req.body.string();
  45 | //   let reg = '/<a href="(.*)?" target="_blank" data-v-402fe7d6>'
  46 | //   +'<button type="button" appearance="default" spacing="default" data-v-4ab5aafc data-v-402fe7d6>/';
  47 | //   let link = resp_str.match(eval(reg))[1];
  48 | //   //log(link);
  49 | //   app.openUrl(link);
  50 |   app.openUrl("https://hamibot.com/download");
  51 |   exit();
  52 | }
  53 | // 初始化宽高
  54 | var [device_w, device_h] = init_wh();
  55 | // log("fina:", device_w, device_h);
  56 | // OCR初始化，重写内置OCR module
  57 | if (ocr_plugin) {
  58 |   fInfo("初始化第三方ocr插件");
  59 |   try {
  60 |     ocr = plugins.load("com.hraps.ocr");
  61 |     ocr.recognizeText = function (img) {
  62 |       let results = this.detect(img.getBitmap(),1);
  63 |       let all_txt = "";
  64 |       for (let i=0;i<results.size();i++) {
  65 |         let re = results.get(i);
  66 |         all_txt += re.text;
  67 |       }
  68 |       return all_txt
  69 |     }
  70 |   }
  71 |   catch(e) {
  72 |     fError("未安装第三方OCR插件，请安装后重新运行");
  73 |     alert("未安装第三方OCR插件，点击确认跳转浏览器下载，密码为ttxs");
  74 |     app.openUrl("https://wwc.lanzouo.com/ikILs001d0wh");
  75 |     exit();
  76 |   }
  77 | }
  78 | // sleep(2000);
  79 | // 自动允许权限进程
  80 | threads.start(function() {
  81 |   //在新线程执行的代码
  82 |   //sleep(500);
  83 |   toastLog("开始自动获取截图权限");
  84 |   var btn = className("android.widget.Button").textMatches(/允许|立即开始|START NOW/).findOne(5000);
  85 |   if (btn) {
  86 |     sleep(1000);
  87 |     btn.click();
  88 |   }
  89 |   toastLog("结束获取截图权限");
  90 | });
  91 | fInfo("请求截图权限");
  92 | // 请求截图权限、似乎请求两次会失效
  93 | if (!requestScreenCapture(false)) { // false为竖屏方向
  94 |   fError('请求截图失败');
  95 |   hamibot.exit();
  96 | }
  97 | // 防止设备息屏
  98 | fInfo("设置屏幕常亮");
  99 | device.keepScreenOn(3600 * 1000);
 100 | // 下载题库
 101 | fInfo("检测题库更新");
 102 | const update_info = get_tiku_by_http("https://gitee.com/songgedodo/songge_tiku/raw/master/info.json");
 103 | fInfo("正在加载对战题库......请稍等\n题库版本:"+update_info["tiku_version"]);
 104 | var tiku = [];
 105 | try {tiku = get_tiku_by_http(update_info["tiku_link"]);}
 106 | catch (e) {tiku = get_tiku_by_http(update_info["tiku_link2"]);}
 107 | // var tiku = get_tiku_by_gitee();
 108 | fInfo("正在加载专项题库......请稍等\n题库版本:"+update_info["dati_tiku_version"]);
 109 | var dati_tiku = [];
 110 | try {dati_tiku = update_dati_tiku()}
 111 | catch (e) {
 112 |   fError("网络原因未获取到在线题库，请尝试切换流量或者更换114DNS");
 113 |   dati_tiku = get_tiku_by_ct('https://webapi.ctfile.com/get_file_url.php?uid=35157972&fid=555754562&file_chk=94c3c662ba28f583d2128a1eb9d78af4&app=0&acheck=2&rd=0.14725283060014105');
 114 | }
 115 | // 设置资源保存路径
 116 | files.createWithDirs("/sdcard/天天向上/");
 117 | // 调整音量
 118 | if (yl_on) {
 119 |   fInfo("设置媒体音量");
 120 |   var yuan_yl = device.getMusicVolume();
 121 |   var max_yl = device.getMusicMaxVolume();
 122 |   let yl = Math.ceil(yinliang*max_yl/100);
 123 |   //log(yuan_yl, max_yl, yl, typeof yl);
 124 |   device.setMusicVolume(yl);
 125 |   fInfo("当前音量："+ device.getMusicVolume());
 126 | }
 127 | if (is_exit) {
 128 |   fInfo("运行前重置学习APP");
 129 |   exit_app("学习强国");
 130 |   sleep(1500);
 131 | }
 132 | // 检测地理位置权限代码，出现就点掉
 133 | fInfo("开始位置权限弹窗检测");
 134 | var nolocate_thread = threads.start(function() {
 135 |   //在新线程执行的代码
 136 |   id("title_text").textContains("地理位置").waitFor();
 137 |   fInfo("检测到位置权限弹窗");
 138 |   sleep(1000);
 139 |   var btn = text("暂不开启").findOne();
 140 |   btn.click();
 141 |   fInfo("已关闭定位");
 142 | });
 143 | fInfo("跳转学习APP");
 144 | // launch('cn.xuexi.android');
 145 | app.launchApp('学习强国');
 146 | sleep(2000);
 147 | // console.hide();
 148 | // 命令行方式启动，似乎需要root
 149 | // var result_shell = shell("pm disable cn.xuexi.android");
 150 | // log(result_shell.code, result_shell.error);
 151 | /***************不要动****************
 152 |  * **********************************
 153 | // 创建一个安卓动作，打开软件，此功能可以跳过开屏页，还在实验中
 154 | // app.startActivity({
 155 | //   action: 'android.intent.action.VIEW',
 156 | //   data: 'dtxuexi://appclient/page/study_feeds',
 157 | //   packageName: 'cn.xuexi.android',
 158 | // });
 159 |  * **********************************
 160 | *************************************/
 161 | 
 162 | 
 163 | function do_fenxiang() {
 164 |   // 点击分享"去看看"回首页
 165 | //   jifen_list = className("android.widget.ListView").depth(21).findOne();
 166 | //   jifen_list = refind_jifen();
 167 |   jifen_list.child(11).child(3).click();
 168 |   fSet("title", "分享和评论…");
 169 |   fClear();
 170 |   sleep(1000);
 171 |   swipe(device_w/2, device_h*0.7, device_w/2, device_h*0.4, 1000);
 172 |   let wen_box = id("general_card_title_id").findOne().parent().parent();
 173 |   fInfo("尝试点击title:"+ id("general_card_title_id").findOne().text());
 174 | //   //log("文章click:", wen_box.click());
 175 | //   while (!id("general_card_title_id").findOne().parent().parent().click()) {log("文章click: false");}
 176 | //   log("文章click: true");
 177 |   real_click(id("general_card_title_id").findOne().parent().parent());
 178 |   log("等待加载");
 179 |   idContains("image-text-content").waitFor();
 180 |   let text_edit = text("欢迎发表你的观点");
 181 |   log("查找评论框");
 182 |   text_edit.waitFor();
 183 |   sleep(1500);
 184 |   while (text_edit.exists()) {
 185 |     let pinglun = text_edit.findOne(500);
 186 |     fInfo("尝试点击评论框中");
 187 |     log(pinglun.click());
 188 |     sleep(1500);
 189 |     fRefocus();
 190 |   }
 191 |   fInfo("评论框click: true");
 192 |   let content_list = ["全心全意为人民服务","不忘初心，牢记使命","不忘初心，方得始终","永远坚持党的领导","富强、民主、文明、和谐","自由，平等，公正，法治"];
 193 |   classNameEndsWith("EditText").findOne().setText(content_list[random(0, content_list.length-1)]);
 194 |   sleep(1000);
 195 |   text("发布").findOne().click();
 196 |   sleep(1000);
 197 |   text("删除").findOne().click();
 198 |   sleep(1000);
 199 |   text("确认").findOne().click();
 200 |   sleep(1000);
 201 |   // 下面是分享
 202 |   for (let i=0; i<2; i++) {
 203 |     text_edit.findOne().parent().child(3).click();
 204 |     sleep(500);
 205 |     textContains("学习强国").findOne().parent().click();
 206 |     sleep(500);
 207 |     text("创建新的聊天").waitFor();
 208 |     sleep(1000);
 209 |     back();
 210 |     sleep(1000);
 211 |   }
 212 |   // 回到首页
 213 |   back();
 214 |   // 返回积分页
 215 |   jifen_init();
 216 |   ran_sleep();
 217 |   return true;
 218 | }
 219 | 
 220 | /********时长部分*********/
 221 | function do_shipin() {
 222 | //   jifen_list = refind_jifen();
 223 |   jifen_list.child(2).child(3).click();
 224 |   if (ddtong) { fSet("title", "视听(dd通)…"); }
 225 |   else { fSet("title", "视听学习…"); }
 226 |   fClear();
 227 |   desc("百灵").findOne().click();
 228 |   sleep(1000);
 229 |   fInfo("检测温馨提示弹窗");
 230 |   if (text("温馨提示").findOne(1500)) {
 231 |     text("关闭").findOne().click();
 232 |     fInfo("检测到温馨提示并已关闭");
 233 |   }
 234 |   desc("百灵").findOne().click();
 235 |   let shu = text("竖").findOne();
 236 |   sleep(1000);
 237 |   // 定位到整个百灵frame_box
 238 |   let frame_box = shu.parent().parent().parent().parent();
 239 |   textMatches(/\d{2}:\d{2}/).waitFor();
 240 |   let video_list = frame_box.findOne(className("android.widget.ListView"));
 241 |   video_list.child(1).child(1).child(0).click();
 242 |   text("分享").waitFor();
 243 |   if (idContains("guide_view").findOne(1500)) {
 244 |     fInfo("检测到引导遮罩");
 245 |     sleep(1000);
 246 |     click(device_w / 2, device_h / 2);
 247 |     sleep(1000);
 248 |     click(device_w / 2, device_h / 4);
 249 |   }
 250 |   sleep(800);
 251 |   //log(text("刷新重试").exists());
 252 |   if (text("刷新重试").exists()) {
 253 |     fInfo("检测到流量提醒");
 254 |     text("刷新重试").findOne().click();
 255 |   }
 256 |   sleep(random(8000,9500));
 257 |   let re_times = 6;
 258 |   if (ddtong) { re_times += 6; }
 259 |   for (let i=0; i<re_times; i++) {
 260 |     click(device_w / 2, device_h / 2);
 261 |     sleep(500);
 262 |     swipe(device_w/2, device_h*0.8, device_w/2, device_h*0.1, 1000);
 263 |     sleep(random(8000,9500));
 264 |   }
 265 |   back();
 266 |   fInfo("视频个数已刷完");
 267 |   // 返回积分页
 268 |   jifen_init();
 269 |   ran_sleep();
 270 |   return true;
 271 | }
 272 | 
 273 | function do_wenzhang() {
 274 | //   jifen_list = refind_jifen();
 275 |   // 点击进入本地
 276 |   let old_wen = storage_user.get("old_wen_list", []);
 277 |   //log(typeof old_wen, old_wen);
 278 |   jifen_list.child(13).child(3).click();
 279 |   if (ddtong) { fSet("title", "文章(dd通)…"); }
 280 |   else { fSet("title", "选读文章…"); }
 281 |   fClear();
 282 |   fInfo("切换地区为北京");
 283 |   text("切换地区").findOne(3000);
 284 |   if (text("立即切换").exists()) {
 285 |     text("取消").findOne(3000).click();
 286 |   }
 287 |   log("切换地区");
 288 |   text("切换地区").findOne().click();
 289 |   log("查找北京");
 290 |   text("北京").waitFor();
 291 |   sleep(500);
 292 |   log("切换北京");
 293 |   text("北京").findOne().parent().parent().click();
 294 |   log("查找banner");
 295 |   //let banner = className("android.support.v7.widget.RecyclerView").findOne();
 296 |   let banner = classNameContains("RecyclerView").findOne();
 297 |   fInfo("查找北京新闻广播");
 298 |   //fRefocus();
 299 |   while (banner.findOne(text("北京新闻广播").boundsInside(0,0,device_w,device_h)) == null) {banner.scrollForward();sleep(500);}
 300 |   last_obj = banner.findOne(text("北京新闻广播"));
 301 | //   fInfo("点击北京新闻广播", text("北京新闻广播").findOne().parent().click());
 302 |   fInfo("点击北京新闻广播："+ last_obj.parent().click());
 303 |   fInfo("视听广播时长");
 304 |   sleep(11500);
 305 |   back();
 306 |   fClear();
 307 |   // 下面正式刷文章
 308 |   fInfo("开始文章");
 309 |   sleep(1500);
 310 |   banner = classNameContains("RecyclerView").findOne();
 311 |   //log(banner);
 312 |   while (banner.findOne(text("北京学习平台").boundsInside(0,0,device_w,device_h)) == null) {banner.scrollBackward();sleep(500);}
 313 |   sleep(1000);
 314 |   fInfo("查找北京学习平台，尝试点击");
 315 |   first_obj = banner.findOne(text("北京学习平台"));
 316 | //   while (!text("北京学习平台").findOne().parent().click()) {log("click: false");}
 317 | //   log("click: true");
 318 | //   real_click(text("北京学习平台").findOne().parent());
 319 |   real_click(first_obj.parent());
 320 |   log("等待加载");
 321 |   sleep(1000);
 322 |   text("新思想扎根京华").waitFor();
 323 |   sleep(1000);
 324 |   let swipe_y = text("新思想扎根京华").findOne().parent().parent().bounds().bottom;
 325 |   log("识别出顶部：", swipe_y);
 326 |   fRefocus();
 327 |   let listview = className("android.widget.ListView").depth(17).findOne();
 328 |   // 先判断是否有可刷文章，没有则停止脚本
 329 |   // while (!id("general_card_image_id").findOne(1000)) {listview.scrollForward();}
 330 |   for (i=0; i<2; i++) {
 331 |     listview.scrollForward();
 332 |     sleep(500);
 333 |   }
 334 |   // 自定义没有刷过的文章筛选器
 335 |   let wen_box_slt = className("android.view.ViewGroup").depth(20).filter(function(l) {
 336 |     let title = l.findOne(idContains("general_card_title_id"));
 337 |     let image = l.findOne(idContains("general_card_image_id"));
 338 |     if (title && image) {
 339 |       return old_wen.indexOf(title.text())==-1 && title.text().indexOf("【专题】")==-1;
 340 |     }
 341 |     return false;
 342 |   });
 343 |   log("查找文章");
 344 |   //while (!idContains("general_card_image_id").findOne(500)) {
 345 |   while (!wen_box_slt.findOne(500)) {
 346 |     listview.scrollForward();
 347 |     //sleep(500);
 348 |   }
 349 |   log("找到文章");
 350 |   // 下面那句会定位到新思想的文章，不能加载过新思想
 351 |   let wen_box = wen_box_slt.findOne();
 352 |   // 先做5次
 353 |   let wen_num = 0;
 354 |   let re_times = 6;
 355 |   if (ddtong) { re_times += 6; }
 356 |   while (true) {
 357 |     let title = wen_box.findOne(idContains("general_card_title_id")).text();
 358 |     old_wen.push(title);
 359 |     if (old_wen.length > 100) {old_wen.shift();}
 360 |     fClear();
 361 |     fInfo("点击文章："+title);
 362 |     //wen_box.click();
 363 |     let title_click = wen_box.parent().parent().click();
 364 |     fInfo("点击："+title_click);
 365 |     classNameContains("com.uc.webview.export").waitFor();
 366 |     fInfo("查找webview");
 367 |     let father_view = className("android.webkit.WebView").findOne(9000);
 368 |     sleep(1000);
 369 | //     let father_view = className("android.view.View").depth(16).findOne();
 370 |     // 判断是否为专题而不是文章
 371 |     if (father_view && father_view.find(idContains("__next")).empty()) {
 372 |       fInfo("查找文章内容");
 373 |       let content = idContains("image-text-content").findOne(9000);
 374 |       // log(idContains("image-text-content").findOne().id());
 375 |       if (content) {
 376 |         // 不先点一下划不动
 377 |         idContains("xxqg-article-header").findOne().child(0).click();
 378 |       }
 379 |       swipe(device_w/2, device_h*0.7, device_w/2, device_h*0.3, 1000);
 380 |       if (wen_num < re_times-1) {
 381 |         sleep(random(9000,10500));
 382 |       }
 383 |      	else {
 384 |         // 第6次停顿刷时间
 385 |         //console.show();   
 386 |         toastLog("正在刷时长程序未停止");
 387 |         let shichang = 6*random(55, 60);
 388 |         fClear();
 389 |         fInfo("开始刷时长，总共" + shichang + "秒");
 390 |         let wait_time = 1;
 391 |         for (let i=0; i<shichang; i++){ //*random(55, 60)
 392 |           // 每15秒增加一次滑动防息屏
 393 |           if (i%15==0) {
 394 |             swipe(device_w/2, device_h*0.6, device_w/2, device_h*0.6-100, 500);
 395 |             sleep(500);
 396 |           }
 397 |           else {sleep(1000);}
 398 |           //w.info.setText("已观看文章" + wait_time + "秒，总共" + shichang + "秒");
 399 |           fSet("info", "已观看文章" + wait_time + "秒，总共" + shichang + "秒");
 400 |           wait_time++;
 401 |         }
 402 |         fSet("info", "已结束文章时长");
 403 |         console.hide();
 404 |         back();
 405 |         break;
 406 |       }
 407 |     }
 408 |     else {wen_num -= 1;}
 409 |     back();
 410 |     //id("general_card_image_id").waitFor();
 411 |     className("android.widget.ListView").scrollable().depth(17).waitFor();
 412 |     sleep(1000);
 413 |     while (!wen_box_slt.exists()) {
 414 |       listview.scrollForward();
 415 |       sleep(200);
 416 |     }
 417 |     wen_box = wen_box_slt.findOne();
 418 |     wen_num += 1;
 419 |   }
 420 |   // 更新已读文章库
 421 |   storage_user.put("old_wen_list", old_wen);
 422 |   sleep(3000);
 423 |   // 关闭音乐
 424 |   close_video();
 425 |   back(); 
 426 |   sleep(3000);
 427 |   // 返回积分页
 428 |   jifen_init();
 429 |   ran_sleep();
 430 |   return true;
 431 | }
 432 | 
 433 | /********每日答题*********/
 434 | function do_meiri() {
 435 |   // 点击进入每日答题
 436 | //   jifen_list = refind_jifen();
 437 |   jifen_list.child(4).child(3).click();
 438 |   fSet("title", "每日答题…");
 439 |   fClear();
 440 |   // 等待加载
 441 |   text("查看提示").waitFor();
 442 |   // 获取右上题号，如1 /5
 443 |   var tihao = className("android.view.View").depth(24).findOnce(1).text();
 444 |   var num = Number(tihao[0]);
 445 |   var sum = Number(tihao[tihao.length-1]);
 446 |   var substr = tihao.slice(1);
 447 |   while (num<=sum) {
 448 |     fClear();
 449 |     fInfo("第"+num+"题");
 450 |     // 等待加载
 451 |     text(num+substr).waitFor();
 452 |     num++;
 453 | //     // 如果是视频题则重新开始
 454 | //     if (className("android.widget.Image").exists()) {
 455 | //       num = 1;
 456 | //       restart(0);
 457 | //       continue;
 458 | //     }
 459 |     do_exec();
 460 |     // 点击确定下一题
 461 |     depth(20).text("确定").findOne().click();
 462 | 		ran_sleep();
 463 |     // 如果题做错了重来
 464 |     if (text("下一题").exists() || text("完成").exists()) {
 465 |       fInfo("答错重试");
 466 |       num = 1;
 467 |       restart(0);
 468 |       continue;
 469 |     }
 470 |   }
 471 | 	// 循环结束完成答题
 472 |   text("返回").findOne().click();
 473 |   text("登录").waitFor();
 474 |   ran_sleep();
 475 |   return true;
 476 | }
 477 | 
 478 | /********每周答题*********/
 479 | function do_meizhou() {
 480 |   // 点击进入每周答题
 481 | //   jifen_list = refind_jifen();
 482 |   jifen_list.child(5).child(3).click();
 483 |   fSet("title", "每周答题…");
 484 |   fClear();
 485 |   // 等待加载
 486 |   textContains("月").waitFor();
 487 |   let scoll = depth(21).scrollable().findOne();
 488 |   // 下面是倒叙作答
 489 |   if (meizhou_dao) {
 490 |     fInfo("倒序查找未做题目");
 491 |     //当出现已作答时，点击最后一个未作答
 492 |     while (!text("已作答").exists()) {
 493 |       scoll.scrollForward();
 494 |       sleep(300);
 495 |     }
 496 |     var clt = text("未作答").find();
 497 |     if (clt.empty()) {
 498 |       fInfo("每周答题全部已作答。");
 499 |       back();
 500 |       text("登录").waitFor();
 501 |       ran_sleep();
 502 |       return true;
 503 |     }
 504 |     var title = clt[clt.length-1].parent().child(0).text();
 505 |     fInfo(title + "开始作答");
 506 |     clt[clt.length-1].parent().click();
 507 |     // 测试用
 508 |     // text("已作答").findOnce(0).click();
 509 |   }
 510 |   // 下面是正序作答
 511 |   else {
 512 |     fInfo("正序查找未做题目");
 513 |     // 找到未作答就停止滚动
 514 |     let dixian_slt = text("您已经看到了我的底线").filter(function(w) {
 515 |       log("底线：", w.bounds().top, device_h);
 516 |       return w.bounds().top <= device_h-30;
 517 |     });
 518 |     //while (true) { //测试用
 519 |     while (!text("未作答").exists()) {
 520 |       // 如果到底则设置倒序为true
 521 |       if (dixian_slt.exists()) {
 522 |         //storage_user.put('meizhou_dao', true);
 523 |         fInfo("每周答题全部已作答。");
 524 |         back();
 525 |         text("登录").waitFor();
 526 |         ran_sleep();
 527 |         return true;
 528 |       }
 529 |       scoll.scrollForward();
 530 |       sleep(200);
 531 |     }
 532 |     title = text("未作答").findOne().parent().child(0).text();
 533 |     fInfo(title + "开始作答");
 534 |     text("未作答").findOne().parent().click();
 535 |   } 
 536 |   // 等待加载
 537 |   text("查看提示").waitFor();
 538 |   // 获取右上题号，如1 /5
 539 |   var tihao = className("android.view.View").depth(24).findOnce(1).text();
 540 |   var num = Number(tihao[0]);
 541 |   var sum = Number(tihao[tihao.length-1]);
 542 |   var substr = tihao.slice(1);
 543 |   while (num<=sum) {
 544 |     fClear();
 545 |     fInfo("第"+num+"题");
 546 |     // 等待加载
 547 |     text(num+substr).waitFor();
 548 |     num++;
 549 |     do_exec("（每周）");
 550 |     // 点击确定下一题
 551 |     depth(20).text("确定").findOne().click();
 552 | 		ran_sleep();
 553 |     // 如果题做错了重来
 554 |     if (text("下一题").exists() || text("完成").exists()) {
 555 |       //toastLog(title + "我无能为力啦，请手动作答吧");
 556 |       fInfo("做错尝试重答");
 557 |       text("答案解析").waitFor();
 558 |       upload_wrong_exec("（每周）");
 559 |       storage.put('dati_tiku', dati_tiku);
 560 |       back();
 561 |       text("退出").findOne().click();
 562 |   		ran_sleep();
 563 |       back();
 564 |       text("登录").waitFor();
 565 |       ran_sleep();
 566 |       return false;
 567 |     }    
 568 |   }
 569 | 	// 循环结束完成答题
 570 |   text("返回").findOne().click();
 571 |   sleep(1000);
 572 |   back();
 573 |   text("登录").waitFor();
 574 |   ran_sleep();
 575 |   return true;
 576 | }
 577 | 
 578 | /********专项答题*********/
 579 | /*专项答题中提示的层次与每日每周的不一样
 580 |  * 专项答题出现的倒计时会影响22,23层的结构*/
 581 | function do_zhuanxiang() {
 582 |   // 点击进入专项答题
 583 | //   jifen_list = refind_jifen();
 584 |   jifen_list.child(6).child(3).click();
 585 |   fSet("title", "专项答题…");
 586 |   fClear();
 587 |   // 等待加载
 588 |   depth(23).waitFor();
 589 |   ran_sleep();
 590 |   let scoll = depth(21).indexInParent(1).scrollable().findOne();
 591 |   //let new_tihao = [];
 592 |   // 下面是倒序答题
 593 |   if (zhuanxiang_dao) {
 594 |     // 当出现已满分时，点击最后一个开始答题
 595 |     while (!text("已满分").exists()) {
 596 |       scoll.scrollForward();
 597 |       // 不加延迟会很卡
 598 |       sleep(200);
 599 |     }
 600 |     var clt = text("开始答题").find();
 601 |     if (clt.empty()) {
 602 |       fInfo("专项答题全部已作答。");
 603 |       back();
 604 |       text("登录").waitFor();
 605 |       ran_sleep();
 606 |       return true;
 607 |     }
 608 |     // 点击最后一项
 609 |     clt[clt.length-1].click();
 610 |   }
 611 |   // 下面是正序
 612 |   else {
 613 |     // 直到找到开始答题
 614 |     let dixian_slt = text("您已经看到了我的底线").filter(function(w) {
 615 |       return w.bounds().top <= device_h-30;
 616 |     });
 617 |     //while (true) { //测试用
 618 |     while (!text("开始答题").exists()) { //开始答题
 619 |       // 如果到底则设置倒序为true
 620 |       if (dixian_slt.exists()) {
 621 |         //storage_user.put('zhuanxiang_dao', true); 自定义不用读取
 622 |         fInfo("专项答题全部已作答。");
 623 |         back();
 624 |         text("登录").waitFor();
 625 |         ran_sleep();
 626 |         return true;
 627 |       }
 628 |       // 滚动20次
 629 |       for (i=0; i<15; i++) {
 630 |         scoll.scrollForward();
 631 |         // 不加延迟会很卡
 632 |         sleep(300);
 633 |       }
 634 |     }
 635 |     text("开始答题").findOne().click();
 636 |   }
 637 |   ran_sleep();
 638 |   // 等待加载
 639 |   text("查看提示").waitFor();
 640 |   sleep(2000);
 641 |   // 获取右上题号，如1 /5
 642 |   var tihao = className("android.view.View").depth(24).findOnce(1).text();
 643 |   // 需要加个斜杠转义
 644 |   let reg = /(\d+) \/(\d+)/;
 645 |   var num = Number(tihao.match(reg)[1]);
 646 |   var sum = Number(tihao.match(reg)[2]);
 647 |   var substr = " /" + sum;
 648 |   //log(tihao);
 649 |   while (num<=sum) {
 650 |     fClear();
 651 |     fInfo("第"+num+"题");
 652 |     // 等待加载
 653 |     text(num+substr).waitFor();
 654 |     num++;
 655 |     do_exec();
 656 |     // 点击确定下一题
 657 |     let next = className("android.view.View").filter(function(l) {
 658 |       return (l.text() == "下一题") || (l.text() == "完成");
 659 |     });
 660 |     next.findOne().click();
 661 | //     if (!click("下一题")) {
 662 | //       click("完成");
 663 | //     }
 664 |     ran_sleep();
 665 |   }
 666 |   // 循环结束完成答题
 667 |   text("查看解析").waitFor();
 668 |   sleep(1000);
 669 |   // 如果题目答错，循环每一题并添加错题
 670 |   if (textMatches(/\d+分/).findOne().text() != "100分") {
 671 |     fInfo("有错题，尝试上传错题");
 672 |     text("查看解析").findOne().click();
 673 |     tihao = textMatches(reg).findOne().text();
 674 |     num = Number(tihao.match(reg)[1]);
 675 |     sum = Number(tihao.match(reg)[2]);
 676 |     substr = " /" + sum;
 677 |     //log(tihao);
 678 |     sleep(1500);
 679 |     while (num<=sum) {
 680 |       // 等待加载
 681 |       text(num+substr).waitFor();
 682 |       num++;
 683 |       if (textEndsWith("回答错误").exists()) {
 684 |         upload_wrong_exec();
 685 |       }
 686 |       // 点击确定下一题
 687 |       let next = className("android.view.View").filter(function(l) {
 688 |         return (l.text() == "下一题") || (l.text() == "完成");
 689 |       });
 690 |       next.findOne().click();
 691 |       sleep(random(1000, 1500));
 692 |     }
 693 |     storage.put('dati_tiku', dati_tiku);
 694 |   }
 695 |   else {
 696 |     back();
 697 |     ran_sleep();
 698 |   }
 699 |   back();
 700 |   text("登录").waitFor();
 701 |   ran_sleep();
 702 |   return true;
 703 | }
 704 | 
 705 | /********挑战答题*********/
 706 | function do_tiaozhan() {
 707 |   // 点击进入挑战答题
 708 | //   jifen_list = refind_jifen();
 709 |   jifen_list.child(7).child(3).click();
 710 |   if (ddtong) { fSet("title", "挑战(dd通)…"); }
 711 |   else { fSet("title", "挑战答题…"); }
 712 |   fClear();
 713 |   // 等待加载、积分页面也有Image和List，需要用depth筛选
 714 |   className("android.widget.Image").depth(24).waitFor();
 715 |   let total = 0;
 716 |   let max_total = 5;
 717 |   if (ddtong) { max_total += 10; }
 718 |   while (true) {
 719 |     fClear();
 720 |     fInfo("第"+(total+1)+"题");
 721 |     // 等待选项列表
 722 |     let xuan_list = className("android.widget.ListView").findOne().children();
 723 |     // 获取题目
 724 |     let que_txt = className("android.widget.ListView").findOne().parent().child(0).text();
 725 |     //log(que_txt);
 726 |     // 获取答案列表，可能找到多个答案
 727 |     // let ans_list = get_ans_by_http(que_txt.replace(/来源：.*|出题单位：.+/, ""));
 728 |     let ans_list = get_ans_by_tiku(que_txt.replace(/[^\u4e00-\u9fa5\d]|来源：.+|出题单位：.+/g, ""));
 729 | //     fInfo(que_txt.replace(/[^\u4e00-\u9fa5\d]|来源：.+|出题单位：.+/g, ""));
 730 |     //log("答案："+ans_list);
 731 |     ran_sleep();
 732 |     if (total >= max_total) {
 733 |       // 题数数够了随便选
 734 |       fInfo("已答对"+max_total+"题，全选A");
 735 |       xuan_list[0].child(0).click();
 736 |     }else if (ans_list.length != 0) {
 737 |       let max_simi = 0;
 738 |       let xuanxiang = null;
 739 |       // 循环对比所有选项和答案，选出相似度最大的
 740 |       for (let xuan_box of xuan_list) {
 741 |         let xuan_txt = xuan_box.child(0).child(1).text();
 742 |         //log(xuan_txt);
 743 |         for (let ans of ans_list) {
 744 |           let similar = str_similar(ans.slice(2), xuan_txt);
 745 |           //log(xuan_txt, similar);
 746 |           if (similar > max_simi) {
 747 |             max_simi = similar;
 748 |             xuanxiang = xuan_box.child(0);
 749 |           }
 750 |         }
 751 |       }
 752 |       if (xuanxiang != null) {
 753 |         fInfo("最终："+ xuanxiang.child(1).text());
 754 |         xuanxiang.click();
 755 |       }
 756 |       else {
 757 |         fInfo("无匹配答案");
 758 |         xuan_list[0].child(0).click();
 759 |       }
 760 |     }
 761 |     // 如果没找到答案
 762 |     else {
 763 |       fInfo("未找到答案");
 764 |       // 选第一个选项
 765 |       xuan_list[0].child(0).click();
 766 |     }
 767 |     sleep(2500);
 768 |     // 判断题是否答错
 769 |     if (text("结束本局").exists()) {
 770 |       sleep(5000);
 771 |       click("结束本局");
 772 |       text("再来一局").waitFor();
 773 |       if (total < 5) {
 774 |         fInfo("答错重试");
 775 |         console.warn("warn:", que_txt);
 776 |       	text("再来一局").findOne().click();
 777 |       }
 778 |       else {
 779 |         // 退出
 780 |         back();
 781 |         text("登录").waitFor();
 782 |         ran_sleep();
 783 |         return true;
 784 |       }
 785 |       total = 0;
 786 |       sleep(2000);
 787 |       continue;
 788 |     }
 789 |     // 没答错总数加1
 790 |     total += 1;
 791 |   }
 792 | }
 793 | 
 794 | /********双人、四人赛*********/
 795 | function do_duizhan1(renshu) {
 796 | //   jifen_list = refind_jifen();
 797 |   fClear();
 798 |   if (renshu == 2) {
 799 |     // 点击进入双人对战
 800 |     jifen_list.child(9).child(3).click();
 801 |     fSet("title", "双人对战");
 802 |     fInfo("等待随机匹配");
 803 |     text("随机匹配").waitFor();
 804 |     sleep(1000);
 805 |     let match = text("随机匹配").findOne().parent().child(0);
 806 |     do {
 807 |       fInfo("点击："+match.click());
 808 |       sleep(500);
 809 |     } while (text("随机匹配").exists());
 810 |   } else {
 811 |     // 点击进入四人赛
 812 |     jifen_list.child(8).child(3).click();
 813 |     fSet("title", "四人赛");
 814 |     // 等待开始比赛并点击
 815 |     fInfo("等待开始比赛");
 816 |     text("开始比赛").waitFor();
 817 |     sleep(1000);
 818 |     let start_click = text("开始比赛").findOne().click();
 819 |     fInfo("点击："+start_click);
 820 |   }
 821 |   let delay = Number(jisu);
 822 |   if (delay > 0 && duizhan_mode == "guding") {
 823 |     ui.run(function() {
 824 |       let title = w.title.getText();
 825 |       w.title.setText(title+"(急速)");
 826 |       toastLog("极速模式开启");
 827 |     });
 828 |   } else if (duizhan_mode == "shoudong") {
 829 |     ui.run(function() {
 830 |       let title = w.title.getText();
 831 |       w.title.setText(title+"(手动)");
 832 |       toastLog("请手动点击答案");
 833 |     });
 834 |   }
 835 |   //text("开始").findOne(1000);
 836 |   className("android.widget.ListView").waitFor();
 837 |   fClear();
 838 | //   if (renshu == 0) {
 839 | //   }
 840 |   let num = 1;
 841 |   let err_flag = true;
 842 |   while (true) {
 843 |     // 如果是第一题或者下面出错，则跳过前面等待过渡
 844 |     if (num != 1 && err_flag) {
 845 |       // 检查到其中一个过渡界面为止
 846 |       while (true) {
 847 |         // 检测是否结束并退出
 848 |         if (text("继续挑战").exists()) {
 849 |           sleep(1000);
 850 |           let tz_click = text("继续挑战").findOne().click();
 851 |           fInfo("点击继续挑战:"+tz_click);
 852 |           sleep(1500);
 853 |           back();
 854 |           if (renshu == 2) {
 855 |             sleep(1000);
 856 |             fInfo("查找退出按钮");
 857 |             if (fast_mode) { winReshow(); }
 858 |             var exit_click = text("退出").findOne().click();
 859 |             fInfo("点击退出:"+exit_click);
 860 |           }
 861 |           sleep(1000);
 862 |           text("登录").waitFor();
 863 |           ran_sleep();
 864 |           return true;
 865 |         }
 866 |         else if (text("第" + num + "题").exists()) {
 867 |           fClear();
 868 |           fInfo("第"+num+"题");
 869 |           break;
 870 |         }
 871 |       }
 872 |       // 直到过渡界面消失，再匹配下一题
 873 |       while (text("第" + num + "题").exists()) {} //sleep(100);
 874 |       //fTips("题号过渡消失");
 875 |     }
 876 |     else if (!err_flag) {
 877 |       err_flag = true;
 878 |       if (text("继续挑战").exists()) {
 879 |         sleep(1000);
 880 |         let tz_click = text("继续挑战").findOne().click();
 881 |         fInfo("点击继续挑战:"+tz_click);
 882 |         sleep(1500);
 883 |         back();
 884 |         if (renshu == 2) {
 885 |           sleep(1000);
 886 |           fInfo("查找退出按钮");
 887 |           if (fast_mode) { winReshow(); }
 888 |           var exit_click = text("退出").findOne().click();
 889 |           fInfo("点击退出:"+exit_click);
 890 |         }
 891 |         sleep(1000);
 892 |         text("登录").waitFor();
 893 |         ran_sleep();
 894 |         return true;
 895 |       }
 896 |     }
 897 |     let listview = className("android.widget.ListView").findOne(1000);
 898 |     if (!listview) {
 899 |       log("找不到listview");
 900 |       err_flag = false;
 901 |       sleep(200);
 902 |       continue;
 903 |     }
 904 |     sleep(100); // 追求极限速度，不知道会不会出错
 905 |     let view_d28 = className("android.view.View").depth(28).indexInParent(0).findOne(1000);
 906 |     if (!view_d28) {
 907 |       toastLog("找不到view_d28");
 908 |       err_flag = false;
 909 |       sleep(200);
 910 |       continue;
 911 |     }
 912 |     // 根据父框的孩子数
 913 |     if (view_d28.childCount() > 0) {
 914 |       que_x = view_d28.bounds().left;
 915 |       que_y = view_d28.bounds().top;
 916 |       que_w = view_d28.bounds().width();
 917 |       if (view_d28.child(0).text().length <= 4) { //有来源的是前面两个空格元素，文本为4个空格
 918 |         que_h = view_d28.child(2).bounds().top - view_d28.bounds().top;
 919 |       } else { //无来源的是题目，文本为8个空格
 920 |         que_h = view_d28.child(0).bounds().bottom - view_d28.bounds().top;
 921 |       }
 922 |     }
 923 |     else {
 924 |       toastLog("找不到框体");
 925 |       log(view_d28.childCount(), view_d28.bounds());
 926 |       err_flag = false;
 927 |       sleep(200);
 928 |       continue;
 929 |     }
 930 |     // 查找选项个数
 931 |     var radio_num = className("android.widget.RadioButton").find().length;
 932 |     if (!radio_num) {
 933 |       log("找不到选项");
 934 |       err_flag = false;
 935 |       sleep(200);
 936 |       continue;
 937 |     }
 938 |     //fTips("开始识别题目");
 939 |     for (let i=0; i<3; i++) {
 940 |       let img = captureScreen();
 941 |       // 裁剪题干区域，识别题干
 942 |       let que_img = images.clip(img, que_x, que_y, que_w, que_h);
 943 |       //images.save(que_img, '/sdcard/1/que_img' + num + '.png');
 944 | //       console.time('题目识别1');
 945 | //       let results = ocr.recognize(que_img).results;
 946 | //       var que_txt = ocr_rslt_to_txt(results).replace(/[^\u4e00-\u9fa5\d]|^\d{1,2}\.?/g, "");
 947 | //       console.timeEnd('题目识别1');
 948 |       // 为了适配OCR插件改为下面这句
 949 |       console.time('题目识别');
 950 |       var que_txt = ocr.recognizeText(que_img).replace(/[^\u4e00-\u9fa5\d]|\d{1,2}\./g, "");
 951 |       console.timeEnd('题目识别');
 952 |       if (!que_txt) {
 953 |         images.save(img, '/sdcard/天天向上/' + renshu + '-' + num + '.png','png',50);
 954 |         images.save(que_img, '/sdcard/天天向上/' + renshu + '-' + num + '-q.png','png',50);
 955 |         fError("未识别出题目，图片保存至‘/sdcard/天天向上/’");
 956 |         console.error("大概率无障碍服务失效"+ auto.service);
 957 |         console.error("题目框体范围：", que_x, que_y, que_w, que_h);
 958 |         img.recycle();
 959 |         que_img.recycle();
 960 |       } else {
 961 |         fInfo("题目识别："+ que_txt);
 962 |         img.recycle();
 963 |         que_img.recycle();
 964 |         break
 965 |       }
 966 |     }
 967 |     if (renshu == 0) {
 968 |       fInfo("由于第一局匹配对手较强，正在挂机中。");
 969 |       fInfo("经测试挂机不会扣积分局数，此功能可在配置中关闭");
 970 |       fTips("请不要点击任何选项，不要作答！！！");
 971 |       num++;
 972 |       text("继续挑战").waitFor();
 973 |       continue;
 974 |     }
 975 |     // 选项清洗标识
 976 |     var replace_sign = "default_ocr_replace";
 977 |     let question_reg = new RegExp(update_info["question_reg"], "gi");
 978 |     let include_reg = new RegExp(update_info["include_reg"], "gi");
 979 |     var que_key = null;
 980 |     if (que_key = question_reg.exec(que_txt)) { replace_sign = "other_ocr_replace"; }
 981 |     else if (que_key = (/读音|词形/g).exec(que_txt)) { replace_sign = "accent_ocr_replace"; }
 982 |     else if (que_key = include_reg.exec(que_txt)) { replace_sign = "include_ocr_replace"; }
 983 |     
 984 |     let ans_list = get_ans_by_tiku(que_txt);
 985 |     //log(ans_list);
 986 |     let idx_dict = {"A": 0, "B": 1, "C": 2, "D": 3};
 987 | /************以下是因为随机选项顺序后失效的代码*****************/
 988 |     try { //防止别人先答完出错
 989 |       let idx = 0;
 990 |       if (ans_list.length <= 1) {
 991 |         if (ans_list.length == 1 && idx_dict[ans_list[0][0]] != undefined) {
 992 |           idx = idx_dict[ans_list[0][0]];
 993 |           fTips("答案:"+ ans_list[0].slice(2));
 994 | //           fInfo("答案:"+ ans_list[0]);
 995 |         }
 996 |         else if (ans_list.length == 0) {
 997 |           fInfo("未找到答案");
 998 |         }
 999 |         if (duizhan_mode == "guding") {
1000 |           if (delay > 0 && num != 1) {sleep(random(delay, delay+50));}
1001 |           else {
1002 |             // 直到选项完全出现在屏幕
1003 |             while (className("android.widget.ListView").findOne(1000).indexInParent() == 0) {}
1004 |           }
1005 |           let is_click = className("android.widget.RadioButton").findOnce(idx).parent().click();
1006 |           log(is_click);
1007 |           if (!is_click) {
1008 |             sleep(200);
1009 |             log(className("android.widget.RadioButton").findOnce(idx).parent().click());
1010 |           }
1011 |           num++;
1012 |           continue;
1013 |         } else if (duizhan_mode == "shoudong") {
1014 |           num++;
1015 |           textMatches(/第.+题|继续挑战/).waitFor();
1016 |           continue;
1017 |         }
1018 |       }
1019 |     }
1020 |     catch (e) {
1021 |       log("error1:", e);
1022 |     }
1023 | /************以上是因为随机选项顺序后失效的代码*****************/
1024 |     
1025 |     
1026 |     // 如果上面答案不唯一或者不包含找到的选项，直到选项完全出现在屏幕
1027 |     try {
1028 |     	while (className("android.widget.ListView").findOne(1000).indexInParent() == 0) {}
1029 |       //fTips("选项显现");
1030 |     } catch (e) {
1031 |       log("error2:", e);
1032 |       err_flag = false;
1033 |       sleep(200);
1034 |       continue;
1035 |     }
1036 |     let xuanxiang_list = className("android.widget.ListView").findOne(1000);
1037 |     let xuanxiang_index = xuanxiang_list.indexInParent();
1038 |     let xuanxiang_list_x = xuanxiang_list.bounds().left;
1039 |     let xuanxiang_list_y = xuanxiang_list.bounds().top;
1040 |     let xuanxiang_list_w = xuanxiang_list.bounds().width();
1041 |     let xuanxiang_list_h = xuanxiang_list.bounds().height();
1042 |     
1043 |     if (xuanxiang_list.parent().child(0) == null || !xuanxiang_list.parent().childCount() || !xuanxiang_list) {
1044 |       log("xuan_box is null");
1045 |       err_flag = false;
1046 |       sleep(200);
1047 |       continue;
1048 |     }
1049 |     log("开始截选项");
1050 |     console.time("选项识别");
1051 |     img = captureScreen();
1052 |     // 裁剪所有选项区域
1053 |     img = images.clip(img, xuanxiang_list_x, xuanxiang_list_y, xuanxiang_list_w, xuanxiang_list_h);
1054 | 		//images.save(allx_img, '/sdcard/1/x_img' + num + '.png');
1055 |     let xuan_txt_list = [];
1056 |     let allx_txt = "";
1057 |     if (!ocr_plugin) {
1058 |       // 排序顺序
1059 |       //     console.time('选项识别1');
1060 |       let x_results = ocr.recognize(img).results;
1061 |       allx_txt = ocr_rslt_to_txt(x_results).replace(/\s+/g, "");
1062 |       //     console.timeEnd('选项识别1');
1063 |     } else {
1064 | //     // 直接识别
1065 | //     console.time('选项识别2');
1066 |       allx_txt = ocr.recognizeText(img);
1067 | //     console.timeEnd('选项识别2');
1068 |     }
1069 |     console.timeEnd("选项识别");
1070 |     // log(allx_txt);
1071 |     if (!allx_txt) {
1072 |       images.save(img, '/sdcard/天天向上/' + renshu + '-' + num + '-a.png','png',50);
1073 |       log("识别不出选项文本，图片保存至‘/sdcard/天天向上/’");
1074 |       err_flag = false;
1075 |       sleep(200);
1076 |       continue;
1077 |     }
1078 |     img.recycle();
1079 |     // 清洗选项文本
1080 |     log("replace_sign:"+replace_sign);
1081 |     log("清洗前："+allx_txt);
1082 |     let replace_d = update_info[replace_sign];
1083 |     if (replace_sign == "include_ocr_replace") {
1084 |       let result = true;
1085 |       log("que_key:"+que_key);
1086 |       let [words, r, repl] = replace_d[que_key];
1087 |       for (let word of words) {
1088 |         let reg = new RegExp(word, "gi");
1089 |         if (!reg.test(allx_txt)) {
1090 |           result = false;
1091 |           break;
1092 |         }
1093 |       }
1094 |       if (result) {
1095 |         let reg = new RegExp(r, "gi");
1096 |         allx_txt = allx_txt.replace(reg, repl);
1097 |       }
1098 |     } else {
1099 |       for (let r of Object.keys(replace_d)) {
1100 |         let reg = new RegExp(r, "gi");
1101 |         allx_txt = allx_txt.replace(reg, replace_d[r]);
1102 |       }
1103 |     }
1104 |     // allx_txt.replace(/令媛/g, "令嫒");
1105 |     // 获取选项列表
1106 |     xuan_txt_list = allx_txt.match(/[a-d][^a-z\u4e00-\u9fa5\d]?\s*.*?(?=[a-d][^a-z\u4e00-\u9fa5\d]?|$)/gi);
1107 |     if (xuan_txt_list && xuan_txt_list.length != radio_num) {
1108 |       xuan_txt_list = allx_txt.match(/[a-d][^a-z\u4e00-\u9fa5\d]\s*.*?(?=[a-d][^a-z\u4e00-\u9fa5\d]|$)/gi);
1109 |     }
1110 |     if (!xuan_txt_list) {
1111 |       log("识别不出选项");
1112 |       err_flag = false;
1113 |       sleep(200);
1114 |       continue;
1115 |     }
1116 |     log(xuan_txt_list.toString());
1117 |     
1118 |     if (xuan_txt_list.length != 0) {
1119 |       let max_simi = 0;
1120 |       let right_xuan = '';
1121 |       let right_xuan2 = '';
1122 |       let ans_txt = '';
1123 |       for (let xuan_txt of xuan_txt_list) {
1124 |         let txt = xuan_txt.replace(/^[A-Z]\.?/gi, "");;
1125 |         for (let ans of ans_list) {
1126 |           let similar = str_similar(ans.slice(2), txt);
1127 |           if (similar > max_simi) {
1128 |             max_simi = similar;
1129 |             ans_txt = ans;
1130 |             if (duizhan_mode == "guding") {
1131 |               // 答案默认顺序优先
1132 |               right_xuan = ans[0];
1133 |               right_xuan2 = xuan_txt[0].toUpperCase();
1134 |             } else {
1135 |               // 文本匹配优先
1136 |               right_xuan2 = ans[0];
1137 |               right_xuan = xuan_txt[0].toUpperCase();
1138 |             }
1139 |           }
1140 |         }
1141 |       }
1142 |       if (ans_list.length > 1) {fTips("匹配答案:"+ ans_txt);}
1143 |       if (right_xuan != '' && duizhan_mode != "shoudong") {
1144 |         let idx = idx_dict[right_xuan];
1145 |         fInfo("最终:"+ right_xuan);
1146 |         try {className("android.widget.RadioButton").findOnce(idx).parent().click();}
1147 |         catch (e) {
1148 |           idx = idx_dict[right_xuan2];
1149 |           fInfo("备选:"+ right_xuan2);
1150 |           try {className("android.widget.RadioButton").findOnce(idx).parent().click();}
1151 |           catch (e1) {
1152 |             log("error3:", e1);
1153 |             err_flag = false;
1154 |             sleep(200);
1155 |             continue;
1156 |           }
1157 |         }
1158 |         //log(a);
1159 |       } else if (duizhan_mode == "shoudong") {
1160 |         textMatches(/第.+题|继续挑战/).waitFor();
1161 |       }
1162 |       else {
1163 |         try {className("android.widget.RadioButton").findOnce().parent().click();}
1164 |         catch (e1) {
1165 |           log("error4:", e1);
1166 |           err_flag = false;
1167 |           sleep(200);
1168 |           continue;
1169 |         }
1170 |       }
1171 |     }
1172 |     else {
1173 |       console.warn("未识别出选项");
1174 |       err_flag = false;
1175 |       sleep(200);
1176 |       continue;
1177 |     }
1178 |     num++;
1179 |   }
1180 | }
1181 | 
1182 | // 对战答错版
1183 | function dacuo(renshu) {
1184 |   jifen_list = refind_jifen();
1185 |   if (renshu == 2) {
1186 |     // 点击进入双人对战
1187 |     jifen_list.child(9).child(3).click();
1188 |     text("随机匹配").waitFor();
1189 |     sleep(1000);
1190 |     text("随机匹配").findOne().parent().child(0).click();
1191 |   }
1192 |   else if (renshu == 4) {
1193 |     // 点击进入四人赛
1194 |     jifen_list.child(8).child(3).click();
1195 |     // 等待开始比赛并点击
1196 |     fInfo("等待开始比赛");
1197 |     sleep(1000);
1198 |     let start_click = text("开始比赛").findOne().click();
1199 |     log("点击："+start_click);
1200 |   }
1201 |   //fInfo("等待开始过渡");
1202 |   //text("开始").findOne(1000);
1203 |   className("android.widget.ListView").waitFor();
1204 |   let num = 1;
1205 |   let err_flag = true;
1206 |   while (true) {
1207 |     // 如果是第一题或者下面出错，则跳过前面等待过渡
1208 |     if (num != 1 && err_flag) {
1209 |       // 检查到其中一个过渡界面为止
1210 |       while (true) {
1211 |         // 检测是否结束并退出
1212 |         if (text("继续挑战").exists()) {
1213 |           fInfo("本轮结束");
1214 |           sleep(1000);
1215 |           text("继续挑战").findOne().click();
1216 |           sleep(1500);
1217 |           back();
1218 |           if (renshu == 2) {
1219 |             text("退出").findOne().click();
1220 |           }
1221 |           text("登录").waitFor();
1222 |           ran_sleep();
1223 |           fClear();
1224 |           return true;
1225 |         }
1226 |         else if (text("第" + num + "题").exists()) {break;}
1227 |       }
1228 |       // 直到过渡界面消失，再匹配下一题
1229 |       //log("等待题号过渡");
1230 |       while (text("第" + num + "题").exists()) {} //sleep(100);
1231 |     }
1232 |     else if (!err_flag) {
1233 |       err_flag = true;
1234 |       if (text("继续挑战").exists()) {
1235 |         fInfo("本轮结束");
1236 |         sleep(1000);
1237 |         text("继续挑战").findOne().click();
1238 |         sleep(1500);
1239 |         back();
1240 |         if (renshu == 2) {
1241 |           text("退出").findOne().click();
1242 |         }
1243 |         text("登录").waitFor();
1244 |         ran_sleep();
1245 |         return true;
1246 |       }
1247 |     }
1248 |     //log("开始第"+num+"题，等待listview");
1249 |     //className("android.widget.ListView").waitFor();
1250 |     let listview = className("android.widget.ListView").findOne(1000);
1251 |     if (!listview) {
1252 |       //log("找不到listview");
1253 |       err_flag = false;
1254 |       sleep(200);
1255 |       continue;
1256 |     }
1257 |     sleep(100); // 追求极限速度，不知道会不会出错
1258 |     //log("find view_d28");
1259 |     // listview父框体
1260 |     let view_d28 = className("android.view.View").depth(28).indexInParent(0).findOne(1000);
1261 |     if (!view_d28) {
1262 |       //log("找不到view_d28");
1263 |       //log('far:', listview.parent());
1264 |       //log('garfa', listview.parent().parent());
1265 |       err_flag = false;
1266 |       sleep(200);
1267 |       continue;
1268 |     }
1269 |     if (view_d28.childCount() > 0) {
1270 |       que_x = view_d28.bounds().left;
1271 |       que_y = view_d28.bounds().top;
1272 |       que_w = view_d28.bounds().width();
1273 |       que_h = view_d28.child(0).bounds().bottom - view_d28.bounds().top;
1274 |     }
1275 |     else {
1276 |       toastLog("找不到框体内容");
1277 |       //log(view_d28.childCount(), view_d28.bounds());
1278 |       err_flag = false;
1279 |       sleep(200);
1280 |       continue;
1281 |     }
1282 |     let idx_dict = {"A": 0, "B": 1, "C": 2, "D": 3};
1283 |     try { //防止别人先答完出错
1284 |       while (className("android.widget.ListView").findOne(1000).indexInParent() == 0) {}
1285 |       sleep(random(2000, 3000));
1286 |       //log("选项显现");
1287 |       className("android.widget.RadioButton").findOnce(random(0,3)).parent().click();
1288 |       num++;
1289 |       continue;
1290 |     }
1291 |     catch (e) {
1292 |       //log("error1:", e);
1293 |       err_flag = false;
1294 |       sleep(200);
1295 |       continue;
1296 |     }
1297 |     num++;
1298 |   }
1299 | }
1300 | 
1301 | /********订阅*********/
1302 | function do_dingyue() {
1303 | //   jifen_list = refind_jifen();
1304 |   jifen_list.child(10).child(3).click();
1305 |   fSet("title", "订阅…");
1306 |   fClear();
1307 |   let tab1 = descContains("Tab").findOne(9000);
1308 |   if (!tab1) {back();text("登录").waitFor();return false}
1309 |   let zuo1 = descContains("上新").findOne(9000);
1310 |   if (!zuo1) {back();text("登录").waitFor();return false}
1311 |   // 上方标签
1312 |   let tab_clt = descContains("Tab").untilFind();
1313 |   let total_click = 0;
1314 |   for (let tab of tab_clt) {
1315 |     tab.click();
1316 |     sleep(500);
1317 |     // 左方分类
1318 |     let zuo_clt = className("android.view.View").depth(14).findOne().children();
1319 |     for (let zuo of zuo_clt) {
1320 |       if (dingyue_dao) {zuo = zuo_clt[zuo_clt.length-1];}
1321 |       zuo.click();
1322 |       sleep(500);
1323 |       // 右方列表
1324 |       className("android.view.View").depth(14).waitFor();
1325 |       let you_clt = className("android.view.View").depth(14).findOnce(1);
1326 |       let last_desc = "";
1327 |       while (you_clt) {
1328 |         //let img = captureScreen();
1329 |         // 订阅按钮集合
1330 |         //fInfo("查找订阅集合");
1331 |         let dingyue_clt = className("android.widget.ImageView").indexInParent(2).untilFind();
1332 |         try {
1333 |           //fInfo(dingyue_clt[dingyue_clt.length-1].parent().child(1).desc().slice(0,4)+" 旧:"+last_desc.slice(0,4));
1334 |           if (dingyue_clt[dingyue_clt.length-1].parent().child(1).desc() == last_desc) {
1335 |             fClear();
1336 |             fInfo("到底了");
1337 |             break;
1338 |           }
1339 |           // 最底下订阅的名称
1340 |           last_desc = dingyue_clt[dingyue_clt.length-1].parent().child(1).desc();
1341 |         }
1342 |         catch (e) {log(e); continue;}
1343 |         let img = captureScreen();
1344 |         for (let dingyue of dingyue_clt) {
1345 |           if (dingyue.bounds().bottom >= device_h) {continue;}
1346 |           try {
1347 |             var pot = findColorInRegion(img, "#E42417", dingyue.bounds().left, dingyue.bounds().top,
1348 |                                         dingyue.bounds().width(), dingyue.bounds().height(), 30);
1349 |           } catch(e) { 
1350 |             console.error(dingyue.bounds());
1351 |             console.error(dingyue.parent().child(1).desc());
1352 |           }
1353 |           //if (pot && dingyue.bounds().bottom < device_h) {
1354 |           if (pot) {
1355 |             fInfo("找到一个订阅");
1356 |             sleep(1000);
1357 |             let is_click = dingyue.click();
1358 |             fInfo("点击："+ is_click);
1359 |             //click(dingyue.bounds().centerX(), dingyue.bounds().centerY());
1360 |             sleep(1000);
1361 |             //click(pot.x, pot.y+5);
1362 |             total_click += 1;
1363 |           }
1364 |           if (total_click >= 2) {
1365 |             fInfo("订阅已完成");
1366 |             back();
1367 |             text("登录").waitFor();
1368 |             ran_sleep();
1369 |             return true;
1370 |           }
1371 |         }
1372 |         //img.recycle();
1373 |         let scr_result = you_clt.scrollForward();
1374 |         sleep(500);
1375 | //         swipe(device_w*0.6, device_h*0.8, device_w*0.6, device_h*0.3, 800);
1376 | //         while (desc("加载中").exists()) { sleep(1000); }
1377 |       }
1378 |       if (dingyue_dao) {fInfo("只检查年度上新");break;}
1379 |     }
1380 |     //sleep(1000);
1381 |   }
1382 |   fInfo("无可订阅项目");
1383 |   back();
1384 |   text("登录").waitFor();
1385 |   ran_sleep();
1386 |   return true;
1387 | }
1388 | 
1389 | /*********本地*********/
1390 | function do_bendi() {
1391 | //   jifen_list = refind_jifen();
1392 |   jifen_list.child(13).child(3).click();
1393 |   fSet("title", "本地…");
1394 |   fClear();
1395 |   text("切换地区").findOne(5000);
1396 |   if (text("立即切换").exists()) {
1397 |     text("取消").findOne(3000).click();
1398 |   }
1399 |   //let banner = className("android.support.v7.widget.RecyclerView").findOne();
1400 |   let banner = classNameContains("RecyclerView").findOne();
1401 |   let txt = banner.child(0).child(1).text();
1402 |   banner.child(0).click();
1403 |   className("android.widget.TextView").depth(11).text(txt).waitFor();
1404 |   sleep(1500);
1405 |   back();
1406 |   ran_sleep();
1407 |   jifen_init();
1408 |   ran_sleep();
1409 |   return true;
1410 | }
1411 | /**************************************上方为执行各项目函数*********************************************/
1412 | 
1413 | 
1414 | 
1415 | // 做一次题
1416 | function do_exec(type) {
1417 |   // 等待加载
1418 |   let tishi = text("查看提示").findOne();
1419 |   //log(tishi);
1420 |   // 点击查看提示按钮
1421 |   tishi.click();
1422 |   // 随机延迟、等待提示
1423 |   ran_sleep();
1424 |   // 等待加载
1425 |   text("提示").waitFor();
1426 |   
1427 |   // 判断题型
1428 |   /******************单选题*******************/
1429 |   if (textStartsWith("单选题").exists()) {
1430 |     // 获取题目
1431 | 		//let que_txt = className("android.view.View").depth(23).findOnce(1).text();
1432 |     // 上面被专项答题影响了22、23层的元素数，只能通过其他层定位
1433 |     let que_txt = className("android.view.View").depth(24).findOnce(1).parent().parent().child(1).text();
1434 |     // log(que_txt);
1435 |     var ans = get_ans_by_re(que_txt);
1436 |     if (ans && depth(26).text(ans).exists()) {
1437 |       // 定位选项并点击
1438 |       depth(26).text(ans).findOnce().parent().click();
1439 |     }
1440 |     //else if (ans = get_ans_by_http_dati(que_txt)) {
1441 |     else {
1442 |       if (type) {ans = get_ans_by_dati_tiku(que_txt, type);}
1443 |       else {ans = get_ans_by_dati_tiku(que_txt);}
1444 |       let reg = /[A-F]/;
1445 |       if (ans && reg.test(ans) && ans.length == 1) {
1446 |         ans = ans.match(reg)[0];
1447 |         let idx_dict = {"A": 0, "B": 1, "C": 2, "D": 3, "E": 4, "F": 5};
1448 |         className("android.widget.RadioButton").findOnce(idx_dict[ans[0]]).parent().click();
1449 |       }
1450 |       // 否则用ocr
1451 |       else {
1452 |         if (!ans) {ans = get_ans_by_ocr1().replace(/\s/g, "");}
1453 |         if (depth(26).text(ans).exists()) {
1454 |           depth(26).text(ans).findOne().parent().click();
1455 |         }
1456 |         else {
1457 |           // 筛选出相似度最大的
1458 |           let xuan_clt = className("android.widget.RadioButton").find();
1459 |           let max_simi = 0;
1460 |           let xuanxiang = null;
1461 |           for (let n of xuan_clt) {
1462 |             let similar = str_similar(ans, n.parent().child(2).text());
1463 |             if (similar > max_simi) {
1464 |               max_simi = similar;
1465 |               xuanxiang = n.parent();
1466 |             }
1467 |           }
1468 |           //点击选项
1469 |           if (xuanxiang) {xuanxiang.click();}
1470 |           else {className("android.widget.RadioButton").findOne().parent().click();}
1471 |           //log(xuanxiang.find().size());
1472 |         }
1473 |       }
1474 |     }
1475 |   }
1476 |   /******************填空题*******************/
1477 |   else if (textStartsWith("填空题").exists()) {
1478 |     // 填空题题干会被空格分割
1479 |     //let que = className("android.view.View").depth(23).findOnce(1).children();
1480 |     // 上面被专项答题影响了22、23层的元素数，只能通过其他层定位
1481 |     let que = className("android.view.View").depth(24).findOnce(1).parent().parent().child(1).children();
1482 |     // 第一个编辑框的父元素
1483 |     let text_edit = className("android.widget.EditText").findOne().parent().children();
1484 |     // 第一个空答案字数，后期考虑换成全部答案字数
1485 |     let word_num = text_edit.find(className("android.view.View")).length;
1486 |     // 填空数
1487 |     let kong_num = 0;
1488 |     let que_txt = "";
1489 |     for (let i of que) {
1490 |       // 如果没有text则加个空格
1491 |       if (i.text()) {que_txt = que_txt + i.text();}
1492 |       else {
1493 |         kong_num += 1;
1494 |         que_txt = que_txt + "    ";
1495 |       }
1496 |     }
1497 |     // log(que_txt);
1498 |     // log("kong_num:", kong_num);
1499 |     // 判断是否只有一个空，re只能得出第一空答案
1500 |     if (kong_num <= 1) {
1501 |       //一个空时，先正则匹配，再题库匹配，以防题库出错，最后OCR
1502 |       //var ans = get_ans_by_http_dati(que_txt);
1503 |       if (type) {ans = get_ans_by_dati_tiku(que_txt, type);}
1504 |       else {ans = get_ans_by_dati_tiku(que_txt);}
1505 |       if (!ans) {ans = get_ans_by_re(que_txt);}
1506 |       //长度和空格数相等才会填充
1507 |       if (ans && word_num == ans.length) {
1508 |         // 定位填空并填入
1509 |         depth(25).className("android.widget.EditText").findOne().setText(ans);
1510 |       }
1511 |       else {
1512 |         ans = get_ans_by_ocr1().replace(/\s/g, "");
1513 |         if (!ans) {ans = "未识别出文字";}
1514 |         depth(25).className("android.widget.EditText").setText(ans);
1515 |       }
1516 |     }
1517 |     // 如果多个空，直接ocr按顺序填入
1518 |     else {
1519 |       //ans = get_ans_by_http_dati(que_txt);
1520 |       if (type) {ans = get_ans_by_dati_tiku(que_txt, type);}
1521 |       else {ans = get_ans_by_dati_tiku(que_txt);}
1522 |       if (!ans) {ans = get_ans_by_ocr1().replace(/\s/g, "");}
1523 |       if (!ans) {ans = "未识别出文字";}
1524 |       edit_clt = className("android.widget.EditText").find();
1525 |       for (let edit of edit_clt) {
1526 |         let n = edit.parent().children().find(className("android.view.View")).length;
1527 |         edit.setText(ans.slice(0, n));
1528 |         ans = ans.slice(n);
1529 |       }
1530 |     }
1531 |   }
1532 |   /******************多选题*******************/
1533 |   else if (textStartsWith("多选题").exists()) {
1534 |     // 获取题目
1535 | 		// let que_txt = className("android.view.View").depth(23).findOnce(1).text();
1536 |     // 上面被专项答题影响了22、23层的元素数，只能通过其他层定位
1537 |     let que_txt = className("android.view.View").depth(24).findOnce(1).parent().parent().child(1).text();
1538 |     // log(que_txt);
1539 |     // 这里匹配出全部挖空
1540 |     let reg1 = /\s{3,}/g;
1541 |     let res = que_txt.match(reg1);
1542 |     // log(res);
1543 |     // 先看挖空数量和选项数量是否一致，判断是否全选
1544 |     let collect = className("android.widget.CheckBox").find();
1545 |     // 如果全选
1546 |     if (res.length == collect.length) {
1547 |       ans = "全选";
1548 |       for (let n of collect) {
1549 |         // 直接点击会点不上全部
1550 |         n.parent().click();
1551 |       }
1552 |     }
1553 |     //else if (ans = get_ans_by_http_dati(que_txt)) {
1554 |     else {
1555 |       if (type) {ans = get_ans_by_dati_tiku(que_txt, type);}
1556 |       else {ans = get_ans_by_dati_tiku(que_txt);}
1557 |       let reg = /[A-F]{1,6}/;
1558 |       if (ans && reg.test(ans)) {
1559 |         ans = ans.match(reg)[0];
1560 |         let idx_dict = {"A": 0, "B": 1, "C": 2, "D": 3, "E": 4, "F": 5};
1561 |         for (let n of ans) {
1562 |           className("android.widget.CheckBox").findOnce(idx_dict[n]).parent().click();
1563 |         }
1564 |       }
1565 |       // 如果不是全选
1566 |       else {
1567 |         ans = get_ans_by_ocr1();
1568 |         // 下面为匹配子串法
1569 |         ans = ans.replace(/[^\u4e00-\u9fa5\w]/g, "");
1570 |         log(ans);
1571 |         for (let n of collect) {
1572 |           let xuan_txt = n.parent().child(2).text().replace(/[^\u4e00-\u9fa5\w]/g, "");
1573 |           if (ans.indexOf(xuan_txt) >= 0) {
1574 |             n.parent().click();
1575 |           }
1576 |         }
1577 |       }
1578 |     }
1579 |   }
1580 |   fInfo("答案："+ans);
1581 |   // 返回退出查看提示界面
1582 |   back();
1583 |   sleep(1000);
1584 |   return true;
1585 | }
1586 | 
1587 | // 通过re匹配答案
1588 | function get_ans_by_re(que_txt) {
1589 |   // 定位挖空两侧字符，限制在两个标点符号内
1590 |   let reg1 = /([^，。？、；：” ]*?)\s{3,}([^，。？、；：” ]*)/;
1591 |   let res = que_txt.match(reg1);
1592 |   if (res[1] == '' && res[2] == '') {
1593 |     reg1 = /([^，。？、；：” ]*?[，。？、；：” ]*?)\s{3,}([，。？、；：” ]*?[^，。？、；：” ]*)/;
1594 |     res = que_txt.match(reg1);
1595 |   }
1596 |   // log(res);
1597 |   // 生成正则表达式
1598 |   let reg2_str = "/" + res[1] + "([^，。？、；：” ]*)" + res[2] + "/";
1599 |   let reg2 = eval(reg2_str);
1600 |   // log(reg2);
1601 |   // 获取试题信息、匹配答案
1602 |   // let tishi_txt = className("android.view.View").depth(23).findOnce(6).text();
1603 |   // 上面的查找方式会被出题方干扰
1604 |   // let tishi_txt = className("android.view.View").depth(22).findOnce(2).child(0).text();
1605 |   // 上面的层次在专项答题中出现变化
1606 |   let tishi_txt = text("提示").findOne().parent().parent().child(1).child(0).text();
1607 |   //log(tishi_txt);
1608 |   // 如果匹配到答案
1609 |   if (tishi_txt.match(reg2)) {
1610 |     let ans = tishi_txt.match(reg2)[1];
1611 |     log(ans);
1612 |     return ans;
1613 |   }
1614 |   else {return 0;}
1615 | }
1616 | 
1617 | // 通过ocr匹配答案
1618 | function get_ans_by_ocr1() {
1619 |   // 定位提示框位置
1620 |   //let tishi_box = className("android.view.View").depth(22).findOnce(2).child(0).bounds();
1621 |   // 上面的层次在专项答题中出现变化
1622 |   let tishi_box = text("提示").findOne().parent().parent().child(1).child(0).bounds();
1623 |   fInfo('开始截屏');
1624 |   let img = captureScreen();
1625 |   // 控制截图范围
1626 |   img = images.clip(img, tishi_box.left-10, tishi_box.top-10, tishi_box.width()+20, tishi_box.height());
1627 |   //images.save(img, '/sdcard/1/1.png');
1628 |   // 二值化
1629 |   img = images.interval(img, "#FD1111", 120);  //比inRange()好用多了
1630 |   //images.save(img, '/sdcard/1/2.png');
1631 |   let ans = "";
1632 | //   let resp = ocr.recognize(img).results;
1633 | //   ans = ocr_rslt_to_txt(resp);
1634 |   // 为适配第三方OCR改动
1635 |   ans = ocr.recognizeText(img);
1636 |   if (!ans) {fInfo("未识别出文字");}
1637 |   else {log(ans);} 
1638 |   img.recycle();
1639 |   return ans;
1640 | }
1641 | 
1642 | // 通过http请求匹配答案
1643 | function get_ans_by_http(que_txt) {
1644 |   // 匹配题空两边汉字、字母及数字
1645 |   let reg = /[\u4e00-\u9fa5\d]+/g;
1646 |   //let reg = /(\S*)\s{2,}(\S*)/;
1647 |   let res = que_txt.match(reg);
1648 |   if (res == null) {return [];}
1649 |   // 此处可以加个判断，不然截图没截好时会有bug
1650 |   // 选取长的一边并控制在十个字
1651 |   let longest = '';
1652 |   for (let r of res) {
1653 |     if (r.length > longest.length && r.indexOf("中华人民共和") < 0 && r.indexOf("习近平总书记") < 0) {
1654 |       longest = r;
1655 |     }
1656 |   }
1657 |   let keyword = longest.slice(0, 6);
1658 |   log(keyword);
1659 |   // 获取答案html并解析
1660 |   let req = http.get('http://www.syiban.com/search/index/init.html?modelid=1&q=' + encodeURI(keyword));
1661 |   let resp_str = req.body.string();
1662 |   let resp_list = resp_str.match(/答案：(.*?)<\/span><\/p>/g);
1663 |   let ans_list = [];
1664 |   if (resp_list != null) {
1665 |     for (let a of resp_list) {
1666 |       // 查找出来后答案中有不可见的ZERO WIDTH SPACE，需要清洗
1667 |       ans = a.match(/答案：(.*?)<\/span><\/p>/)[1].replace(/[\u200B-\u200D\uFEFF]/g, "");
1668 |       //log(ans);
1669 |       ans_list.push(ans);
1670 |     }
1671 |   }
1672 |   //log(ans_list);
1673 |   return ans_list;
1674 | }
1675 | 
1676 | // 通过离线答题题库匹配答案
1677 | function get_ans_by_dati_tiku(que_txt, type) {
1678 |   let keyword = que_txt.replace(/\s/g, "");
1679 |   let ans_list = [];
1680 |   let ans = null;
1681 |   if (dati_tiku.length == 0) {return false;}
1682 |   //for (let ti of dati_tiku) {
1683 |   for (let i = dati_tiku.length - 1; i >= 0; i--) {
1684 |     let ti = dati_tiku[i];
1685 |     if (ti[0].indexOf(keyword) > -1) {
1686 |       ans = ti[1];
1687 |       if (ans != "None") {ans_list.push(ans);}
1688 |     }
1689 |   }
1690 |   //if (!ans || ans == "None") {return false;}
1691 |   if (!ans_list) {return false;}
1692 |   if (type && ans_list.length > 1) {
1693 |     for (let a of ans_list) {
1694 |       if (a.indexOf(type) > -1) {
1695 |         ans = a.replace(type, "");
1696 |         break;
1697 |       }
1698 |     }
1699 |   }
1700 |   log("匹配题库：", ans);
1701 |   return ans;
1702 | }
1703 | 
1704 | // 通过http请求匹配答题答案
1705 | function get_ans_by_http_dati(que_txt) {
1706 |   // 获取答案html并解析
1707 |   let keyword = que_txt.replace(/\s/g, "");
1708 |   let req = http.get('https://tiku.3141314.xyz/search?table_name=tiku&page=1&rows=20&keyword=' + encodeURI(keyword));
1709 |   let resp_json = req.body.json();
1710 |   if (resp_json["total"] == 0) {return false;}
1711 |   let rows = resp_json["rows"];
1712 |   log(rows[0]);
1713 |   let ans_list = [];
1714 |   let ans = rows[0]["answer"];
1715 |   if (ans == "None") {return false;}
1716 |   //log(ans_list);
1717 |   return ans;
1718 | }
1719 | 
1720 | // 检测|更新离线题库
1721 | function update_dati_tiku() {
1722 | //   let total_req = http.get("https://tiku.3141314.xyz/tableCount");
1723 |   let total = 1;
1724 |   let last_dati_tiku_link = storage.get("dati_tiku_link", "");
1725 |   let dati_tiku = storage.get('dati_tiku', []);
1726 | //   if (total_req.statusCode == 200) {
1727 | //     total = total_req.body.json()[0][0];
1728 | //   } else {
1729 |   try {
1730 |     //dati_tiku = get_tiku_by_ct('https://webapi.ctfile.com/get_file_url.php?uid=35157972&fid=555754562&file_chk=94c3c662ba28f583d2128a1eb9d78af4&app=0&acheck=2&rd=0.14725283060014105');
1731 |     //dati_tiku = get_tiku_by_gitee('https://gitee.com/songgedodo/songge_tiku/raw/master/dati_tiku.txt');
1732 |     if (update_info["dati_tiku_link"] != last_dati_tiku_link) {
1733 |       try {dati_tiku = get_tiku_by_http(update_info["dati_tiku_link"]);}
1734 |       catch (e) {dati_tiku = get_tiku_by_http(update_info["dati_tiku_link2"]);}
1735 |       storage.put("dati_tiku_link", update_info["dati_tiku_link"]);
1736 |       storage.put('dati_tiku', dati_tiku);
1737 |       fInfo("已更新离线题库");
1738 |     }
1739 |     else {fInfo("未检测到题库更新，已用历史题库");}
1740 |     return dati_tiku
1741 |   } catch (e) {
1742 |     console.warn(e);
1743 |     if (dati_tiku) {
1744 |       fInfo("未识别出离线题库，已用历史题库");
1745 |       return dati_tiku
1746 |     }
1747 |   }
1748 | //   } 上面else的}
1749 |   //log("update total:", total);
1750 |   if (!dati_tiku || dati_tiku.length != total) {
1751 |     let req = http.get("https://tiku.3141314.xyz/getAnswer");
1752 |     if (req.statusCode == 200) {
1753 |       dati_tiku = req.body.json();
1754 |       storage.put('dati_tiku', dati_tiku);
1755 |       fInfo("题库已更新");
1756 |     }
1757 |     else {
1758 |       fInfo("网络问题识别不出在线题库");
1759 |     }
1760 |   }
1761 |   return dati_tiku;
1762 | }
1763 | 
1764 | //上传错题
1765 | function upload_wrong_exec(endstr) {
1766 |   text("答案解析").waitFor();
1767 |   let que_txt = "";
1768 |   if (textStartsWith("填空题").exists()) {
1769 |     let que = className("android.view.View").depth(24).findOnce(1).parent().parent().child(1).children();
1770 |     for (let i of que) {
1771 |       // 如果没有text则加个空格
1772 |       if (i.text()) {que_txt = que_txt + i.text();}
1773 |       else {
1774 |         que_txt = que_txt + "    ";
1775 |       }
1776 |     }
1777 |   }
1778 |   else {
1779 |     que_txt = className("android.view.View").depth(24).findOnce(1).parent().parent().child(1).text();
1780 |   }
1781 |   let ans_txt = textStartsWith("正确答案：").findOne().text().replace(/正确答案：|\s+/g, "");
1782 |   let question = que_txt.replace(/\s/g, "");
1783 |   if (endstr) {ans_txt += endstr;}
1784 |   fError("错题:" + question + ans_txt);
1785 |   //dati_tiku.unshift([question, ans_txt, null, null, null]);
1786 |   dati_tiku.push([question, ans_txt, null, null, null]);
1787 |   try {
1788 |   	updateToServer(question,ans_txt);
1789 |   }
1790 |   catch (e) {log(e);}
1791 | }
1792 | 
1793 | // 上传题目：
1794 | function updateToServer(question,answer) {
1795 |   fInfo("开始上传");
1796 |   var res = http.post("https://tiku.3141314.xyz/insertOrUpdate", 
1797 |                       {"question": question,"answer": answer, "pswd": "X2417481092ZY"});
1798 |   if (res.body.json()==200) {
1799 |     fInfo("成功");
1800 |     return true;
1801 |   }
1802 |   else {
1803 |     log(res.body.string());
1804 |     return false;
1805 |   }
1806 | }
1807 | 
1808 | // 通过缓存题库获取答案
1809 | function get_ans_by_tiku(que_txt) {
1810 |   let ans_list = [];
1811 |   let max_simi = 0;
1812 |   for (let ti of Object.keys(tiku)) {
1813 |     //log(ti.replace(/[\s_]/g, "").indexOf(que_txt));
1814 |     let ti_txt = ti.replace(/\[.+\]|^\d+\./g, "").replace(/[^\u4e00-\u9fa5\d]/g, "");
1815 |     //log(ti_txt);
1816 |     let len = que_txt.length;
1817 |     //let simi = str_similar(ti_txt.slice(0, len+6), que_txt);
1818 |     let simi = str_similar(ti_txt.slice(0, len), que_txt);
1819 |     //if (ti_txt.indexOf(que_txt) >= 0) {
1820 |     if (simi >= 0.25) {
1821 |       if (simi > max_simi) {
1822 |         ans_list.length = 0;
1823 |         ans_list.push(tiku[ti][1]);
1824 |         max_simi = simi;
1825 |       }
1826 |       else if (simi == max_simi) {ans_list.push(tiku[ti][1]);}
1827 |     }
1828 |   }
1829 |   return ans_list;
1830 | }
1831 | 
1832 | // 获取直链json
1833 | function get_tiku_by_http(link) {
1834 |   // 通过gitee的原始数据保存题库
1835 |   if (!link) {link = "https://gitee.com/songgedodo/songge_tiku/raw/master/tiku_json.txt"}
1836 |   let req = http.get(link);
1837 |   // log(req.statusCode);
1838 |   // 更新题库时若获取不到，则文件名+1
1839 |   if (req.statusCode != 200) {
1840 |     fError("网络错误，获取资源失败，退出脚本");
1841 |     exit();
1842 |     return false;
1843 |   }
1844 |   return req.body.json();
1845 | }
1846 | 
1847 | // 获取gitee题库
1848 | function get_tiku_by_gitee(link) {
1849 |   // 通过gitee的原始数据保存题库
1850 |   if (!link) {link = "https://gitee.com/songgedodo/songge_tiku/raw/master/tiku_json.txt"}
1851 |   let req = http.get(link);
1852 |   log(req.statusCode);
1853 |   // 更新题库时若获取不到，则文件名+1
1854 |   if (req.statusCode != 200) {
1855 |     link2 = link.replace(/(\w+)(?=\.txt)/, "$1"+"1");
1856 |     log(link2);
1857 |     req = http.get(link2);
1858 |   }
1859 |   return req.body.json();
1860 | }
1861 | 
1862 | // 获取城通网盘题库
1863 | function get_tiku_by_ct(link) {
1864 |   // 获取答案html并解析
1865 |   // 城通网盘解析
1866 |   if (!link) {link = "https://webapi.ctfile.com/get_file_url.php?uid=35157972&fid=546999609&file_chk=e83f4b72a2f142cca6ee87c64baba15c&app=0&acheck=2&rd=0.9023931062078081"}
1867 |   let req = http.get(link);
1868 | //   let resp_str = req.body.string();
1869 | //   let result = eval("("+ resp_str + ")");
1870 |   let result = req.body.json();
1871 |   let file = http.get(result["downurl"]);
1872 | //   return eval("("+ file.body.string() + ")");
1873 |   return file.body.json();
1874 | }
1875 | 
1876 | // 把ocr结果转换为正序的字符串
1877 | function ocr_rslt_to_txt(result) {
1878 |   let top = 0;
1879 |   let previous_left = 0;
1880 |   let txt = "";
1881 |   let txt_list = [];
1882 |   for (let idx in result) {
1883 |     if (top == 0) {top = result[idx].bounds.top;}
1884 |     if (previous_left == 0) {previous_left = result[idx].bounds.left;}
1885 |     if (result[idx].bounds.top >= top-10 && result[idx].bounds.top <= top+10) {
1886 |       if (result[idx].bounds.left > previous_left) {txt = txt + "   " + result[idx].text;}
1887 |       else {txt = result[idx].text + "   " + txt;}
1888 |     }
1889 |     else {
1890 |       top = result[idx].bounds.top;
1891 |       txt_list.push(txt);
1892 |       txt = result[idx].text;
1893 |     }
1894 |     if (idx == result.length-1) {txt_list.push(txt);}
1895 |     previous_left = result[idx].bounds.left;
1896 |   }
1897 |   //每行直接加个换行
1898 |   let ans = txt_list.join("\n");
1899 |   //log(ans);
1900 |   return ans;
1901 | }
1902 | 
1903 | // 重启每日、每周
1904 | function restart(restart_flag) {
1905 |   // 点击退出
1906 |   ran_sleep();
1907 |   back();
1908 |   text("退出").findOne().click();
1909 |   ran_sleep();
1910 |   switch (restart_flag) {
1911 |       // 0为每日答题
1912 |     case 0:
1913 |       text('登录').waitFor();
1914 |       jifen_list.child(4).child(3).click();
1915 |       break;
1916 |       // 1为每周答题
1917 |     case 1:
1918 |       // 等待列表加载
1919 |       text('本月').waitFor();
1920 |       //当出现已作答时，点击最后一个未作答
1921 |       while (!text("已作答").exists()) {
1922 |         depth(21).scrollable().findOne().scrollForward();
1923 |         sleep(200);
1924 |       }
1925 |       var clt = text("未作答").find();
1926 |       clt[clt.length-1].parent().click();
1927 |       break;
1928 |   }
1929 | }
1930 | 
1931 | // 从首页进入积分界面初始化
1932 | function jifen_init() {
1933 |   id("comm_head_xuexi_score").findOne().click();
1934 |   while (true) {
1935 |     let denglu = className("android.view.View").depth(24).text("登录").findOne(9000);
1936 |     if (denglu) {break;}
1937 |     back();
1938 |     sleep(1000);
1939 |     id("comm_head_xuexi_score").findOne().click();
1940 |   }
1941 |   fRefocus();
1942 |   text("登录").waitFor();
1943 |   className("android.webkit.WebView").scrollable().findOne().scrollForward();
1944 |   //jifen_list = className("android.widget.ListView").depth(21).findOne();
1945 | }
1946 | 
1947 | // 模拟随机时间0.5-3秒，后期可以用户自定义
1948 | function ran_sleep() {
1949 |   return sleep(random(1000, delay_time));
1950 | }
1951 | 
1952 | // 比较两个字符串相似度
1953 | function str_similar(str1, str2) {
1954 |   str1 = str1.replace(/[^\u4e00-\u9fa5\u2460-\u2469\wāáǎàōóǒòēéěèīíǐìūúǔùüǖǘǚǜ]/g, "");
1955 |   str2 = str2.replace(/[^\u4e00-\u9fa5\u2460-\u2469\wāáǎàōóǒòēéěèīíǐìūúǔùüǖǘǚǜ]/g, "");
1956 |   if (str1 == str2) {return 99;}
1957 |   if (str1.length > str2.length) {
1958 |     var muzi = str2;
1959 |     var instr = str1;
1960 |   }
1961 |   else {
1962 |     muzi = str1;
1963 |     instr = str2;
1964 |   }
1965 |   let reg = "/[" + muzi + "]{1}/g";
1966 |   let resu = instr.match(eval(reg));
1967 | 	if (resu) {
1968 |     return (resu.length / instr.length);
1969 |   }
1970 | 	else {return 0;}
1971 | }
1972 | 
1973 | // 关闭音乐浮动插件
1974 | function close_video() {
1975 |   let imv = className("android.widget.ImageView").find();
1976 |   //log(imv.empty());
1977 |   let swtch = imv[imv.length-1];
1978 |   swtch.click();
1979 |   sleep(1000);
1980 |   swtch.click();
1981 |   return true;
1982 | }
1983 | 
1984 | // 屏幕宽高、方向初始化
1985 | function init_wh() {
1986 |   fInfo("屏幕方向检测");
1987 |   log(device.width + "*" + device.height);
1988 |   var device_w = depth(0).findOne().bounds().width();
1989 |   var device_h = depth(0).findOne().bounds().height();
1990 |   log(device_w + "*" + device_h);
1991 |   if (device.width == device_h && device.height == device_w) {
1992 |     fError("设备屏幕方向检测为横向，后续运行很可能会报错，建议调整后重新运行脚本");
1993 |     sleep(10000);
1994 |   }
1995 |   else if (device.width == 0 || device.height == 0) {
1996 |     fError("识别不出设备宽高，建议重启hamibot后重新运行脚本");
1997 |     sleep(10000);
1998 |   }
1999 |   return [device_w, device_h]
2000 | }
2001 | 
2002 | // 尝试成功点击
2003 | function real_click(obj) {
2004 |   for (let i=1; i<=3; i++) {
2005 |     if (obj.click()) {log("real click: true"); return true;}
2006 |     sleep(300);
2007 |   }
2008 |   console.warn("控件无法正常点击：", obj);
2009 |   log("尝试再次点击");
2010 |   click(obj.bounds().centerX(), obj.bounds().centerY());
2011 |   return false;
2012 | }
2013 | 
2014 | // 测试ocr功能
2015 | function ocr_test() {
2016 |   if (Number(ocr_maxtime)) {
2017 |     var test_limit = Number(ocr_maxtime);
2018 |   } else {
2019 |     var test_limit = 5000;
2020 |   }
2021 |   try {
2022 |     fInfo("测试ocr功能，开始截图");
2023 |     let img_test = captureScreen();
2024 |     img_test = images.clip(img_test, 0, 100, device_w, 250);
2025 |     log("开始识别");
2026 |     //console.time("OCR识别结束");
2027 |     let begin=new Date();
2028 |     let test_txt = ocr.recognizeText(img_test);
2029 |     //console.timeEnd("OCR识别结束");
2030 |     let end=new Date();
2031 |     let test_time = end-begin;
2032 |     fInfo("OCR识别结束:"+test_time+"ms");
2033 |     if (test_time>test_limit) {
2034 |       fError("OCR识别过慢(>"+test_limit+"ms)，已跳过多人对战");
2035 |       fError("建议重启hamibot后重试");
2036 |       return false
2037 |     } else {
2038 |       fInfo("OCR功能正常");
2039 |       img_test.recycle();
2040 |       return true;
2041 |     }
2042 |   }
2043 |   catch (e) {
2044 |     fError(e+"：ocr功能异常，退出脚本");
2045 |     exit();
2046 |     return false;
2047 |   }
2048 | }
2049 | 
2050 | // pushplus推送
2051 | function send_pushplus(token, sign_list) {
2052 |   jinri = jifen_list.parent().child(1).text().match(/\d+/g)[0];
2053 |   zongfen = text("成长总积分").findOne().parent().child(3).text();
2054 |   let style_str = '<style>.item{height:1.5em;line-height:1.5em;}.item span{display:inline-block;padding-left:0.4em;}\
2055 | .item .bar{width:100px;height:10px;background-color:#ddd;border-radius:5px;display:inline-block;}\
2056 | .item .bar div{height:10px;background-color:#ed4e45;border-radius:5px;}</style>';
2057 |   let content_str = '<h6>今日已累积:'+jinri+'积分 总积分:'+zongfen+'</h6><div>';
2058 |   for (let sign of sign_list) {
2059 |   	if (sign == "ocr_false") { content_str = '由于ocr过慢，已跳过多人对战'+content_str; }
2060 |   }
2061 |   for (let option of jifen_list.children()) {
2062 |     let title = option.child(0).child(0).text();
2063 |     let score = option.child(2).text().match(/\d+/g)[0];
2064 |     let total = option.child(2).text().match(/\d+/g)[1];
2065 |     let percent = (Number(score)/Number(total)*100).toFixed() + '%';
2066 |     let detail = title+": "+score+"/"+total;
2067 |     content_str += '<div class="item"><div class="bar"><div style="width: '+percent+';"></div></div><span>'+detail+'</span></div>';
2068 |   }
2069 |   content_str += '</div>'+style_str;
2070 |   let r = http.postJson("http://www.pushplus.plus/send", {
2071 |     token: token,
2072 |     title: "天天向上："+name,
2073 |     content: content_str,
2074 |     template: "markdown",
2075 |   });
2076 |   if (r.body.json()["code"] == 200) {fInfo("推送成功");}
2077 |   else {log(r.body.json());}
2078 | }
2079 | 
2080 | // 发送email通知
2081 | function send_email(email) {
2082 |   let reg = /[\w!#$%&'*+/=?^_`{|}~-]+(?:\.[\w!#$%&'*+/=?^_`{|}~-]+)*@(?:[\w](?:[\w-]*[\w])?\.)+[\w](?:[\w-]*[\w])?/;
2083 |   let e_addr = email.match(reg);
2084 |   if (!e_addr) {
2085 |     fError("请配置正确的邮件格式");
2086 |     return false;
2087 |   }
2088 |   let zongfen = jifen_list.parent().child(1).text();
2089 |   let content = "用户" + name + "已完成：" + zongfen;
2090 |   var data=app.intent({action: "SENDTO"});
2091 |   data.setData(app.parseUri("mailto:"+e_addr));
2092 |   data.putExtra(Intent.EXTRA_SUBJECT, "天天向上："+name);
2093 |   data.putExtra(Intent.EXTRA_TEXT, content);
2094 |   app.startActivity(data);
2095 |   return true;
2096 | }
2097 | 
2098 | // 强行退出应用名称
2099 | function exit_app(name) {
2100 |   // fClear();
2101 |   fInfo("尝试结束"+name+"APP");
2102 |   var packageName = getPackageName(name);
2103 |   if(!packageName){
2104 |     if(getAppName(name)){
2105 |       packageName = name;
2106 |     }else{
2107 |       return false;
2108 |     }
2109 |   }
2110 | 	log("打开应用设置界面");
2111 |   app.openAppSetting(packageName);
2112 |   var appName = app.getAppName(packageName);
2113 |   //log(appName);
2114 |   log("等待加载界面")
2115 |   //textMatches(/应用信息|应用详情/).findOne(5000);
2116 |   text(appName).findOne(5000);
2117 |   sleep(1500);
2118 |   log("查找结束按钮")
2119 |   //let stop = textMatches(/(^强行.*|.*停止$|^结束.*)/).packageNameMatches(/.*settings.*|.*securitycenter.*/).findOne();
2120 |   let stop = textMatches(/(强.停止$|.*停止$|结束运行|停止运行|[Ff][Oo][Rr][Cc][Ee] [Ss][Tt][Oo][Pp])/).findOne();
2121 |   log("stop:", stop.enabled())
2122 |   if (stop.enabled()) {
2123 |     //log("click:", stop.click());
2124 |     real_click(stop);
2125 |     sleep(1000);
2126 |     log("等待确认弹框")
2127 |     //let sure = textMatches(/(确定|^强行.*|.*停止$)/).packageNameMatches(/.*settings.*|.*securitycenter.*/).clickable().findOne();
2128 |     let sure = textMatches(/(确定|.*停止.*|[Ff][Oo][Rr][Cc][Ee] [Ss][Tt][Oo][Pp]|O[Kk])/).clickable().findOne(1500);
2129 |     if (!sure) {
2130 |       fInfo(appName + "应用已关闭");
2131 |       back();
2132 |       return false;
2133 |     }
2134 |     log("sure click:", sure.click());
2135 |     fInfo(appName + "应用已被关闭");
2136 |     sleep(1000);
2137 |     back();
2138 |   } else {
2139 |     fInfo(appName + "应用不能被正常关闭或不在后台运行");
2140 |     sleep(1000);
2141 |     back();
2142 |   }
2143 |   return true;
2144 | }
2145 | 
2146 | // 登录
2147 | function login(username, pwd) {
2148 |   var begin_obj = idMatches(/.*comm_head_xuexi_mine|.*btn_next/).findOne();
2149 |   if (begin_obj.text() == "登录") {
2150 |     log("查找ab");
2151 |     let a = className("EditText").id("et_phone_input").findOne();
2152 |     let b = className("EditText").id("et_pwd_login").findOne();
2153 |     a.setText(username);
2154 |     sleep(1000);
2155 |     b.setText(pwd);
2156 |     sleep(1000);
2157 |     begin_obj.click();
2158 |     sleep(3000);
2159 |     let packageName = getPackageName('学习强国');
2160 |     if (currentPackage() != packageName) {
2161 |       log("检测到弹窗，尝试返回");
2162 |       if (textMatches(/取消/).exists()) {
2163 |         textMatches(/取消/).findOne().click();
2164 |       }
2165 |       else {back();}
2166 |     }
2167 |   }
2168 | }
2169 | 
2170 | function refind_jifen() {
2171 |   let res = className("android.webkit.WebView").scrollable().findOne().scrollForward();
2172 |   //log(res);
2173 |   let jifen_obj = className("android.widget.ListView").depth(21).rowCount(15).findOne();
2174 |   return jifen_obj
2175 | }
2176 | 
2177 | function winReshow() {
2178 |   for (i=0;i<4;i++) {
2179 |     recents();
2180 |     sleep(1000);
2181 |   }
2182 | }
2183 | 
2184 | function noverify() {
2185 |   var noverify_thread = threads.start(function() {
2186 |     //在新线程执行的代码
2187 |     while (true) {
2188 |       text("访问异常").waitFor();
2189 |       fInfo("检测到滑动验证");
2190 |       var bound = idContains("nc_1_n1t").findOne().bounds();
2191 |       var hua_bound = text("向右滑动验证").findOne().bounds();
2192 |       var x_start = bound.centerX();
2193 |       var dx = x_start - hua_bound.left;
2194 |       var x_end = hua_bound.right - dx;
2195 |       var x_mid = (x_end-x_start)*random(5,8)/10 + x_start;
2196 |       var back_x = (x_end-x_start)*random(1,2)/10;
2197 |       var y_start = random(bound.top, bound.bottom);
2198 |       var y_end = random(bound.top, bound.bottom);
2199 |       log("y_start:", y_start, "x_start:", x_start, "x_mid:", x_mid, "x_end:", x_end);
2200 |       x_start = random(x_start-7, x_start);
2201 |       x_end = random(x_end, x_end+10);
2202 |       sleep(600);
2203 |       press(x_start, y_start, 200);
2204 |       sleep(200);
2205 |       gesture(random(350, 400), [x_start, y_start], [x_mid, y_end], [x_mid-back_x, y_start], [x_end, y_end]);
2206 |       //swipe(x_start, y_start, x_end, y_end, random(900,1000));
2207 |       fInfo("已完成滑动验证");
2208 |       sleep(1000);
2209 |       fClear();
2210 |     }
2211 |   });
2212 |   return noverify_thread;
2213 | }
2214 | // 更新内容弹窗
2215 | // function gengxin_show() {
2216 | //   var dlg = dialogs.build({
2217 | //     title: engine_version + "版更新内容", 
2218 | //     content: "请授予hamibot悬浮窗(显示在其他应用上层)权限\n更新只答四人赛版本，可以市场搜索 对战_test,运行测试后反馈给我",
2219 | //     positive: "确定", checkBoxPrompt: '不再提示',
2220 | //   }).show();
2221 | //   while (!dlg.isShowing()) {}
2222 | //   log("dialog showing");
2223 | //   while (dlg.isShowing()) {sleep(500);}
2224 | //   return dlg.promptCheckBoxChecked;
2225 | // }
2226 | 
2227 | // 显示一个对象的所有方法，不知道ocr的返回对象有啥方法
2228 | function displayProp(obj) {    
2229 |     var names="";
2230 |     for(var name in obj){
2231 |        names+=name+": "+obj[name]+", ";
2232 |     }
2233 |     log(names);
2234 | }
2235 | 
2236 | /*******************悬浮窗*******************/
2237 | function fInit() {
2238 |   // ScrollView下只能有一个子布局
2239 |   var w = floaty.rawWindow(
2240 |     <card cardCornerRadius='8dp' alpha="0.8">
2241 |       <vertical>
2242 |         <horizontal bg='#FF000000' padding='10 5'>
2243 |         <text id='version' textColor="#FFFFFF" textSize="18dip">天天向上+</text>
2244 |         <text id='title' h="*" textColor="#FFFFFF" textSize="13dip" layout_weight="1" gravity="top|right"></text>
2245 |         </horizontal>
2246 |         <ScrollView>
2247 |           <vertical bg='#AA000000' id='container' minHeight='20' gravity='center'></vertical>
2248 |         </ScrollView>
2249 |       </vertical>
2250 |     	<relative  gravity="right|bottom">
2251 |     		<text id="username" textColor="#FFFFFF" textSize="12dip" padding='5 0'></text>
2252 |     	</relative>
2253 |     </card>
2254 |   );
2255 |   ui.run(function() {
2256 |     //w.title.setFocusable(true);
2257 |     w.version.setText("天天向上+"+newest_version);
2258 |   });
2259 |   w.setSize(720, -2);
2260 |   w.setPosition(10, 10);
2261 |   w.setTouchable(false);
2262 |   return w;
2263 | }
2264 | 
2265 | function fSet(id, txt) {
2266 |   ui.run(function() {
2267 |     w.findView(id).setText(txt);
2268 |   });
2269 | }
2270 | 
2271 | function fInfo(str) {
2272 |   ui.run(function() {
2273 |     let textView = ui.inflate(
2274 |       <text id="info" maxLines="2" textColor="#7CFC00" textSize="15dip" padding='5 0'></text>,
2275 |       w.container);
2276 |     textView.setText(str);
2277 |     w.container.addView(textView);
2278 |   });
2279 |   console.info(str);
2280 | }
2281 | 
2282 | function fError(str) {
2283 |   ui.run(function() {
2284 |     let textView = ui.inflate(
2285 |       <text id="error" maxLines="2" textColor="#FF0000" textSize="15dip" padding='5 0'></text>,
2286 |       w.container);
2287 |     textView.setText(str);
2288 |     w.container.addView(textView);
2289 |   });
2290 |   console.error(str);
2291 | }
2292 | 
2293 | function fTips(str) {
2294 |   ui.run(function() {
2295 |     let textView = ui.inflate(
2296 |       <text id="tips" maxLines="2" textColor="#FFFF00" textSize="15dip" padding='5 0'></text>,
2297 |       w.container);
2298 |     textView.setText(str);
2299 |     w.container.addView(textView);
2300 |   });
2301 |   console.info(str);
2302 | }
2303 | 
2304 | function fClear() {
2305 |   ui.run(function() {
2306 |     w.container.removeAllViews();
2307 |   });
2308 | }
2309 | 
2310 | function fRefocus() {
2311 |   threads.start(function() {
2312 |     ui.run(function() {
2313 |       w.requestFocus();
2314 |       w.title.requestFocus();
2315 |       ui.post(function() {
2316 |         w.title.clearFocus();
2317 |         w.disableFocus();
2318 |       }, 200);
2319 |     });
2320 |   });
2321 |   sleep(500);
2322 | }
2323 | 
2324 | function xxqg(userinfo) {
2325 |   var sign_list = [];
2326 |   // 检测更新提示代码，出现就点掉
2327 |   fInfo("开始更新弹窗检测");
2328 |   var noupdate_thread = threads.start(function() {
2329 |     //在新线程执行的代码
2330 |     className("android.widget.Button").text("立即升级").waitFor();
2331 |     fInfo("检测到升级弹窗");
2332 |     sleep(1000);
2333 |     var btn = className("android.widget.Button").text("取消").findOne();
2334 |     btn.click();
2335 |     fInfo("已取消升级");
2336 |   });
2337 |   fInfo("开始消息通知弹窗检测");
2338 |   var nonotice_thread = threads.start(function() {
2339 |     //在新线程执行的代码
2340 |     className("android.widget.Button").text("去开启").waitFor();
2341 |     fInfo("检测到消息通知弹窗");
2342 |     sleep(1000);
2343 |     var btn = className("android.widget.Button").text("取消").findOne();
2344 |     btn.click();
2345 |     fInfo("已取消消息通知");
2346 |   });
2347 |   var noverify_thread = noverify();
2348 | //   var keepQG_thread = threads.start(function() {
2349 | //     //在新线程执行的代码
2350 | //     let packageName = getPackageName('学习强国');
2351 | //     while (true) {
2352 | //       try {
2353 | //         if (currentPackage() != packageName) {
2354 | //           fInfo("请切换回学习强国");
2355 | //         }
2356 | //         text("当做sleep方法").findOne(1000);
2357 | //       } catch (e) {console.warn(e);}
2358 | //     }
2359 | //   });
2360 |   /********登录*********/
2361 |   if (userinfo) {
2362 |     var [username, pwd, token] = userinfo;
2363 |     login(username, pwd);
2364 |   }
2365 |   /********获取用户姓名并读取本地数据*********/
2366 |   text("我的").findOne().click();
2367 |   name = id("my_display_name").findOne().text();
2368 |   storage_user = storages.create('songgedodo:'+name);
2369 |   fSet("username", name);
2370 |   back();
2371 |   ran_sleep();
2372 |   if (meizhou == "zhengxu") {meizhou_dao = false;}
2373 |   else if (meizhou == "daoxu") {meizhou_dao = true;}
2374 |   if (zhuanxiang == "zhengxu") {zhuanxiang_dao = false;}
2375 |   else if (zhuanxiang == "daoxu") {zhuanxiang_dao = true;}
2376 |   if (dingyue == "zhengxu") {dingyue_dao = false;}
2377 |   else if (dingyue == "daoxu") {dingyue_dao = true;}
2378 | 
2379 |   /********进入积分界面*********/
2380 |   // 点击积分
2381 |   id("comm_head_xuexi_score").findOne().click();
2382 |   // 等待"登录"项目加载
2383 |   // className("android.view.View").depth(24).text("登录").waitFor();
2384 |   text("登录").waitFor();
2385 |   // 往下滑一段加载
2386 |   //className("android.webkit.WebView").depth(18).findOne().scrollForward();
2387 |   // jifen_list第一层child[0-14]为每一项，第二层child{0:项目名称; 1:积分规则; 2:已获分数; 3:跳转按钮}
2388 |   jifen_list = refind_jifen();
2389 |   
2390 |   // 中断地理位置弹窗检测
2391 |   if (nolocate_thread.isAlive()) {
2392 |     nolocate_thread.interrupt();
2393 |     fInfo("终止位置权限弹窗检测");
2394 |   }
2395 |   // 中断更新弹窗检测
2396 |   if (noupdate_thread.isAlive()) {
2397 |     noupdate_thread.interrupt();
2398 |     fInfo("终止更新弹窗检测");
2399 |   }
2400 |   // 中断消息通知弹窗检测
2401 |   if (nonotice_thread.isAlive()) {
2402 |     nonotice_thread.interrupt();
2403 |     fInfo("终止消息通知检测");
2404 |   }
2405 | 
2406 |   // 先判断评论分享
2407 |   if (fenxiang == "true") {
2408 |     if (jifen_list.child(11).child(2).text().match(/\d+/)[0] == "0" || jifen_list.child(12).child(2).text().match(/\d+/)[0] == "0") {
2409 |       toastLog("开始分享和评论");
2410 |       do_fenxiang();
2411 |       jifen_list = refind_jifen();
2412 |     }
2413 |   }
2414 |   if (shipin == "true" && jifen_list.child(2).child(3).text() != "已完成") { // 视听学习
2415 |     console.verbose("无障碍服务："+auto.service);
2416 |     toastLog("开始视听次数");
2417 |     do_shipin();
2418 |     jifen_list = refind_jifen();
2419 |   }
2420 |   if (wenzhang == "true" && jifen_list.child(1).child(3).text() != "已完成") { // 文章
2421 |     console.verbose("无障碍服务："+auto.service);
2422 |     toastLog("开始文章次数与时长");
2423 |     do_wenzhang();
2424 |     jifen_list = refind_jifen();
2425 |   }
2426 |   if (meiri == "true" && jifen_list.child(4).child(3).text() != "已完成") { // 每日答题
2427 |     toastLog("每日答题开始");
2428 |     do_meiri();
2429 |     jifen_list = refind_jifen();
2430 |   }
2431 |   var meizhou_right = 1;
2432 |   if (meizhou != "false" && jifen_list.child(5).child(2).text().match(/\d+/)[0] == "0") { // 每周答题
2433 |     toastLog("每周答题开始");
2434 |     var meizhou_right = do_meizhou();
2435 |     while (!meizhou_right) {meizhou_right = do_meizhou();}
2436 |     jifen_list = refind_jifen();
2437 |   }
2438 |   var zhuanxiang_right = 1;
2439 |   if (zhuanxiang != "false" && jifen_list.child(6).child(2).text().match(/\d+/)[0] == "0") { // 专项答题
2440 |     toastLog("专项答题开始");
2441 |     var zhuanxiang_right = do_zhuanxiang();
2442 |     jifen_list = refind_jifen();
2443 |   }
2444 |   if (tiaozhan == "true" && jifen_list.child(7).child(3).text() != "已完成") { // 挑战答题
2445 |     toastLog("挑战答题开始");
2446 |     do_tiaozhan();
2447 |     jifen_list = refind_jifen();
2448 |   }
2449 |   // 四人赛前先ocr功能测试
2450 |   var test_result = ocr_test();
2451 |   if (test_result) {
2452 |     //console.verbose("无障碍服务："+auto.service);
2453 |     if (siren == "true" && parseInt(jifen_list.child(8).child(2).text().match(/\d+/)[0]) <= 3) { // 四人两次
2454 |       toastLog("四人赛开始");
2455 |       if (guaji) { do_duizhan1(0); }
2456 |       do_duizhan1(4);
2457 |       do_duizhan1(4);
2458 |       let dacuo_n = Number(dacuo_num);
2459 |       if (dacuo_n) {
2460 |         fSet("title", "平衡胜率…");
2461 |         fClear();
2462 |         console.info("开始平衡胜率，答错次数："+dacuo_n);
2463 |         for (i=0; i<dacuo_n; i++) {
2464 |           fInfo("答错第"+ (i+1) + "轮");
2465 |           dacuo(4);
2466 |           fClear();
2467 |         }
2468 |       }
2469 |       jifen_list = refind_jifen();
2470 |     }
2471 |     if (shuangren == "true" && jifen_list.child(9).child(2).text().match(/\d+/)[0] == "0") { // 双人对战
2472 |       toastLog("双人对战开始");
2473 |       do_duizhan1(2);
2474 |       jifen_list = refind_jifen();
2475 |     }
2476 |   } else if (siren == "true" && shuangren == "true") {
2477 |     sign_list.push("ocr_false");
2478 |   }
2479 |   if (bendi == "true" && jifen_list.child(13).child(3).text() != "已完成") {
2480 |     toastLog("本地开始");
2481 |     do_bendi();
2482 |     jifen_list = refind_jifen();
2483 |   }
2484 |   var dingyue_right = 1;
2485 |   if (dingyue != "false" && jifen_list.child(10).child(2).text().match(/\d+/)[0] == "0") { // 订阅
2486 |     toastLog("订阅开始");
2487 |     var dingyue_right = do_dingyue();
2488 |     jifen_list = refind_jifen();
2489 |   }
2490 |   
2491 |   if (meizhou != "false" && !meizhou_right) {
2492 |     fError("每周答题可能由于识别错误、包含视频题而不能满分，请手动作答");
2493 |   }
2494 |   if (dingyue != "false" && !dingyue_right) {
2495 |     fError("未能识别出订阅界面，订阅不支持学习强国V2.33.0以上版本");
2496 |   }
2497 |   // push+推送
2498 |   if (pushplus || token) {
2499 |     fInfo("推送前等待积分刷新5秒");
2500 |     sleep(5000);
2501 |     if (!token) { token = pushplus; }
2502 |     try {send_pushplus(token, sign_list);}
2503 |     catch (e) {fError(e+":push+推送失败，请尝试切换流量运行或者设置114DNS");}
2504 |   }
2505 |   back();
2506 |   if (!zhanghao) {return true}
2507 |   // 退出登录
2508 |   text("我的").findOne().click();
2509 |   log("等待设置按钮");
2510 |   let setting = id("my_setting").findOne();
2511 |   sleep(1000);
2512 |   log("点击设置按钮");
2513 |   real_click(setting);
2514 |   // log(setting.click());
2515 |   log("等待退出登录");
2516 |   let signout = id("setting_sign_out").findOne();
2517 |   sleep(1000);
2518 |   log("点击退出登录");
2519 |   real_click(signout);
2520 |   // log(signout.click());
2521 |   text("确认").findOne().click();
2522 |   if (noverify_thread.isAlive()) {
2523 |     noverify_thread.interrupt();
2524 |   }
2525 |   return true
2526 | }
2527 | 
2528 | function main(userinfo){
2529 |   var retry_time;
2530 |   if (!Number(watchdog)) {
2531 |     retry_time = 5400;
2532 |   } else if (Number(watchdog)<900) {
2533 |     fTips("建议重试延迟不要低于900s即15分钟，已设为1800s");
2534 |     retry_time = 1800;
2535 |   } else { retry_time = Number(watchdog) }
2536 |   for (let i=0;i<3;i++) {
2537 |     fClear();
2538 |     fInfo("开始第"+(i+1)+"轮，最长运行时间为"+retry_time+"s");
2539 |     let xxqg_begin=new Date();
2540 |     var main_thread = threads.start(function(){
2541 |       xxqg(userinfo);
2542 |     })
2543 |     main_thread.join(retry_time*1000);
2544 |     if (main_thread.isAlive()) {
2545 |       main_thread.interrupt();
2546 |       fError("运行超时，重试");
2547 |       exit_app("学习强国");
2548 |       sleep(1500);
2549 |       app.launchApp('学习强国');
2550 |       sleep(2000);
2551 |     } else {
2552 |       let xxqg_end=new Date();
2553 |       let spent_time = ((xxqg_end - xxqg_begin)/1000).toFixed();
2554 |       fInfo("本轮已正常结束，花费时间"+spent_time+"s");
2555 |       return true
2556 |     }
2557 |   }
2558 |   fError("已重试3次，可能无障碍服务出现故障，退出脚本");
2559 |   exit();
2560 | }
2561 | 
2562 | /*******************主程序部分*******************/
2563 | /********定义全局变量*********/
2564 | var jifen_list, meizhou_dao, zhuanxiang_dao, dingyue_dao, storage_user, name, jinri, zongfen;
2565 | // 分割账号
2566 | if (zhanghao) {
2567 |   var zhanghao_list = [];
2568 |   for (let zh of zhanghao.split("\n")) {
2569 |     let userinfo = zh.split(/:|：/);
2570 |     zhanghao_list.push(userinfo);
2571 |   };
2572 |   if (zhanghao_list.length > 3) {zhanghao_list.length = 3;}
2573 |   //console.verbose(zhanghao_list);
2574 |   for (let userinfo of zhanghao_list) {
2575 |     console.verbose(userinfo);
2576 |     main(userinfo);
2577 |   }
2578 |   fClear();
2579 |   fInfo("登录回账号1");
2580 |   console.verbose(zhanghao_list[0][0], zhanghao_list[0][1]);
2581 |   login(zhanghao_list[0][0], zhanghao_list[0][1]);
2582 | } else {
2583 |   main();
2584 | }
2585 | 
2586 | // main("18802583389", "xhbj.39000");
2587 | // main("15849082086", "zhangfpan0711");
2588 | // main("17684809426", "qxpcdodo");
2589 | // main("18647101545", "zhoukun147753");
2590 | 
2591 | /*****************结束后配置*****************/
2592 | launch('com.hamibot.hamibot');
2593 | //console.show();
2594 | // console.clear();
2595 | fInfo("已全部结束");
2596 | // 调回原始音量
2597 | if (yl_on) {
2598 |   fInfo("调回初始音量:"+ yuan_yl);
2599 |   device.setMusicVolume(yuan_yl);
2600 | }
2601 | // 取消屏幕常亮
2602 | fInfo("取消屏幕常亮");
2603 | device.cancelKeepingAwake();
2604 | // exit_app("学习强国");
2605 | // if (email) {
2606 | //   send_email(email);
2607 | // }
2608 | // 震动提示
2609 | device.vibrate(500);
2610 | fInfo("十秒后关闭悬浮窗");
2611 | sleep(10000);
2612 | console.hide();
2613 | home();
2614 | exit();
2615 | 
2616 | 


--------------------------------------------------------------------------------
/TTXS_Pro/TTXS_CODDE/V9.0(有弹窗).js:
--------------------------------------------------------------------------------
   1 | 
   2 | var hamibot={env:{fenxiang:"true",wenzhang:"true",meizhou:"daoxu",zhuanxiang:"daoxu",dingyue:"zhengxu",shipin:"true",meiri:"true",siren:"true",bendi:"true",shuangren:"true",dacuo_num:"2",yinliang:"0",tiaozhan:"true",duizhan_mode:"suiji",yl_on:true,zhanghao:"11111111111:11111111111\n22222222222:22222222222",APP_ENV:"production",USER_ID:"",ROBOT_ID:"",SCRIPT_ID:"",TIMESTAMP:""},plan:{name:"免费",onFreeTrial:false,model:"free"},robotName:"",};
   3 | hamibot.postMessage=function(){};hamibot.exit=function(){exit();};
   4 | auto.waitFor(mode = "fast");//mode = "fast"
   5 | var delay_time = 3000;
   6 | // 读取自定义配置
   7 | const { fenxiang, shipin, wenzhang, meiri, meizhou, zhuanxiang, tiaozhan, ocr_plugin, duizhan_mode,
   8 |        jisu, siren, dacuo_num, shuangren, bendi, dingyue, pushplus, yl_on, yinliang, zhanghao } = hamibot.env;
   9 | launch('com.hamibot.hamibot');
  10 | // text("Hamibot").waitFor();
  11 | textMatches(/Hamibot|日志/).waitFor();
  12 | sleep(delay_time);
  13 | /*****************更新内容弹窗部分*****************/
  14 | var storage = storages.create('songgedodo');
  15 | // 脚本版本号
  16 | var last_version = "V8.6";
  17 | var engine_version = "V9.0";
  18 | if (storage.get(engine_version, true)) {
  19 |   storage.remove(last_version);
  20 | //   以下为自定义弹窗代码
  21 | //   let checked = gengxin_show();
  22 | //   if (checked) {storage.put(engine_version, false);}
  23 |   let gengxin_rows = ["强国APP版本v2.34.0以上不支持订阅，可以在豌豆荚中下载历史版本",
  24 |                       "1.更换了更新题库的方式，尝试解决网络报错，用起来更快更方便",
  25 |                       "2.稍微增加了每篇视频和文章的时长",
  26 |                       "3.修复多账号退出登录时可能卡住的bug",
  27 |                       "4.修复对战可能出现报错的bug",
  28 |                       "联系方式：qq群: 586076765；tg: t.me/wyqg_ttxs",
  29 |                       "（点击取消不再提示）"]
  30 |   let is_show = confirm(engine_version + "版更新内容", gengxin_rows.join("\n"));
  31 |   if (!is_show) {storage.put(engine_version, false);}
  32 | }
  33 | var w = fInit();
  34 | // console.setTitle("天天向上");
  35 | // console.show();
  36 | fInfo("脚本初始化");
  37 | fInfo("版本号检测："+ app.versionCode);
  38 | if (app.versionCode < 110) {
  39 |   alert("请进入下载页点击下载测试版！！\n版本号为v1.3.0-beta.3");
  40 |   let req = http.get("https://hamibot.com/download");
  41 |   let resp_str = req.body.string();
  42 |   let reg = '/<a href="(.*)?" target="_blank" data-v-402fe7d6>'
  43 |   +'<button type="button" appearance="default" spacing="default" data-v-4ab5aafc data-v-402fe7d6>/';
  44 |   let link = resp_str.match(eval(reg))[1];
  45 |   //log(link);
  46 |   app.openUrl(link);
  47 |   exit();
  48 | }
  49 | // 初始化宽高
  50 | var [device_w, device_h] = init_wh();
  51 | // log("fina:", device_w, device_h);
  52 | // OCR初始化，重写内置OCR module
  53 | if (ocr_plugin) {
  54 |   fInfo("初始化第三方ocr插件");
  55 |   try {
  56 |     ocr = plugins.load("com.hraps.ocr");
  57 |     ocr.recognizeText = function (img) {
  58 |       let results = this.detect(img.getBitmap(),1);
  59 |       let all_txt = "";
  60 |       for (let i=0;i<results.size();i++) {
  61 |         let re = results.get(i);
  62 |         all_txt += re.text;
  63 |       }
  64 |       return all_txt
  65 |     }
  66 |   }
  67 |   catch(e) {
  68 |     fError("未安装第三方OCR插件，请安装后重新运行");
  69 |     alert("未安装第三方OCR插件，点击确认跳转浏览器下载，密码为ttxs");
  70 |     app.openUrl("https://wwc.lanzouo.com/ikILs001d0wh");
  71 |     exit();
  72 |   }
  73 | }
  74 | // sleep(2000);
  75 | // 自动允许权限进程
  76 | threads.start(function() {
  77 |   //在新线程执行的代码
  78 |   //sleep(500);
  79 |   toastLog("开始自动获取截图权限");
  80 |   var btn = className("android.widget.Button").textMatches(/允许|立即开始|START NOW/).findOne(5000);
  81 |   if (btn) {
  82 |     sleep(1000);
  83 |     btn.click();
  84 |   }
  85 |   toastLog("结束获取截图权限");
  86 | });
  87 | fInfo("请求截图权限");
  88 | // 请求截图权限、似乎请求两次会失效
  89 | if (!requestScreenCapture(false)) { // false为竖屏方向
  90 |   fError('请求截图失败');
  91 |   hamibot.exit();
  92 | }
  93 | // 防止设备息屏
  94 | fInfo("设置屏幕常亮");
  95 | device.keepScreenOn(3600 * 1000);
  96 | // 下载题库
  97 | var update_info = get_tiku_by_http("https://gitee.com/songgedodo/songge_tiku/raw/master/info.json");
  98 | fInfo("测试对战题库");
  99 | var tiku = get_tiku_by_http(update_info["tiku_link"]);
 100 | // var tiku = get_tiku_by_gitee();
 101 | fInfo("检测题库更新");
 102 | var dati_tiku = [];
 103 | try {dati_tiku = update_dati_tiku()}
 104 | catch (e) {
 105 |   fError("网络原因未获取到在线题库，请尝试切换流量或者更换114DNS");
 106 |   dati_tiku = get_tiku_by_ct('https://webapi.ctfile.com/get_file_url.php?uid=35157972&fid=555754562&file_chk=94c3c662ba28f583d2128a1eb9d78af4&app=0&acheck=2&rd=0.14725283060014105');
 107 | }
 108 | // 调整音量
 109 | if (yl_on) {
 110 |   fInfo("设置媒体音量");
 111 |   var yuan_yl = device.getMusicVolume();
 112 |   var max_yl = device.getMusicMaxVolume();
 113 |   let yl = Math.ceil(yinliang*max_yl/100);
 114 |   //log(yuan_yl, max_yl, yl, typeof yl);
 115 |   device.setMusicVolume(yl);
 116 |   fInfo("当前音量："+ device.getMusicVolume());
 117 | }
 118 | fInfo("运行前重置学习APP");
 119 | exit_app("学习强国");
 120 | // 检测地理位置权限代码，出现就点掉
 121 | fInfo("开始位置权限弹窗检测");
 122 | var nolocate_thread = threads.start(function() {
 123 |   //在新线程执行的代码
 124 |   id("title_text").textContains("地理位置").waitFor();
 125 |   fInfo("检测到位置权限弹窗");
 126 |   sleep(1000);
 127 |   var btn = text("暂不开启").findOne();
 128 |   btn.click();
 129 |   fInfo("已关闭定位");
 130 | });
 131 | fInfo("跳转学习APP");
 132 | // launch('cn.xuexi.android');
 133 | app.launchApp('学习强国');
 134 | sleep(2000);
 135 | // console.hide();
 136 | // 命令行方式启动，似乎需要root
 137 | // var result_shell = shell("pm disable cn.xuexi.android");
 138 | // log(result_shell.code, result_shell.error);
 139 | /***************不要动****************
 140 |  * **********************************
 141 | // 创建一个安卓动作，打开软件，此功能可以跳过开屏页，还在实验中
 142 | // app.startActivity({
 143 | //   action: 'android.intent.action.VIEW',
 144 | //   data: 'dtxuexi://appclient/page/study_feeds',
 145 | //   packageName: 'cn.xuexi.android',
 146 | // });
 147 |  * **********************************
 148 | *************************************/
 149 | 
 150 | 
 151 | function do_fenxiang() {
 152 |   // 点击分享"去看看"回首页
 153 |   jifen_list = className("android.widget.ListView").depth(21).findOne();
 154 |   jifen_list.child(11).child(3).click();
 155 |   fSet("title", "分享和评论…");
 156 |   fClear();
 157 |   sleep(1000);
 158 |   swipe(device_w/2, device_h*0.7, device_w/2, device_h*0.4, 1000);
 159 |   let wen_box = id("general_card_title_id").findOne().parent().parent();
 160 |   fInfo("尝试点击title:"+ id("general_card_title_id").findOne().text());
 161 | //   //log("文章click:", wen_box.click());
 162 | //   while (!id("general_card_title_id").findOne().parent().parent().click()) {log("文章click: false");}
 163 | //   log("文章click: true");
 164 |   real_click(id("general_card_title_id").findOne().parent().parent());
 165 |   log("等待加载");
 166 |   idContains("image-text-content").waitFor();
 167 |   let text_edit = text("欢迎发表你的观点");
 168 |   log("查找评论框");
 169 |   text_edit.waitFor();
 170 |   sleep(1500);
 171 |   while (pinglun = text_edit.findOne(1500)) {
 172 |     fInfo("尝试点击评论框中");
 173 |     log(pinglun.click());
 174 |     sleep(500);
 175 |     fRefocus();
 176 |   }
 177 |   fInfo("评论框click: true");
 178 |   let content_list = ["全心全意为人民服务", "不忘初心，牢记使命", "不忘初心，方得始终", "永远坚持党的领导"];
 179 |   className("android.widget.EditText").findOne().setText(content_list[random(0, content_list.length-1)]);
 180 |   sleep(1000);
 181 |   text("发布").findOne().click();
 182 |   sleep(1000);
 183 |   text("删除").findOne().click();
 184 |   sleep(1000);
 185 |   text("确认").findOne().click();
 186 |   sleep(1000);
 187 |   // 下面是分享
 188 |   for (let i=0; i<2; i++) {
 189 |     text_edit.findOne().parent().child(3).click();
 190 |     sleep(500);
 191 |     textContains("学习强国").findOne().parent().click();
 192 |     sleep(500);
 193 |     text("创建新的聊天").waitFor();
 194 |     sleep(1000);
 195 |     back();
 196 |     sleep(1000);
 197 |   }
 198 |   // 回到首页
 199 |   back();
 200 |   // 返回积分页
 201 |   jifen_init();
 202 |   ran_sleep();
 203 |   return true;
 204 | }
 205 | 
 206 | /********时长部分*********/
 207 | function do_shipin() {
 208 |   jifen_list = className("android.widget.ListView").depth(21).findOne();
 209 |   jifen_list.child(2).child(3).click();
 210 |   fSet("title", "视听学习…");
 211 |   fClear();
 212 |   desc("百灵").findOne().click();
 213 |   sleep(1000);
 214 |   fInfo("检测温馨提示弹窗");
 215 |   if (text("温馨提示").findOne(1500)) {
 216 |     text("关闭").findOne().click();
 217 |     fInfo("检测到温馨提示并已关闭");
 218 |   }
 219 |   desc("百灵").findOne().click();
 220 |   let shu = text("竖").findOne();
 221 |   sleep(1000);
 222 |   // 定位到整个百灵frame_box
 223 |   let frame_box = shu.parent().parent().parent().parent();
 224 |   textMatches(/\d{2}:\d{2}/).waitFor();
 225 |   let video_list = frame_box.findOne(className("android.widget.ListView"));
 226 |   video_list.child(1).child(1).child(0).click();
 227 |   text("分享").waitFor();
 228 |   if (idContains("guide_view").findOne(1500)) {
 229 |     fInfo("检测到引导遮罩");
 230 |     sleep(1000);
 231 |     click(device_w / 2, device_h / 2);
 232 |     sleep(1000);
 233 |     click(device_w / 2, device_h / 4);
 234 |   }
 235 |   sleep(800);
 236 |   //log(text("刷新重试").exists());
 237 |   if (text("刷新重试").exists()) {
 238 |     fInfo("检测到流量提醒");
 239 |     text("刷新重试").findOne().click();
 240 |   }
 241 |   sleep(random(8000,9500));
 242 |   for (let i=0; i<6; i++) {
 243 |     click(device_w / 2, device_h / 2);
 244 |     sleep(500);
 245 |     swipe(device_w/2, device_h*0.8, device_w/2, device_h*0.1, 1000);
 246 |     sleep(random(8000,9500));
 247 |   }
 248 |   back();
 249 |   fInfo("视频个数已刷完");
 250 |   // 返回积分页
 251 |   jifen_init();
 252 |   ran_sleep();
 253 |   return true;
 254 | }
 255 | 
 256 | function do_wenzhang() {
 257 |   jifen_list = className("android.widget.ListView").depth(21).findOne();
 258 |   // 点击进入本地
 259 |   let old_wen = storage_user.get("old_wen_list", []);
 260 |   //log(typeof old_wen, old_wen);
 261 |   jifen_list.child(13).child(3).click();
 262 |   fSet("title", "选读文章…");
 263 |   fClear();
 264 |   fInfo("切换地区为北京");
 265 |   text("切换地区").findOne(3000);
 266 |   if (text("立即切换").exists()) {
 267 |     text("取消").findOne(3000).click();
 268 |   }
 269 |   log("切换地区");
 270 |   text("切换地区").findOne().click();
 271 |   log("查找北京");
 272 |   text("北京").waitFor();
 273 |   sleep(500);
 274 |   log("切换北京");
 275 |   text("北京").findOne().parent().parent().click();
 276 |   log("查找banner");
 277 |   let banner = className("android.support.v7.widget.RecyclerView").findOne();
 278 |   log("查找末项");
 279 |   while (banner.findOne(text("北京新闻广播")) == null) {banner.scrollForward();}
 280 |   log("点击末项", text("北京新闻广播").findOne().parent().click());
 281 |   fInfo("视听广播时长");
 282 |   sleep(11500);
 283 |   back();
 284 |   // 下面正式刷文章
 285 |   fInfo("开始文章");
 286 |   sleep(1500);
 287 |   banner = className("android.support.v7.widget.RecyclerView").findOne();
 288 |   while (banner.findOne(text("北京学习平台")) == null) {banner.scrollBackward();}
 289 |   sleep(1000);
 290 |   log("查找首项，尝试点击");
 291 | //   while (!text("北京学习平台").findOne().parent().click()) {log("click: false");}
 292 | //   log("click: true");
 293 |   real_click(text("北京学习平台").findOne().parent());
 294 |   log("等待加载");
 295 |   sleep(1000);
 296 |   text("新思想扎根京华").waitFor();
 297 |   sleep(1000);
 298 |   let swipe_y = text("新思想扎根京华").findOne().parent().parent().bounds().bottom;
 299 |   log("识别出顶部：", swipe_y);
 300 |   fRefocus();
 301 |   let listview = className("android.widget.ListView").depth(17).findOne();
 302 |   // 先判断是否有可刷文章，没有则停止脚本
 303 |   // while (!id("general_card_image_id").findOne(1000)) {listview.scrollForward();}
 304 |   for (i=0; i<2; i++) {
 305 |     listview.scrollForward();
 306 |     sleep(500);
 307 |   }
 308 |   // 自定义没有刷过的文章筛选器
 309 |   let wen_box_slt = className("android.view.ViewGroup").depth(20).filter(function(l) {
 310 |     let title = l.findOne(idContains("general_card_title_id"));
 311 |     let image = l.findOne(idContains("general_card_image_id"));
 312 |     if (title && image) {
 313 |       return old_wen.indexOf(title.text())==-1 && title.text().indexOf("【专题】")==-1;
 314 |     }
 315 |     return false;
 316 |   });
 317 |   log("查找文章");
 318 |   //while (!idContains("general_card_image_id").findOne(500)) {
 319 |   while (!wen_box_slt.findOne(500)) {
 320 |     listview.scrollForward();
 321 |     //sleep(500);
 322 |   }
 323 |   log("找到文章");
 324 |   // 下面那句会定位到新思想的文章，不能加载过新思想
 325 |   let wen_box = wen_box_slt.findOne();
 326 |   // 先做5次
 327 |   let wen_num = 0;
 328 |   while (wen_num < 6) {
 329 |     let title = wen_box.findOne(idContains("general_card_title_id")).text();
 330 |     old_wen.push(title);
 331 |     if (old_wen.length > 60) {old_wen.shift();}
 332 |     fClear();
 333 |     fInfo("点击文章："+title);
 334 |     //wen_box.click();
 335 |     let title_click = wen_box.parent().parent().click();
 336 |     fInfo("点击："+title_click);
 337 |     classNameContains("com.uc.webview.export").waitFor();
 338 |     let father_view = className("android.webkit.WebView").findOne();
 339 |     sleep(1000);
 340 | //     let father_view = className("android.view.View").depth(16).findOne();
 341 |     // 判断是否为专题而不是文章
 342 |     if (father_view.find(idContains("__next")).empty()) {
 343 |       idContains("image-text-content").waitFor();
 344 |       // log(idContains("image-text-content").findOne().id());
 345 |       // 不先点一下划不动
 346 |       idContains("xxqg-article-header").findOne().child(0).click();
 347 |       swipe(device_w/2, device_h*0.7, device_w/2, device_h*0.3, 1000);
 348 |       if (wen_num < 5) {
 349 |         sleep(random(8000,9500));
 350 |       }
 351 |      	else {
 352 |         // 第6次停顿刷时间
 353 |         //console.show();   
 354 |         toastLog("正在刷时长程序未停止");
 355 |         let shichang = 6*random(55, 60);
 356 |         fClear();
 357 |         fInfo("开始刷时长，总共" + shichang + "秒");
 358 |         let wait_time = 1;
 359 |         for (let i=0; i<shichang; i++){ //*random(55, 60)
 360 |           // 每15秒增加一次滑动防息屏
 361 |           if (i%15==0) {
 362 |             swipe(device_w/2, device_h*0.6, device_w/2, device_h*0.6-100, 500);
 363 |             sleep(500);
 364 |           }
 365 |           else {sleep(1000);}
 366 |           //w.info.setText("已观看文章" + wait_time + "秒，总共" + shichang + "秒");
 367 |           fSet("info", "已观看文章" + wait_time + "秒，总共" + shichang + "秒");
 368 |           wait_time++;
 369 |         }
 370 |         fSet("info", "已结束文章时长");
 371 |         console.hide();
 372 |         back();
 373 |         break;
 374 |       }
 375 |     }
 376 |     else {wen_num -= 1;}
 377 |     back();
 378 |     //id("general_card_image_id").waitFor();
 379 |     className("android.widget.ListView").scrollable().depth(17).waitFor();
 380 |     sleep(1000);
 381 |     while (!wen_box_slt.exists()) {
 382 |       listview.scrollForward();
 383 |       sleep(200);
 384 |     }
 385 |     wen_box = wen_box_slt.findOne();
 386 |     wen_num += 1;
 387 |   }
 388 |   // 更新已读文章库
 389 |   storage_user.put("old_wen_list", old_wen);
 390 |   sleep(3000);
 391 |   // 关闭音乐
 392 |   close_video();
 393 |   back(); 
 394 |   sleep(3000);
 395 |   // 返回积分页
 396 |   jifen_init();
 397 |   ran_sleep();
 398 |   return true;
 399 | }
 400 | 
 401 | /********每日答题*********/
 402 | function do_meiri() {
 403 |   // 点击进入每日答题
 404 |   jifen_list = className("android.widget.ListView").depth(21).findOne();
 405 |   jifen_list.child(4).child(3).click();
 406 |   fSet("title", "每日答题…");
 407 |   fClear();
 408 |   // 等待加载
 409 |   text("查看提示").waitFor();
 410 |   // 获取右上题号，如1 /5
 411 |   var tihao = className("android.view.View").depth(24).findOnce(1).text();
 412 |   var num = Number(tihao[0]);
 413 |   var sum = Number(tihao[tihao.length-1]);
 414 |   var substr = tihao.slice(1);
 415 |   while (num<=sum) {
 416 |     fClear();
 417 |     fInfo("第"+num+"题");
 418 |     // 等待加载
 419 |     text(num+substr).waitFor();
 420 |     num++;
 421 | //     // 如果是视频题则重新开始
 422 | //     if (className("android.widget.Image").exists()) {
 423 | //       num = 1;
 424 | //       restart(0);
 425 | //       continue;
 426 | //     }
 427 |     do_exec();
 428 |     // 点击确定下一题
 429 |     depth(20).text("确定").findOne().click();
 430 | 		ran_sleep();
 431 |     // 如果题做错了重来
 432 |     if (text("下一题").exists() || text("完成").exists()) {
 433 |       fInfo("答错重试");
 434 |       num = 1;
 435 |       restart(0);
 436 |       continue;
 437 |     }
 438 |   }
 439 | 	// 循环结束完成答题
 440 |   text("返回").findOne().click();
 441 |   text("登录").waitFor();
 442 |   ran_sleep();
 443 |   return true;
 444 | }
 445 | 
 446 | /********每周答题*********/
 447 | function do_meizhou() {
 448 |   // 点击进入每周答题
 449 |   jifen_list = className("android.widget.ListView").depth(21).findOne();
 450 |   jifen_list.child(5).child(3).click();
 451 |   fSet("title", "每周答题…");
 452 |   fClear();
 453 |   // 等待加载
 454 |   textContains("月").waitFor();
 455 |   let scoll = depth(21).scrollable().findOne();
 456 |   // 下面是倒叙作答
 457 |   if (meizhou_dao) {
 458 |     fInfo("倒序查找未做题目");
 459 |     //当出现已作答时，点击最后一个未作答
 460 |     while (!text("已作答").exists()) {
 461 |       scoll.scrollForward();
 462 |       sleep(300);
 463 |     }
 464 |     var clt = text("未作答").find();
 465 |     if (clt.empty()) {
 466 |       fInfo("每周答题全部已作答。");
 467 |       back();
 468 |       text("登录").waitFor();
 469 |       ran_sleep();
 470 |       return true;
 471 |     }
 472 |     var title = clt[clt.length-1].parent().child(0).text();
 473 |     fInfo(title + "开始作答");
 474 |     clt[clt.length-1].parent().click();
 475 |     // 测试用
 476 |     // text("已作答").findOnce(0).click();
 477 |   }
 478 |   // 下面是正序作答
 479 |   else {
 480 |     fInfo("正序查找未做题目");
 481 |     // 找到未作答就停止滚动
 482 |     let dixian_slt = text("您已经看到了我的底线").filter(function(w) {
 483 |       log("底线：", w.bounds().top, device_h);
 484 |       return w.bounds().top <= device_h-30;
 485 |     });
 486 |     //while (true) { //测试用
 487 |     while (!text("未作答").exists()) {
 488 |       // 如果到底则设置倒序为true
 489 |       if (dixian_slt.exists()) {
 490 |         //storage_user.put('meizhou_dao', true);
 491 |         fInfo("每周答题全部已作答。");
 492 |         back();
 493 |         text("登录").waitFor();
 494 |         ran_sleep();
 495 |         return true;
 496 |       }
 497 |       scoll.scrollForward();
 498 |       sleep(200);
 499 |     }
 500 |     title = text("未作答").findOne().parent().child(0).text();
 501 |     fInfo(title + "开始作答");
 502 |     text("未作答").findOne().parent().click();
 503 |   } 
 504 |   // 等待加载
 505 |   text("查看提示").waitFor();
 506 |   // 获取右上题号，如1 /5
 507 |   var tihao = className("android.view.View").depth(24).findOnce(1).text();
 508 |   var num = Number(tihao[0]);
 509 |   var sum = Number(tihao[tihao.length-1]);
 510 |   var substr = tihao.slice(1);
 511 |   while (num<=sum) {
 512 |     fClear();
 513 |     fInfo("第"+num+"题");
 514 |     // 等待加载
 515 |     text(num+substr).waitFor();
 516 |     num++;
 517 |     do_exec("（每周）");
 518 |     // 点击确定下一题
 519 |     depth(20).text("确定").findOne().click();
 520 | 		ran_sleep();
 521 |     // 如果题做错了重来
 522 |     if (text("下一题").exists() || text("完成").exists()) {
 523 |       //toastLog(title + "我无能为力啦，请手动作答吧");
 524 |       fInfo("做错尝试重答");
 525 |       text("答案解析").waitFor();
 526 |       upload_wrong_exec("（每周）");
 527 |       storage.put('dati_tiku', dati_tiku);
 528 |       back();
 529 |       text("退出").findOne().click();
 530 |   		ran_sleep();
 531 |       back();
 532 |       text("登录").waitFor();
 533 |       ran_sleep();
 534 |       return false;
 535 |     }    
 536 |   }
 537 | 	// 循环结束完成答题
 538 |   text("返回").findOne().click();
 539 |   sleep(1000);
 540 |   back();
 541 |   text("登录").waitFor();
 542 |   ran_sleep();
 543 |   return true;
 544 | }
 545 | 
 546 | /********专项答题*********/
 547 | /*专项答题中提示的层次与每日每周的不一样
 548 |  * 专项答题出现的倒计时会影响22,23层的结构*/
 549 | function do_zhuanxiang() {
 550 |   // 点击进入专项答题
 551 |   jifen_list = className("android.widget.ListView").depth(21).findOne();
 552 |   jifen_list.child(6).child(3).click();
 553 |   fSet("title", "专项答题…");
 554 |   fClear();
 555 |   // 等待加载
 556 |   depth(23).waitFor();
 557 |   ran_sleep();
 558 |   let scoll = depth(21).indexInParent(1).scrollable().findOne();
 559 |   //let new_tihao = [];
 560 |   // 下面是倒序答题
 561 |   if (zhuanxiang_dao) {
 562 |     // 当出现已满分时，点击最后一个开始答题
 563 |     while (!text("已满分").exists()) {
 564 |       scoll.scrollForward();
 565 |       // 不加延迟会很卡
 566 |       sleep(200);
 567 |     }
 568 |     var clt = text("开始答题").find();
 569 |     if (clt.empty()) {
 570 |       fInfo("专项答题全部已作答。");
 571 |       back();
 572 |       text("登录").waitFor();
 573 |       ran_sleep();
 574 |       return true;
 575 |     }
 576 |     // 点击最后一项
 577 |     clt[clt.length-1].click();
 578 |   }
 579 |   // 下面是正序
 580 |   else {
 581 |     // 直到找到开始答题
 582 |     let dixian_slt = text("您已经看到了我的底线").filter(function(w) {
 583 |       return w.bounds().top <= device_h-30;
 584 |     });
 585 |     //while (true) { //测试用
 586 |     while (!text("开始答题").exists()) { //开始答题
 587 |       // 如果到底则设置倒序为true
 588 |       if (dixian_slt.exists()) {
 589 |         //storage_user.put('zhuanxiang_dao', true); 自定义不用读取
 590 |         fInfo("专项答题全部已作答。");
 591 |         back();
 592 |         text("登录").waitFor();
 593 |         ran_sleep();
 594 |         return true;
 595 |       }
 596 |       // 滚动20次
 597 |       for (i=0; i<15; i++) {
 598 |         scoll.scrollForward();
 599 |         // 不加延迟会很卡
 600 |         sleep(300);
 601 |       }
 602 |     }
 603 |     text("开始答题").findOne().click();
 604 |   }
 605 |   ran_sleep();
 606 |   // 等待加载
 607 |   text("查看提示").waitFor();
 608 |   sleep(2000);
 609 |   // 获取右上题号，如1 /5
 610 |   var tihao = className("android.view.View").depth(24).findOnce(1).text();
 611 |   // 需要加个斜杠转义
 612 |   let reg = /(\d+) \/(\d+)/;
 613 |   var num = Number(tihao.match(reg)[1]);
 614 |   var sum = Number(tihao.match(reg)[2]);
 615 |   var substr = " /" + sum;
 616 |   //log(tihao);
 617 |   while (num<=sum) {
 618 |     fClear();
 619 |     fInfo("第"+num+"题");
 620 |     // 等待加载
 621 |     text(num+substr).waitFor();
 622 |     num++;
 623 |     do_exec();
 624 |     // 点击确定下一题
 625 |     let next = className("android.view.View").filter(function(l) {
 626 |       return (l.text() == "下一题") || (l.text() == "完成");
 627 |     });
 628 |     next.findOne().click();
 629 | //     if (!click("下一题")) {
 630 | //       click("完成");
 631 | //     }
 632 |     ran_sleep();
 633 |   }
 634 |   // 循环结束完成答题
 635 |   text("查看解析").waitFor();
 636 |   sleep(1000);
 637 |   // 如果题目答错，循环每一题并添加错题
 638 |   if (textMatches(/\d+分/).findOne().text() != "100分") {
 639 |     fInfo("有错题，尝试上传错题");
 640 |     text("查看解析").findOne().click();
 641 |     tihao = textMatches(reg).findOne().text();
 642 |     num = Number(tihao.match(reg)[1]);
 643 |     sum = Number(tihao.match(reg)[2]);
 644 |     substr = " /" + sum;
 645 |     //log(tihao);
 646 |     sleep(1500);
 647 |     while (num<=sum) {
 648 |       // 等待加载
 649 |       text(num+substr).waitFor();
 650 |       num++;
 651 |       if (textEndsWith("回答错误").exists()) {
 652 |         upload_wrong_exec();
 653 |       }
 654 |       // 点击确定下一题
 655 |       let next = className("android.view.View").filter(function(l) {
 656 |         return (l.text() == "下一题") || (l.text() == "完成");
 657 |       });
 658 |       next.findOne().click();
 659 |       sleep(random(1000, 1500));
 660 |     }
 661 |     storage.put('dati_tiku', dati_tiku);
 662 |   }
 663 |   else {
 664 |     back();
 665 |     ran_sleep();
 666 |   }
 667 |   back();
 668 |   text("登录").waitFor();
 669 |   ran_sleep();
 670 |   return true;
 671 | }
 672 | 
 673 | /********挑战答题*********/
 674 | function do_tiaozhan() {
 675 |   // 点击进入挑战答题
 676 |   jifen_list = className("android.widget.ListView").depth(21).findOne();
 677 |   jifen_list.child(7).child(3).click();
 678 |   fSet("title", "挑战答题…");
 679 |   fClear();
 680 |   // 等待加载、积分页面也有Image和List，需要用depth筛选
 681 |   className("android.widget.Image").depth(24).waitFor();
 682 |   let total = 0;
 683 |   while (true) {
 684 |     fClear();
 685 |     fInfo("第"+(total+1)+"题");
 686 |     // 等待选项列表
 687 |     let xuan_list = className("android.widget.ListView").findOne().children();
 688 |     // 获取题目
 689 |     let que_txt = className("android.widget.ListView").findOne().parent().child(0).text();
 690 |     //log(que_txt);
 691 |     // 获取答案列表，可能找到多个答案
 692 |     // let ans_list = get_ans_by_http(que_txt.replace(/来源：.*|出题单位：.+/, ""));
 693 |     let ans_list = get_ans_by_tiku(que_txt.replace(/[^\u4e00-\u9fa5\d]|来源：.+|出题单位：.+/g, ""));
 694 | //     fInfo(que_txt.replace(/[^\u4e00-\u9fa5\d]|来源：.+|出题单位：.+/g, ""));
 695 |     log("答案："+ans_list);
 696 |     ran_sleep();
 697 |     if (total >= 5) {
 698 |       // 题数数够了随便选
 699 |       fInfo("已答对5题，全选A");
 700 |       xuan_list[0].child(0).click();
 701 |     }else if (ans_list.length != 0) {
 702 |       let max_simi = 0;
 703 |       let xuanxiang = null;
 704 |       // 循环对比所有选项和答案，选出相似度最大的
 705 |       for (let xuan_box of xuan_list) {
 706 |         let xuan_txt = xuan_box.child(0).child(1).text();
 707 |         //log(xuan_txt);
 708 |         for (let ans of ans_list) {
 709 |           let similar = str_similar(ans.slice(2), xuan_txt);
 710 |           //log(xuan_txt, similar);
 711 |           if (similar > max_simi) {
 712 |             max_simi = similar;
 713 |             xuanxiang = xuan_box.child(0);
 714 |           }
 715 |         }
 716 |       }
 717 |       if (xuanxiang != null) {
 718 |         fInfo("最终："+ xuanxiang.child(1).text());
 719 |         xuanxiang.click();
 720 |       }
 721 |       else {
 722 |         fInfo("无匹配答案");
 723 |         xuan_list[0].child(0).click();
 724 |       }
 725 |     }
 726 |     // 如果没找到答案
 727 |     else {
 728 |       fInfo("未找到答案");
 729 |       // 选第一个选项
 730 |       xuan_list[0].child(0).click();
 731 |     }
 732 |     sleep(2500);
 733 |     // 判断题是否答错
 734 |     if (text("结束本局").exists()) {
 735 |       sleep(5000);
 736 |       click("结束本局");
 737 |       text("再来一局").waitFor();
 738 |       if (total < 5) {
 739 |         fInfo("答错重试");
 740 |         console.warn("warn:", que_txt);
 741 |       	text("再来一局").findOne().click();
 742 |       }
 743 |       else {
 744 |         // 退出
 745 |         back();
 746 |         text("登录").waitFor();
 747 |         ran_sleep();
 748 |         return true;
 749 |       }
 750 |       total = 0;
 751 |       sleep(2000);
 752 |       continue;
 753 |     }
 754 |     // 没答错总数加1
 755 |     total += 1;
 756 |   }
 757 | }
 758 | 
 759 | /********双人、四人赛*********/
 760 | function do_duizhan1(renshu) {
 761 |   jifen_list = className("android.widget.ListView").depth(21).findOne();
 762 |   fClear();
 763 |   if (renshu == 2) {
 764 |     // 点击进入双人对战
 765 |     jifen_list.child(9).child(3).click();
 766 |     fSet("title", "双人对战");
 767 |     fInfo("等待随机匹配");
 768 |     text("随机匹配").waitFor();
 769 |     sleep(500);
 770 |     let match_click = text("随机匹配").findOne().parent().child(0).click();
 771 |     fInfo("点击："+match_click);
 772 |   }
 773 |   else if (renshu == 4) {
 774 |     // 点击进入四人赛
 775 |     jifen_list.child(8).child(3).click();
 776 |     fSet("title", "四人赛…");
 777 |     // 等待开始比赛并点击
 778 |     fInfo("等待开始比赛");
 779 |     let start_click = text("开始比赛").findOne().click();
 780 |     fInfo("点击："+start_click);
 781 |   }
 782 |   let delay = Number(jisu);
 783 |   if (delay > 0 && duizhan_mode == "guding") {
 784 |     ui.run(function() {
 785 |       let title = w.title.getText();
 786 |       w.title.setText(title+"(急速)");
 787 |       toastLog("极速模式开启");
 788 |     });
 789 |   } else if (duizhan_mode == "shoudong") {
 790 |     ui.run(function() {
 791 |       let title = w.title.getText();
 792 |       w.title.setText(title+"(手动)");
 793 |       toastLog("请手动点击答案");
 794 |     });
 795 |   }
 796 |   text("开始").waitFor();
 797 |   fClear();
 798 |   let num = 1;
 799 |   let err_flag = true;
 800 |   while (true) {
 801 |     // 如果是第一题或者下面出错，则跳过前面等待过渡
 802 |     if (num != 1 && err_flag) {
 803 |       // 检查到其中一个过渡界面为止
 804 |       while (true) {
 805 |         // 检测是否结束并退出
 806 |         if (text("继续挑战").exists()) {
 807 |           sleep(1000);
 808 |           text("继续挑战").findOne().click();
 809 |           sleep(1500);
 810 |           back();
 811 |           if (renshu == 2) {
 812 |             text("退出").findOne().click();
 813 |           }
 814 |           text("登录").waitFor();
 815 |           ran_sleep();
 816 |           return true;
 817 |         }
 818 |         else if (text("第" + num + "题").exists()) {
 819 |           fClear();
 820 |           fInfo("第"+num+"题");
 821 |           break;
 822 |         }
 823 |       }
 824 |       // 直到过渡界面消失，再匹配下一题
 825 |       while (text("第" + num + "题").exists()) {} //sleep(100);
 826 |     }
 827 |     else if (!err_flag) {
 828 |       err_flag = true;
 829 |       if (text("继续挑战").exists()) {
 830 |         sleep(1000);
 831 |         text("继续挑战").findOne().click();
 832 |         sleep(1500);
 833 |         back();
 834 |         if (renshu == 2) {
 835 |           text("退出").findOne().click();
 836 |         }
 837 |         text("登录").waitFor();
 838 |         ran_sleep();
 839 |         return true;
 840 |       }
 841 |     }
 842 |     let listview = className("android.widget.ListView").findOne(1000);
 843 |     if (!listview) {
 844 |       log("找不到listview");
 845 |       err_flag = false;
 846 |       sleep(200);
 847 |       continue;
 848 |     }
 849 |     sleep(100); // 追求极限速度，不知道会不会出错
 850 |     let view_d28 = className("android.view.View").depth(28).indexInParent(0).findOne(1000);
 851 |     if (!view_d28) {
 852 |       toastLog("找不到view_d28");
 853 |       err_flag = false;
 854 |       sleep(200);
 855 |       continue;
 856 |     }
 857 |     // 根据父框的孩子数
 858 |     if (view_d28.childCount() > 0) {
 859 |       que_x = view_d28.bounds().left;
 860 |       que_y = view_d28.bounds().top;
 861 |       que_w = view_d28.bounds().width();
 862 |       que_h = view_d28.child(0).bounds().bottom - view_d28.bounds().top;
 863 |     }
 864 |     else {
 865 |       toastLog("找不到框体");
 866 |       log(view_d28.childCount(), view_d28.bounds());
 867 |       err_flag = false;
 868 |       sleep(200);
 869 |       continue;
 870 |     }
 871 |     let img = captureScreen();
 872 |     // 裁剪题干区域，识别题干
 873 |     let que_img = images.clip(img, que_x, que_y, que_w, que_h);
 874 |     //images.save(que_img, '/sdcard/1/que_img' + num + '.png');
 875 | //     let results = ocr.recognize(que_img).results;
 876 | //     let que_txt = ocr_rslt_to_txt(results).replace(/[^\u4e00-\u9fa5\d]|^\d{1,2}\.?/g, "");
 877 |     // 为了适配OCR插件改为下面这句
 878 |     let que_txt = ocr.recognizeText(que_img).replace(/[^\u4e00-\u9fa5\d]|\d{1,2}\./g, "");
 879 |     que_img.recycle();
 880 |     fInfo("题目识别："+ que_txt);
 881 |     let ans_list = get_ans_by_tiku(que_txt);
 882 |     //log(ans_list);
 883 |     let idx_dict = {"A": 0, "B": 1, "C": 2, "D": 3};
 884 | /************以下是因为随机选项顺序后失效的代码*****************/
 885 |     try { //防止别人先答完出错
 886 |       let idx = 0;
 887 |       if (ans_list.length <= 1) {
 888 |         if (ans_list.length == 1 && idx_dict[ans_list[0][0]] != undefined) {
 889 |           idx = idx_dict[ans_list[0][0]];
 890 |           fTips("答案:"+ ans_list[0].slice(2));
 891 | //           fInfo("答案:"+ ans_list[0]);
 892 |         }
 893 |         else if (ans_list.length == 0) {
 894 |           fInfo("未找到答案");
 895 |         }
 896 |         if (delay > 0 && num != 1) {sleep(random(delay, delay+50));}
 897 |         else {
 898 |           // 直到选项完全出现在屏幕
 899 |           while (className("android.widget.ListView").findOne(1000).indexInParent() == 0) {}
 900 |         }
 901 |         if (duizhan_mode == "guding") {
 902 |           let is_click = className("android.widget.RadioButton").findOnce(idx).parent().click();
 903 |           log(is_click);
 904 |           if (!is_click) {
 905 |             sleep(200);
 906 |             log(className("android.widget.RadioButton").findOnce(idx).parent().click());
 907 |           }
 908 |           num++;
 909 |           continue;
 910 |         } else if (duizhan_mode == "shoudong") {
 911 |           num++;
 912 |           textMatches(/第.+题|继续挑战/).waitFor();
 913 |           continue;
 914 |         }
 915 |       }
 916 |     }
 917 |     catch (e) {
 918 |       log("error1:", e);
 919 |     }
 920 | /************以上是因为随机选项顺序后失效的代码*****************/
 921 |     
 922 |     
 923 |     // 如果上面答案不唯一或者不包含找到的选项，直到选项完全出现在屏幕
 924 |     try {
 925 |     	while (className("android.widget.ListView").findOne(1000).indexInParent() == 0) {}
 926 |     } catch (e) {
 927 |       log("error2:", e);
 928 |       err_flag = false;
 929 |       sleep(200);
 930 |       continue;
 931 |     }
 932 |     let xuanxiang_list = className("android.widget.ListView").findOne(1000);
 933 |     let xuanxiang_index = xuanxiang_list.indexInParent();
 934 |     let xuanxiang_list_x = xuanxiang_list.bounds().left;
 935 |     let xuanxiang_list_y = xuanxiang_list.bounds().top;
 936 |     let xuanxiang_list_w = xuanxiang_list.bounds().width();
 937 |     let xuanxiang_list_h = xuanxiang_list.bounds().height();
 938 |     
 939 |     if (xuanxiang_list.parent().child(0) == null || !xuanxiang_list.parent().childCount() || !xuanxiang_list) {
 940 |       log("xuan_box is null");
 941 |       err_flag = false;
 942 |       sleep(200);
 943 |       continue;
 944 |     }
 945 |     log("开始截选项");
 946 |     img = captureScreen();
 947 |     // 裁剪所有选项区域
 948 |     let allx_img = images.clip(img, xuanxiang_list_x, xuanxiang_list_y, xuanxiang_list_w, xuanxiang_list_h);
 949 | 		//images.save(allx_img, '/sdcard/1/x_img' + num + '.png');
 950 |     let xuan_txt_list = [];
 951 |     let allx_txt = "";
 952 |     allx_txt = ocr.recognizeText(allx_img);
 953 |     // 获取选项列表
 954 |     xuan_txt_list = allx_txt.match(/[a-f][^a-z\u4e00-\u9fa5\d]\s*.*?(?=[a-f][^a-z\u4e00-\u9fa5\d]|$)/gi);
 955 |     allx_img.recycle();
 956 |     if (!xuan_txt_list) {
 957 |       log("识别不出选项");
 958 |       err_flag = false;
 959 |       sleep(200);
 960 |       continue;
 961 |     }
 962 |     log(xuan_txt_list.toString());
 963 |     
 964 |     if (xuan_txt_list.length != 0) {
 965 |       let max_simi = 0;
 966 |       let right_xuan = '';
 967 |       let right_xuan2 = '';
 968 |       let ans_txt = '';
 969 |       for (let xuan_txt of xuan_txt_list) {
 970 |         let txt = xuan_txt.replace(/^[A-Z]\.?/gi, "");;
 971 |         for (let ans of ans_list) {
 972 |           let similar = str_similar(ans.slice(2), txt);
 973 |           if (similar > max_simi) {
 974 |             max_simi = similar;
 975 |             ans_txt = ans;
 976 |             if (duizhan_mode == "guding") {
 977 |               // 答案默认顺序优先
 978 |               right_xuan = ans[0];
 979 |               right_xuan2 = xuan_txt[0].toUpperCase();
 980 |             } else {
 981 |               // 文本匹配优先
 982 |               right_xuan2 = ans[0];
 983 |               right_xuan = xuan_txt[0].toUpperCase();
 984 |             }
 985 |           }
 986 |         }
 987 |       }
 988 |       if (ans_list.length > 1) {fTips("匹配答案:"+ ans_txt);}
 989 |       if (right_xuan != '' && duizhan_mode != "shoudong") {
 990 |         let idx = idx_dict[right_xuan];
 991 |         fInfo("最终:"+ right_xuan);
 992 |         try {className("android.widget.RadioButton").findOnce(idx).parent().click();}
 993 |         catch (e) {
 994 |           idx = idx_dict[right_xuan2];
 995 |           fInfo("备选:"+ right_xuan2);
 996 |           try {className("android.widget.RadioButton").findOnce(idx).parent().click();}
 997 |           catch (e1) {
 998 |             log("error3:", e1);
 999 |             err_flag = false;
1000 |             sleep(200);
1001 |             continue;
1002 |           }
1003 |         }
1004 |         //log(a);
1005 |       } else if (duizhan_mode == "shoudong") {
1006 |         textMatches(/第.+题|继续挑战/).waitFor();
1007 |       }
1008 |       else {
1009 |         try {className("android.widget.RadioButton").findOnce().parent().click();}
1010 |         catch (e1) {
1011 |           log("error4:", e1);
1012 |           err_flag = false;
1013 |           sleep(200);
1014 |           continue;
1015 |         }
1016 |       }
1017 |     }
1018 |     else {
1019 |       console.warn("未识别出选项");
1020 |       err_flag = false;
1021 |       sleep(200);
1022 |       continue;
1023 |     }
1024 |     img.recycle();
1025 |     num++;
1026 |   }
1027 | }
1028 | 
1029 | // 对战答错版
1030 | function dacuo(renshu) {
1031 |   jifen_list = className("android.widget.ListView").depth(21).findOne();
1032 |   if (renshu == 2) {
1033 |     // 点击进入双人对战
1034 |     jifen_list.child(9).child(3).click();
1035 |     text("随机匹配").waitFor();
1036 |     sleep(500);
1037 |     text("随机匹配").findOne().parent().child(0).click();
1038 |   }
1039 |   else if (renshu == 4) {
1040 |     // 点击进入四人赛
1041 |     jifen_list.child(8).child(3).click();
1042 |     // 等待开始比赛并点击
1043 |     fInfo("等待开始比赛");
1044 |     let start_click = text("开始比赛").findOne().click();
1045 |     fInfo("点击："+start_click);
1046 |   }
1047 |   fInfo("等待开始过渡");
1048 |   text("开始").waitFor();
1049 |   let num = 1;
1050 |   let err_flag = true;
1051 |   while (true) {
1052 |     // 如果是第一题或者下面出错，则跳过前面等待过渡
1053 |     if (num != 1 && err_flag) {
1054 |       // 检查到其中一个过渡界面为止
1055 |       while (true) {
1056 |         // 检测是否结束并退出
1057 |         if (text("继续挑战").exists()) {
1058 |           sleep(1000);
1059 |           text("继续挑战").findOne().click();
1060 |           sleep(1500);
1061 |           back();
1062 |           if (renshu == 2) {
1063 |             text("退出").findOne().click();
1064 |           }
1065 |           text("登录").waitFor();
1066 |           ran_sleep();
1067 |           fClear();
1068 |           return true;
1069 |         }
1070 |         else if (text("第" + num + "题").exists()) {break;}
1071 |       }
1072 |       // 直到过渡界面消失，再匹配下一题
1073 |       log("等待题号过渡");
1074 |       while (text("第" + num + "题").exists()) {} //sleep(100);
1075 |     }
1076 |     else if (!err_flag) {
1077 |       err_flag = true;
1078 |       if (text("继续挑战").exists()) {
1079 |         sleep(1000);
1080 |         text("继续挑战").findOne().click();
1081 |         sleep(1500);
1082 |         back();
1083 |         if (renshu == 2) {
1084 |           text("退出").findOne().click();
1085 |         }
1086 |         text("登录").waitFor();
1087 |         ran_sleep();
1088 |         return true;
1089 |       }
1090 |     }
1091 |     log("开始第"+num+"题，等待listview");
1092 |     //className("android.widget.ListView").waitFor();
1093 |     let listview = className("android.widget.ListView").findOne(1000);
1094 |     if (!listview) {
1095 |       log("找不到listview");
1096 |       err_flag = false;
1097 |       sleep(200);
1098 |       continue;
1099 |     }
1100 |     else {log("listview已存在");}
1101 |     sleep(100); // 追求极限速度，不知道会不会出错
1102 |     log("find view_d28");
1103 |     // listview父框体
1104 |     let view_d28 = className("android.view.View").depth(28).indexInParent(0).findOne(1000);
1105 |     if (!view_d28) {
1106 |       log("找不到view_d28");
1107 |       log('far:', listview.parent());
1108 |       log('garfa', listview.parent().parent());
1109 |       err_flag = false;
1110 |       sleep(200);
1111 |       continue;
1112 |     }
1113 |     if (view_d28.childCount() > 0) {
1114 |       que_x = view_d28.bounds().left;
1115 |       que_y = view_d28.bounds().top;
1116 |       que_w = view_d28.bounds().width();
1117 |       que_h = view_d28.child(0).bounds().bottom - view_d28.bounds().top;
1118 |     }
1119 |     else {
1120 |       toastLog("找不到框体内容");
1121 |       log(view_d28.childCount(), view_d28.bounds());
1122 |       err_flag = false;
1123 |       sleep(200);
1124 |       continue;
1125 |     }
1126 |     let idx_dict = {"A": 0, "B": 1, "C": 2, "D": 3};
1127 |     try { //防止别人先答完出错
1128 |       while (className("android.widget.ListView").findOne(1000).indexInParent() == 0) {}
1129 |       sleep(random(2000, 3000));
1130 |       log("选项显现");
1131 |       className("android.widget.RadioButton").findOnce(random(0,3)).parent().click();
1132 |       num++;
1133 |       continue;
1134 |     }
1135 |     catch (e) {
1136 |       log("error1:", e);
1137 |       err_flag = false;
1138 |       sleep(200);
1139 |       continue;
1140 |     }
1141 |     num++;
1142 |   }
1143 | }
1144 | 
1145 | /********订阅*********/
1146 | function do_dingyue() {
1147 |   jifen_list = className("android.widget.ListView").depth(21).findOne();
1148 |   jifen_list.child(10).child(3).click();
1149 |   fSet("title", "订阅…");
1150 |   fClear();
1151 |   let tab1 = descContains("Tab").findOne(9000);
1152 |   if (!tab1) {back();text("登录").waitFor();return false}
1153 |   let zuo1 = descContains("上新").findOne(9000);
1154 |   if (!zuo1) {back();text("登录").waitFor();return false}
1155 |   // 上方标签
1156 |   let tab_clt = descContains("Tab").untilFind();
1157 |   let total_click = 0;
1158 |   for (let tab of tab_clt) {
1159 |     tab.click();
1160 |     sleep(500);
1161 |     // 左方分类
1162 |     let zuo_clt = className("android.view.View").depth(14).findOne().children();
1163 |     for (let zuo of zuo_clt) {
1164 |       if (dingyue_dao) {zuo = zuo_clt[zuo_clt.length-1];}
1165 |       zuo.click();
1166 |       sleep(500);
1167 |       // 右方列表
1168 |       className("android.view.View").depth(14).waitFor();
1169 |       let you_clt = className("android.view.View").depth(14).findOnce(1);
1170 |       let last_desc = "";
1171 |       while (you_clt) {
1172 |         let img = captureScreen();
1173 |         // 订阅按钮集合
1174 |         let dingyue_clt = className("android.widget.ImageView").indexInParent(2).untilFind();
1175 |         // 最底下订阅的名称
1176 |         last_desc = dingyue_clt[dingyue_clt.length-1].parent().child(1).desc();
1177 |         for (let dingyue of dingyue_clt) {
1178 |           if (dingyue.bounds().bottom > device_h) {continue;}
1179 |           let pot = findColorInRegion(img, "#E42417", dingyue.bounds().left, dingyue.bounds().top,
1180 |                                     dingyue.bounds().width(), dingyue.bounds().height(), 20);
1181 |           //if (pot && dingyue.bounds().bottom < device_h) {
1182 |           if (pot) {
1183 |             fInfo("找到一个订阅");
1184 |             sleep(1000);
1185 |             let is_click = dingyue.click();
1186 |             fInfo("点击："+ is_click);
1187 |             //click(dingyue.bounds().centerX(), dingyue.bounds().centerY());
1188 |             sleep(1000);
1189 |             //click(pot.x, pot.y+5);
1190 |             total_click += 1;
1191 |           }
1192 |           if (total_click >= 2) {
1193 |             fInfo("订阅已完成");
1194 |             back();
1195 |             text("登录").waitFor();
1196 |             ran_sleep();
1197 |             return true;
1198 |           }
1199 |         }
1200 |         img.recycle();
1201 |         you_clt.scrollForward();
1202 |         sleep(500);
1203 |         // 滑动后重新查找最底下订阅的名称，判断是否到底
1204 |         dingyue_clt = className("android.widget.ImageView").indexInParent(2).untilFind();
1205 |         //log(dingyue_clt[dingyue_clt.length-1].parent().child(1).desc(), last_desc);
1206 |         try {
1207 |           if (dingyue_clt[dingyue_clt.length-1].parent().child(1).desc() == last_desc) {
1208 |             //toastLog("到底了");
1209 |             break;
1210 |           }
1211 |           last_desc = dingyue_clt[dingyue_clt.length-1].parent().child(1).desc();
1212 |         }
1213 |         catch (e) {log(e);}
1214 |       }
1215 |       if (dingyue_dao) {fInfo("只检查年度上新");break;}
1216 |     }
1217 |     sleep(1000);
1218 |   }
1219 |   fInfo("无可订阅项目");
1220 |   back();
1221 |   text("登录").waitFor();
1222 |   ran_sleep();
1223 |   return true;
1224 | }
1225 | 
1226 | /*********本地*********/
1227 | function do_bendi() {
1228 |   jifen_list = className("android.widget.ListView").depth(21).findOne();
1229 |   jifen_list.child(13).child(3).click();
1230 |   fSet("title", "本地…");
1231 |   fClear();
1232 |   text("切换地区").findOne(5000);
1233 |   if (text("立即切换").exists()) {
1234 |     text("取消").findOne(3000).click();
1235 |   }
1236 |   let banner = className("android.support.v7.widget.RecyclerView").findOne();
1237 |   let txt = banner.child(0).child(1).text();
1238 |   banner.child(0).click();
1239 |   className("android.widget.TextView").depth(11).text(txt).waitFor();
1240 |   sleep(1500);
1241 |   back();
1242 |   ran_sleep();
1243 |   jifen_init();
1244 |   ran_sleep();
1245 |   return true;
1246 | }
1247 | /**************************************上方为执行各项目函数*********************************************/
1248 | 
1249 | 
1250 | 
1251 | // 做一次题
1252 | function do_exec(type) {
1253 |   // 等待加载
1254 |   let tishi = text("查看提示").findOne();
1255 |   //log(tishi);
1256 |   // 点击查看提示按钮
1257 |   tishi.click();
1258 |   // 随机延迟、等待提示
1259 |   ran_sleep();
1260 |   // 等待加载
1261 |   text("提示").waitFor();
1262 |   
1263 |   // 判断题型
1264 |   /******************单选题*******************/
1265 |   if (textStartsWith("单选题").exists()) {
1266 |     // 获取题目
1267 | 		//let que_txt = className("android.view.View").depth(23).findOnce(1).text();
1268 |     // 上面被专项答题影响了22、23层的元素数，只能通过其他层定位
1269 |     let que_txt = className("android.view.View").depth(24).findOnce(1).parent().parent().child(1).text();
1270 |     // log(que_txt);
1271 |     var ans = get_ans_by_re(que_txt);
1272 |     if (ans && depth(26).text(ans).exists()) {
1273 |       // 定位选项并点击
1274 |       depth(26).text(ans).findOnce().parent().click();
1275 |     }
1276 |     //else if (ans = get_ans_by_http_dati(que_txt)) {
1277 |     else {
1278 |       if (type) {ans = get_ans_by_dati_tiku(que_txt, type);}
1279 |       else {ans = get_ans_by_dati_tiku(que_txt);}
1280 |       let reg = /[A-F]/;
1281 |       if (ans && reg.test(ans) && ans.length == 1) {
1282 |         ans = ans.match(reg)[0];
1283 |         let idx_dict = {"A": 0, "B": 1, "C": 2, "D": 3, "E": 4, "F": 5};
1284 |         className("android.widget.RadioButton").findOnce(idx_dict[ans[0]]).parent().click();
1285 |       }
1286 |       // 否则用ocr
1287 |       else {
1288 |         if (!ans) {ans = get_ans_by_ocr1().replace(/\s/g, "");}
1289 |         if (depth(26).text(ans).exists()) {
1290 |           depth(26).text(ans).findOne().parent().click();
1291 |         }
1292 |         else {
1293 |           // 筛选出相似度最大的
1294 |           let xuan_clt = className("android.widget.RadioButton").find();
1295 |           let max_simi = 0;
1296 |           let xuanxiang = null;
1297 |           for (let n of xuan_clt) {
1298 |             let similar = str_similar(ans, n.parent().child(2).text());
1299 |             if (similar > max_simi) {
1300 |               max_simi = similar;
1301 |               xuanxiang = n.parent();
1302 |             }
1303 |           }
1304 |           //点击选项
1305 |           if (xuanxiang) {xuanxiang.click();}
1306 |           else {className("android.widget.RadioButton").findOne().parent().click();}
1307 |           //log(xuanxiang.find().size());
1308 |         }
1309 |       }
1310 |     }
1311 |   }
1312 |   /******************填空题*******************/
1313 |   else if (textStartsWith("填空题").exists()) {
1314 |     // 填空题题干会被空格分割
1315 |     //let que = className("android.view.View").depth(23).findOnce(1).children();
1316 |     // 上面被专项答题影响了22、23层的元素数，只能通过其他层定位
1317 |     let que = className("android.view.View").depth(24).findOnce(1).parent().parent().child(1).children();
1318 |     // 第一个编辑框的父元素
1319 |     let text_edit = className("android.widget.EditText").findOne().parent().children();
1320 |     // 第一个空答案字数，后期考虑换成全部答案字数
1321 |     let word_num = text_edit.find(className("android.view.View")).length;
1322 |     // 填空数
1323 |     let kong_num = 0;
1324 |     let que_txt = "";
1325 |     for (let i of que) {
1326 |       // 如果没有text则加个空格
1327 |       if (i.text()) {que_txt = que_txt + i.text();}
1328 |       else {
1329 |         kong_num += 1;
1330 |         que_txt = que_txt + "    ";
1331 |       }
1332 |     }
1333 |     // log(que_txt);
1334 |     // log("kong_num:", kong_num);
1335 |     // 判断是否只有一个空，re只能得出第一空答案
1336 |     if (kong_num <= 1) {
1337 |       //一个空时，先正则匹配，再题库匹配，以防题库出错，最后OCR
1338 |       //var ans = get_ans_by_http_dati(que_txt);
1339 |       if (type) {ans = get_ans_by_dati_tiku(que_txt, type);}
1340 |       else {ans = get_ans_by_dati_tiku(que_txt);}
1341 |       if (!ans) {ans = get_ans_by_re(que_txt);}
1342 |       //长度和空格数相等才会填充
1343 |       if (ans && word_num == ans.length) {
1344 |         // 定位填空并填入
1345 |         depth(25).className("android.widget.EditText").findOne().setText(ans);
1346 |       }
1347 |       else {
1348 |         ans = get_ans_by_ocr1().replace(/\s/g, "");
1349 |         if (!ans) {ans = "未识别出文字";}
1350 |         depth(25).className("android.widget.EditText").setText(ans);
1351 |       }
1352 |     }
1353 |     // 如果多个空，直接ocr按顺序填入
1354 |     else {
1355 |       //ans = get_ans_by_http_dati(que_txt);
1356 |       if (type) {ans = get_ans_by_dati_tiku(que_txt, type);}
1357 |       else {ans = get_ans_by_dati_tiku(que_txt);}
1358 |       if (!ans) {ans = get_ans_by_ocr1().replace(/\s/g, "");}
1359 |       if (!ans) {ans = "未识别出文字";}
1360 |       edit_clt = className("android.widget.EditText").find();
1361 |       for (let edit of edit_clt) {
1362 |         let n = edit.parent().children().find(className("android.view.View")).length;
1363 |         edit.setText(ans.slice(0, n));
1364 |         ans = ans.slice(n);
1365 |       }
1366 |     }
1367 |   }
1368 |   /******************多选题*******************/
1369 |   else if (textStartsWith("多选题").exists()) {
1370 |     // 获取题目
1371 | 		// let que_txt = className("android.view.View").depth(23).findOnce(1).text();
1372 |     // 上面被专项答题影响了22、23层的元素数，只能通过其他层定位
1373 |     let que_txt = className("android.view.View").depth(24).findOnce(1).parent().parent().child(1).text();
1374 |     // log(que_txt);
1375 |     // 这里匹配出全部挖空
1376 |     let reg1 = /\s{3,}/g;
1377 |     let res = que_txt.match(reg1);
1378 |     // log(res);
1379 |     // 先看挖空数量和选项数量是否一致，判断是否全选
1380 |     let collect = className("android.widget.CheckBox").find();
1381 |     // 如果全选
1382 |     if (res.length == collect.length) {
1383 |       ans = "全选";
1384 |       for (let n of collect) {
1385 |         // 直接点击会点不上全部
1386 |         n.parent().click();
1387 |       }
1388 |     }
1389 |     //else if (ans = get_ans_by_http_dati(que_txt)) {
1390 |     else {
1391 |       if (type) {ans = get_ans_by_dati_tiku(que_txt, type);}
1392 |       else {ans = get_ans_by_dati_tiku(que_txt);}
1393 |       let reg = /[A-F]{1,6}/;
1394 |       if (ans && reg.test(ans)) {
1395 |         ans = ans.match(reg)[0];
1396 |         let idx_dict = {"A": 0, "B": 1, "C": 2, "D": 3, "E": 4, "F": 5};
1397 |         for (let n of ans) {
1398 |           className("android.widget.CheckBox").findOnce(idx_dict[n]).parent().click();
1399 |         }
1400 |       }
1401 |       // 如果不是全选
1402 |       else {
1403 |         ans = get_ans_by_ocr1();
1404 |         // 下面为匹配子串法
1405 |         ans = ans.replace(/[^\u4e00-\u9fa5\w]/g, "");
1406 |         log(ans);
1407 |         for (let n of collect) {
1408 |           let xuan_txt = n.parent().child(2).text().replace(/[^\u4e00-\u9fa5\w]/g, "");
1409 |           if (ans.indexOf(xuan_txt) >= 0) {
1410 |             n.parent().click();
1411 |           }
1412 |         }
1413 |       }
1414 |     }
1415 |   }
1416 |   fInfo("答案："+ans);
1417 |   // 返回退出查看提示界面
1418 |   back();
1419 |   sleep(1000);
1420 |   return true;
1421 | }
1422 | 
1423 | // 通过re匹配答案
1424 | function get_ans_by_re(que_txt) {
1425 |   // 定位挖空两侧字符，限制在两个标点符号内
1426 |   let reg1 = /([^，。？、；：” ]*?)\s{3,}([^，。？、；：” ]*)/;
1427 |   let res = que_txt.match(reg1);
1428 |   if (res[1] == '' && res[2] == '') {
1429 |     reg1 = /([^，。？、；：” ]*?[，。？、；：” ]*?)\s{3,}([，。？、；：” ]*?[^，。？、；：” ]*)/;
1430 |     res = que_txt.match(reg1);
1431 |   }
1432 |   // log(res);
1433 |   // 生成正则表达式
1434 |   let reg2_str = "/" + res[1] + "([^，。？、；：” ]*)" + res[2] + "/";
1435 |   let reg2 = eval(reg2_str);
1436 |   // log(reg2);
1437 |   // 获取试题信息、匹配答案
1438 |   // let tishi_txt = className("android.view.View").depth(23).findOnce(6).text();
1439 |   // 上面的查找方式会被出题方干扰
1440 |   // let tishi_txt = className("android.view.View").depth(22).findOnce(2).child(0).text();
1441 |   // 上面的层次在专项答题中出现变化
1442 |   let tishi_txt = text("提示").findOne().parent().parent().child(1).child(0).text();
1443 |   //log(tishi_txt);
1444 |   // 如果匹配到答案
1445 |   if (tishi_txt.match(reg2)) {
1446 |     let ans = tishi_txt.match(reg2)[1];
1447 |     log(ans);
1448 |     return ans;
1449 |   }
1450 |   else {return 0;}
1451 | }
1452 | 
1453 | // 通过ocr匹配答案
1454 | function get_ans_by_ocr1() {
1455 |   // 定位提示框位置
1456 |   //let tishi_box = className("android.view.View").depth(22).findOnce(2).child(0).bounds();
1457 |   // 上面的层次在专项答题中出现变化
1458 |   let tishi_box = text("提示").findOne().parent().parent().child(1).child(0).bounds();
1459 |   fInfo('开始截屏');
1460 |   let img = captureScreen();
1461 |   // 控制截图范围
1462 |   img = images.clip(img, tishi_box.left-10, tishi_box.top-10, tishi_box.width()+20, tishi_box.height());
1463 |   //images.save(img, '/sdcard/1/1.png');
1464 |   // 二值化
1465 |   img = images.interval(img, "#FD1111", 120);  //比inRange()好用多了
1466 |   //images.save(img, '/sdcard/1/2.png');
1467 |   let ans = "";
1468 | //   let resp = ocr.recognize(img).results;
1469 | //   ans = ocr_rslt_to_txt(resp);
1470 |   // 为适配第三方OCR改动
1471 |   ans = ocr.recognizeText(img);
1472 |   if (!ans) {fInfo("未识别出文字");}
1473 |   else {log(ans);} 
1474 |   img.recycle();
1475 |   return ans;
1476 | }
1477 | 
1478 | // 通过http请求匹配答案
1479 | function get_ans_by_http(que_txt) {
1480 |   // 匹配题空两边汉字、字母及数字
1481 |   let reg = /[\u4e00-\u9fa5\d]+/g;
1482 |   //let reg = /(\S*)\s{2,}(\S*)/;
1483 |   let res = que_txt.match(reg);
1484 |   if (res == null) {return [];}
1485 |   // 此处可以加个判断，不然截图没截好时会有bug
1486 |   // 选取长的一边并控制在十个字
1487 |   let longest = '';
1488 |   for (let r of res) {
1489 |     if (r.length > longest.length && r.indexOf("中华人民共和") < 0 && r.indexOf("习近平总书记") < 0) {
1490 |       longest = r;
1491 |     }
1492 |   }
1493 |   let keyword = longest.slice(0, 6);
1494 |   log(keyword);
1495 |   // 获取答案html并解析
1496 |   let req = http.get('http://www.syiban.com/search/index/init.html?modelid=1&q=' + encodeURI(keyword));
1497 |   let resp_str = req.body.string();
1498 |   let resp_list = resp_str.match(/答案：(.*?)<\/span><\/p>/g);
1499 |   let ans_list = [];
1500 |   if (resp_list != null) {
1501 |     for (let a of resp_list) {
1502 |       // 查找出来后答案中有不可见的ZERO WIDTH SPACE，需要清洗
1503 |       ans = a.match(/答案：(.*?)<\/span><\/p>/)[1].replace(/[\u200B-\u200D\uFEFF]/g, "");
1504 |       //log(ans);
1505 |       ans_list.push(ans);
1506 |     }
1507 |   }
1508 |   //log(ans_list);
1509 |   return ans_list;
1510 | }
1511 | 
1512 | // 通过离线答题题库匹配答案
1513 | function get_ans_by_dati_tiku(que_txt, type) {
1514 |   let keyword = que_txt.replace(/\s/g, "");
1515 |   let ans_list = [];
1516 |   let ans = null;
1517 |   if (dati_tiku.length == 0) {return false;}
1518 |   //for (let ti of dati_tiku) {
1519 |   for (let i = dati_tiku.length - 1; i >= 0; i--) {
1520 |     let ti = dati_tiku[i];
1521 |     if (ti[0].indexOf(keyword) > -1) {
1522 |       ans = ti[1];
1523 |       if (ans != "None") {ans_list.push(ans);}
1524 |     }
1525 |   }
1526 |   //if (!ans || ans == "None") {return false;}
1527 |   if (!ans_list) {return false;}
1528 |   if (type && ans_list.length > 1) {
1529 |     for (let a of ans_list) {
1530 |       if (a.indexOf(type) > -1) {
1531 |         ans = a.replace(type, "");
1532 |         break;
1533 |       }
1534 |     }
1535 |   }
1536 |   log("匹配题库：", ans);
1537 |   return ans;
1538 | }
1539 | 
1540 | // 通过http请求匹配答题答案
1541 | function get_ans_by_http_dati(que_txt) {
1542 |   // 获取答案html并解析
1543 |   let keyword = que_txt.replace(/\s/g, "");
1544 |   let req = http.get('https://tiku.3141314.xyz/search?table_name=tiku&page=1&rows=20&keyword=' + encodeURI(keyword));
1545 |   let resp_json = req.body.json();
1546 |   if (resp_json["total"] == 0) {return false;}
1547 |   let rows = resp_json["rows"];
1548 |   log(rows[0]);
1549 |   let ans_list = [];
1550 |   let ans = rows[0]["answer"];
1551 |   if (ans == "None") {return false;}
1552 |   //log(ans_list);
1553 |   return ans;
1554 | }
1555 | 
1556 | // 检测|更新离线题库
1557 | function update_dati_tiku() {
1558 |   let total_req = http.get("https://tiku.3141314.xyz/tableCount");
1559 |   let total = 1;
1560 |   let last_dati_tiku_link = storage.get("dati_tiku_link", "");
1561 |   let dati_tiku = storage.get('dati_tiku', []);
1562 |   if (total_req.statusCode == 200) {
1563 |     total = total_req.body.json()[0][0];
1564 |   } else {
1565 |     try {
1566 |       //dati_tiku = get_tiku_by_ct('https://webapi.ctfile.com/get_file_url.php?uid=35157972&fid=555754562&file_chk=94c3c662ba28f583d2128a1eb9d78af4&app=0&acheck=2&rd=0.14725283060014105');
1567 |       //dati_tiku = get_tiku_by_gitee('https://gitee.com/songgedodo/songge_tiku/raw/master/dati_tiku.txt');
1568 |       if (update_info["dati_tiku_link"] != last_dati_tiku_link) {
1569 |         dati_tiku = get_tiku_by_http(update_info["dati_tiku_link"]);
1570 |         storage.put("dati_tiku_link", update_info["dati_tiku_link"]);
1571 |         storage.put('dati_tiku', dati_tiku);
1572 |         fInfo("未识别出在线题库，已更新离线题库");
1573 |       }
1574 |       else {fInfo("未检测到题库更新，已用历史题库");}
1575 |       return dati_tiku
1576 |     } catch (e) {
1577 |       console.warn(e);
1578 |       if (dati_tiku) {
1579 |         fInfo("未识别出离线题库，已用历史题库");
1580 |         return dati_tiku
1581 |       }
1582 |     }
1583 |   }
1584 |   //log("update total:", total);
1585 |   if (!dati_tiku || dati_tiku.length != total) {
1586 |     let req = http.get("https://tiku.3141314.xyz/getAnswer");
1587 |     if (req.statusCode == 200) {
1588 |       dati_tiku = req.body.json();
1589 |       storage.put('dati_tiku', dati_tiku);
1590 |       fInfo("题库已更新");
1591 |     }
1592 |     else {
1593 |       fInfo("网络问题识别不出在线题库");
1594 |     }
1595 |   }
1596 |   return dati_tiku;
1597 | }
1598 | 
1599 | //上传错题
1600 | function upload_wrong_exec(endstr) {
1601 |   text("答案解析").waitFor();
1602 |   let que_txt = "";
1603 |   if (textStartsWith("填空题").exists()) {
1604 |     let que = className("android.view.View").depth(24).findOnce(1).parent().parent().child(1).children();
1605 |     for (let i of que) {
1606 |       // 如果没有text则加个空格
1607 |       if (i.text()) {que_txt = que_txt + i.text();}
1608 |       else {
1609 |         que_txt = que_txt + "    ";
1610 |       }
1611 |     }
1612 |   }
1613 |   else {
1614 |     que_txt = className("android.view.View").depth(24).findOnce(1).parent().parent().child(1).text();
1615 |   }
1616 |   let ans_txt = textStartsWith("正确答案：").findOne().text().replace(/正确答案：|\s+/g, "");
1617 |   let question = que_txt.replace(/\s/g, "");
1618 |   if (endstr) {ans_txt += endstr;}
1619 |   fError("错题:", question, ans_txt);
1620 |   //dati_tiku.unshift([question, ans_txt, null, null, null]);
1621 |   dati_tiku.push([question, ans_txt, null, null, null]);
1622 |   try {
1623 |   	updateToServer(question,ans_txt);
1624 |   }
1625 |   catch (e) {log(e);}
1626 | }
1627 | 
1628 | // 上传题目：
1629 | function updateToServer(question,answer) {
1630 |   fInfo("开始上传");
1631 |   var res = http.post("https://tiku.3141314.xyz/insertOrUpdate", 
1632 |                       {"question": question,"answer": answer, "pswd": "X2417481092ZY"});
1633 |   if (res.body.json()==200) {
1634 |     fInfo("成功");
1635 |     return true;
1636 |   }
1637 |   else {
1638 |     log(res.body.string());
1639 |     return false;
1640 |   }
1641 | }
1642 | 
1643 | // 通过缓存题库获取答案
1644 | function get_ans_by_tiku(que_txt) {
1645 |   let ans_list = [];
1646 |   let max_simi = 0;
1647 |   for (let ti of Object.keys(tiku)) {
1648 |     //log(ti.replace(/[\s_]/g, "").indexOf(que_txt));
1649 |     let ti_txt = ti.replace(/\[.+\]|^\d+\./g, "").replace(/[^\u4e00-\u9fa5\d]/g, "");
1650 |     //log(ti_txt);
1651 |     let len = que_txt.length;
1652 |     let simi = str_similar(ti_txt.slice(0, len+6), que_txt);
1653 |     //if (ti_txt.indexOf(que_txt) >= 0) {
1654 |     if (simi >= 0.25) {
1655 |       if (simi > max_simi) {
1656 |         ans_list.length = 0;
1657 |         ans_list.push(tiku[ti][1]);
1658 |         max_simi = simi;
1659 |       }
1660 |       else if (simi == max_simi) {ans_list.push(tiku[ti][1]);}
1661 |     }
1662 |   }
1663 |   return ans_list;
1664 | }
1665 | 
1666 | // 获取直链json
1667 | function get_tiku_by_http(link) {
1668 |   // 通过gitee的原始数据保存题库
1669 |   if (!link) {link = "https://gitee.com/songgedodo/songge_tiku/raw/master/tiku_json.txt"}
1670 |   let req = http.get(link);
1671 |   // log(req.statusCode);
1672 |   // 更新题库时若获取不到，则文件名+1
1673 |   if (req.statusCode != 200) {
1674 |     fError("网络错误，获取资源失败，退出脚本");
1675 |     exit();
1676 |     return false;
1677 |   }
1678 |   return req.body.json();
1679 | }
1680 | 
1681 | // 获取gitee题库
1682 | function get_tiku_by_gitee(link) {
1683 |   // 通过gitee的原始数据保存题库
1684 |   if (!link) {link = "https://gitee.com/songgedodo/songge_tiku/raw/master/tiku_json.txt"}
1685 |   let req = http.get(link);
1686 |   log(req.statusCode);
1687 |   // 更新题库时若获取不到，则文件名+1
1688 |   if (req.statusCode != 200) {
1689 |     link2 = link.replace(/(\w+)(?=\.txt)/, "$1"+"1");
1690 |     log(link2);
1691 |     req = http.get(link2);
1692 |   }
1693 |   return req.body.json();
1694 | }
1695 | 
1696 | // 获取城通网盘题库
1697 | function get_tiku_by_ct(link) {
1698 |   // 获取答案html并解析
1699 |   // 城通网盘解析
1700 |   if (!link) {link = "https://webapi.ctfile.com/get_file_url.php?uid=35157972&fid=546999609&file_chk=e83f4b72a2f142cca6ee87c64baba15c&app=0&acheck=2&rd=0.9023931062078081"}
1701 |   let req = http.get(link);
1702 | //   let resp_str = req.body.string();
1703 | //   let result = eval("("+ resp_str + ")");
1704 |   let result = req.body.json();
1705 |   let file = http.get(result["downurl"]);
1706 | //   return eval("("+ file.body.string() + ")");
1707 |   return file.body.json();
1708 | }
1709 | 
1710 | // 把ocr结果转换为正序的字符串
1711 | function ocr_rslt_to_txt(result) {
1712 |   let top = 0;
1713 |   let previous_left = 0;
1714 |   let txt = "";
1715 |   let txt_list = [];
1716 |   for (let idx in result) {
1717 |     if (top == 0) {top = result[idx].bounds.top;}
1718 |     if (previous_left == 0) {previous_left = result[idx].bounds.left;}
1719 |     if (result[idx].bounds.top >= top-10 && result[idx].bounds.top <= top+10) {
1720 |       if (result[idx].bounds.left > previous_left) {txt = txt + "   " + result[idx].text;}
1721 |       else {txt = result[idx].text + "   " + txt;}
1722 |     }
1723 |     else {
1724 |       top = result[idx].bounds.top;
1725 |       txt_list.push(txt);
1726 |       txt = result[idx].text;
1727 |     }
1728 |     if (idx == result.length-1) {txt_list.push(txt);}
1729 |     previous_left = result[idx].bounds.left;
1730 |   }
1731 |   //每行直接加个换行
1732 |   let ans = txt_list.join("\n");
1733 |   //log(ans);
1734 |   return ans;
1735 | }
1736 | 
1737 | // 重启每日、每周
1738 | function restart(restart_flag) {
1739 |   // 点击退出
1740 |   ran_sleep();
1741 |   back();
1742 |   text("退出").findOne().click();
1743 |   ran_sleep();
1744 |   switch (restart_flag) {
1745 |       // 0为每日答题
1746 |     case 0:
1747 |       text('登录').waitFor();
1748 |       jifen_list.child(4).child(3).click();
1749 |       break;
1750 |       // 1为每周答题
1751 |     case 1:
1752 |       // 等待列表加载
1753 |       text('本月').waitFor();
1754 |       //当出现已作答时，点击最后一个未作答
1755 |       while (!text("已作答").exists()) {
1756 |         depth(21).scrollable().findOne().scrollForward();
1757 |         sleep(200);
1758 |       }
1759 |       var clt = text("未作答").find();
1760 |       clt[clt.length-1].parent().click();
1761 |       break;
1762 |   }
1763 | }
1764 | 
1765 | // 从首页进入积分界面初始化
1766 | function jifen_init() {
1767 |   id("comm_head_xuexi_score").findOne().click();
1768 |   while (true) {
1769 |     let denglu = className("android.view.View").depth(24).text("登录").findOne(9000);
1770 |     if (denglu) {break;}
1771 |     back();
1772 |     sleep(1000);
1773 |     id("comm_head_xuexi_score").findOne().click();
1774 |   }
1775 |   fRefocus();
1776 |   className("android.webkit.WebView").scrollable().findOne().scrollForward();
1777 |   //jifen_list = className("android.widget.ListView").depth(21).findOne();
1778 | }
1779 | 
1780 | // 模拟随机时间0.5-3秒，后期可以用户自定义
1781 | function ran_sleep() {
1782 |   return sleep(random(1000, delay_time));
1783 | }
1784 | 
1785 | // 比较两个字符串相似度
1786 | function str_similar(str1, str2) {
1787 |   str1 = str1.replace(/[^\u4e00-\u9fa5\u2460-\u2469\wāáǎàōóǒòēéěèīíǐìūúǔùüǖǘǚǜ]/g, "");
1788 |   str2 = str2.replace(/[^\u4e00-\u9fa5\u2460-\u2469\wāáǎàōóǒòēéěèīíǐìūúǔùüǖǘǚǜ]/g, "");
1789 |   if (str1 == str2) {return 99;}
1790 |   if (str1.length > str2.length) {
1791 |     var muzi = str2;
1792 |     var instr = str1;
1793 |   }
1794 |   else {
1795 |     muzi = str1;
1796 |     instr = str2;
1797 |   }
1798 |   let reg = "/[" + muzi + "]{1}/g";
1799 |   let resu = instr.match(eval(reg));
1800 | 	if (resu) {
1801 |     return (resu.length / instr.length);
1802 |   }
1803 | 	else {return 0;}
1804 | }
1805 | 
1806 | // 关闭音乐浮动插件
1807 | function close_video() {
1808 |   let imv = className("android.widget.ImageView").find();
1809 |   //log(imv.empty());
1810 |   let swtch = imv[imv.length-1];
1811 |   swtch.click();
1812 |   sleep(1000);
1813 |   swtch.click();
1814 |   return true;
1815 | }
1816 | 
1817 | // 屏幕宽高、方向初始化
1818 | function init_wh() {
1819 |   fInfo("屏幕方向检测");
1820 |   log(device.width + "*" + device.height);
1821 |   var device_w = depth(0).findOne().bounds().width();
1822 |   var device_h = depth(0).findOne().bounds().height();
1823 |   log(device_w + "*" + device_h);
1824 |   if (device.width == device_h && device.height == device_w) {
1825 |     fError("设备屏幕方向检测为横向，后续运行很可能会报错，建议调整后重新运行脚本");
1826 |     sleep(10000);
1827 |   }
1828 |   else if (device.width == 0 || device.height == 0) {
1829 |     fError("识别不出设备宽高，建议重启hamibot后重新运行脚本");
1830 |     sleep(10000);
1831 |   }
1832 |   return [device_w, device_h]
1833 | }
1834 | 
1835 | // 尝试成功点击
1836 | function real_click(obj) {
1837 |   for (let i=1; i<=3; i++) {
1838 |     if (obj.click()) {log("real click: true"); return true;}
1839 |     sleep(300);
1840 |   }
1841 |   console.warn("控件无法正常点击：", obj);
1842 |   log("尝试再次点击");
1843 |   click(obj.bounds().centerX(), obj.bounds().centerY());
1844 |   return false;
1845 | }
1846 | 
1847 | // 测试ocr功能
1848 | function ocr_test() {
1849 |   try {
1850 |     fInfo("测试ocr功能，开始截图");
1851 |     let img_test = captureScreen();
1852 |     img_test = images.clip(img_test, 0, 100, device_w, 250);
1853 |     log("开始识别");
1854 |     console.time("OCR识别结束");
1855 |     ocr.recognizeText(img_test);
1856 |     console.timeEnd("OCR识别结束");
1857 |     fInfo("OCR功能正常");
1858 |     img_test.recycle();
1859 |     return true;
1860 |   }
1861 |   catch (e) {
1862 |     fError(e+"：ocr功能异常，退出脚本");
1863 |     exit();
1864 |     return false;
1865 |   }
1866 | }
1867 | 
1868 | // pushplus推送
1869 | function send_pushplus(token) {
1870 |   let r = http.postJson("http://www.pushplus.plus/send", {
1871 |     token: token,
1872 |     title: "天天向上："+name,
1873 |     content: "用户**" + name + "**已完成：" + jinri + "\n总积分：" + zongfen,
1874 |     template: "markdown",
1875 |   });
1876 |   if (r.body.json()["code"] == 200) {fInfo("推送成功");}
1877 |   else {log(r.body.json());}
1878 | }
1879 | 
1880 | // 发送email通知
1881 | function send_email(email) {
1882 |   let reg = /[\w!#$%&'*+/=?^_`{|}~-]+(?:\.[\w!#$%&'*+/=?^_`{|}~-]+)*@(?:[\w](?:[\w-]*[\w])?\.)+[\w](?:[\w-]*[\w])?/;
1883 |   let e_addr = email.match(reg);
1884 |   if (!e_addr) {
1885 |     fError("请配置正确的邮件格式");
1886 |     return false;
1887 |   }
1888 |   let zongfen = jifen_list.parent().child(1).text();
1889 |   let content = "用户" + name + "已完成：" + zongfen;
1890 |   var data=app.intent({action: "SENDTO"});
1891 |   data.setData(app.parseUri("mailto:"+e_addr));
1892 |   data.putExtra(Intent.EXTRA_SUBJECT, "天天向上："+name);
1893 |   data.putExtra(Intent.EXTRA_TEXT, content);
1894 |   app.startActivity(data);
1895 |   return true;
1896 | }
1897 | 
1898 | // 强行退出应用名称
1899 | function exit_app(name) {
1900 |   // fClear();
1901 |   fInfo("尝试结束"+name+"APP");
1902 |   var packageName = getPackageName(name);
1903 |   if(!packageName){
1904 |     if(getAppName(name)){
1905 |       packageName = name;
1906 |     }else{
1907 |       return false;
1908 |     }
1909 |   }
1910 | 	log("打开应用设置界面");
1911 |   app.openAppSetting(packageName);
1912 |   var appName = app.getAppName(packageName);
1913 |   //log(appName);
1914 |   log("等待加载界面")
1915 |   //textMatches(/应用信息|应用详情/).findOne(5000);
1916 |   text(appName).findOne(5000);
1917 |   sleep(1500);
1918 |   log("查找结束按钮")
1919 |   //let stop = textMatches(/(^强行.*|.*停止$|^结束.*)/).packageNameMatches(/.*settings.*|.*securitycenter.*/).findOne();
1920 |   let stop = textMatches(/(强.停止$|.*停止$|结束运行|停止运行|[Ff][Oo][Rr][Cc][Ee] [Ss][Tt][Oo][Pp])/).findOne();
1921 |   log("stop:", stop.enabled())
1922 |   if (stop.enabled()) {
1923 |     //log("click:", stop.click());
1924 |     real_click(stop);
1925 |     sleep(1000);
1926 |     log("等待确认弹框")
1927 |     //let sure = textMatches(/(确定|^强行.*|.*停止$)/).packageNameMatches(/.*settings.*|.*securitycenter.*/).clickable().findOne();
1928 |     let sure = textMatches(/(确定|.*停止.*|[Ff][Oo][Rr][Cc][Ee] [Ss][Tt][Oo][Pp]|O[Kk])/).clickable().findOne(1500);
1929 |     if (!sure) {
1930 |       fInfo(appName + "应用已关闭");
1931 |       back();
1932 |       return false;
1933 |     }
1934 |     log("sure click:", sure.click());
1935 |     fInfo(appName + "应用已被关闭");
1936 |     sleep(1000);
1937 |     back();
1938 |   } else {
1939 |     fInfo(appName + "应用不能被正常关闭或不在后台运行");
1940 |     back();
1941 |   }
1942 |   return true;
1943 | }
1944 | 
1945 | // 登录
1946 | function login(username, pwd) {
1947 |   var begin_obj = idMatches(/.*comm_head_xuexi_mine|.*btn_next/).findOne();
1948 |   if (begin_obj.text() == "登录") {
1949 |     log("查找ab");
1950 |     let a = className("EditText").id("et_phone_input").findOne();
1951 |     let b = className("EditText").id("et_pwd_login").findOne();
1952 |     a.setText(username);
1953 |     sleep(1000);
1954 |     b.setText(pwd);
1955 |     sleep(1000);
1956 |     begin_obj.click();
1957 |     sleep(3000);
1958 |     let packageName = getPackageName('学习强国');
1959 |     if (currentPackage() != packageName) {
1960 |       log("检测到弹窗，尝试返回");
1961 |       if (textMatches(/取消/).exists()) {
1962 |         textMatches(/取消/).findOne().click();
1963 |       }
1964 |       else {back();}
1965 |     }
1966 |   }
1967 | }
1968 | 
1969 | // 更新内容弹窗
1970 | // function gengxin_show() {
1971 | //   var dlg = dialogs.build({
1972 | //     title: engine_version + "版更新内容", 
1973 | //     content: "请授予hamibot悬浮窗(显示在其他应用上层)权限\n更新只答四人赛版本，可以市场搜索 对战_test,运行测试后反馈给我",
1974 | //     positive: "确定", checkBoxPrompt: '不再提示',
1975 | //   }).show();
1976 | //   while (!dlg.isShowing()) {}
1977 | //   log("dialog showing");
1978 | //   while (dlg.isShowing()) {sleep(500);}
1979 | //   return dlg.promptCheckBoxChecked;
1980 | // }
1981 | 
1982 | // 显示一个对象的所有方法，不知道ocr的返回对象有啥方法
1983 | function displayProp(obj) {    
1984 |     var names="";
1985 |     for(var name in obj){
1986 |        names+=name+": "+obj[name]+", ";
1987 |     }
1988 |     log(names);
1989 | }
1990 | 
1991 | /*******************悬浮窗*******************/
1992 | function fInit() {
1993 |   // ScrollView下只能有一个子布局
1994 |   var w = floaty.rawWindow(
1995 |     <card cardCornerRadius='8dp' alpha="0.8">
1996 |       <vertical>
1997 |         <horizontal bg='#FF000000' padding='10 5'>
1998 |         <text textColor="#FFFFFF" textSize="18sp">天天向上+V9.0</text>
1999 |         <text id='title' h="*" textColor="#FFFFFF" textSize="13sp" layout_weight="1" gravity="top|right"></text>
2000 |         </horizontal>
2001 |         <ScrollView>
2002 |           <vertical bg='#AA000000' id='container' minHeight='20' gravity='center'></vertical>
2003 |         </ScrollView>
2004 |       </vertical>
2005 |     	<relative  gravity="right|bottom">
2006 |     		<text id="username" textColor="#FFFFFF" textSize="12sp" padding='5 0'></text>
2007 |     	</relative>
2008 |     </card>
2009 |   );
2010 |   ui.run(function() {
2011 |     w.title.setFocusable(true);
2012 |   });
2013 |   w.setSize(700, -2);
2014 |   w.setPosition(50, 50);
2015 |   w.setTouchable(false);
2016 |   return w;
2017 | }
2018 | 
2019 | function fSet(id, txt) {
2020 |   ui.run(function() {
2021 |     w.findView(id).setText(txt);
2022 |   });
2023 | }
2024 | 
2025 | function fInfo(str) {
2026 |   ui.run(function() {
2027 |     let textView = ui.inflate(
2028 |       <text id="info" maxLines="2" textColor="#7CFC00" textSize="15sp" padding='5 0'></text>,
2029 |       w.container);
2030 |     textView.setText(str);
2031 |     w.container.addView(textView);
2032 |   });
2033 |   console.info(str);
2034 | }
2035 | 
2036 | function fError(str) {
2037 |   ui.run(function() {
2038 |     let textView = ui.inflate(
2039 |       <text id="error" maxLines="2" textColor="#FF0000" textSize="15sp" padding='5 0'></text>,
2040 |       w.container);
2041 |     textView.setText(str);
2042 |     w.container.addView(textView);
2043 |   });
2044 |   console.error(str);
2045 | }
2046 | 
2047 | function fTips(str) {
2048 |   ui.run(function() {
2049 |     let textView = ui.inflate(
2050 |       <text id="tips" maxLines="2" textColor="#FFFF00" textSize="15sp" padding='5 0'></text>,
2051 |       w.container);
2052 |     textView.setText(str);
2053 |     w.container.addView(textView);
2054 |   });
2055 |   console.info(str);
2056 | }
2057 | 
2058 | function fClear() {
2059 |   ui.run(function() {
2060 |     w.container.removeAllViews();
2061 |   });
2062 | }
2063 | 
2064 | function fRefocus() {
2065 |   threads.start(function() {
2066 |     ui.run(function() {
2067 |       w.requestFocus();
2068 |       w.title.requestFocus();
2069 |       ui.post(function() {
2070 |         w.title.clearFocus();
2071 |         w.disableFocus();
2072 |       }, 200);
2073 |     });
2074 |   });
2075 |   sleep(500);
2076 | }
2077 | 
2078 | /*******************主程序部分*******************/
2079 | /********定义全局变量*********/
2080 | var jifen_list, meizhou_dao, zhuanxiang_dao, dingyue_dao, storage_user, name, jinri, zongfen;
2081 | // 分割账号
2082 | if (zhanghao) {
2083 |   var zhanghao_list = [];
2084 |   for (let zh of zhanghao.split("\n")) {
2085 |     let userinfo = zh.split(/:|：/);
2086 |     zhanghao_list.push(userinfo);
2087 |   };
2088 |   if (zhanghao_list.length > 3) {zhanghao_list.length = 3;}
2089 |   for (let userinfo of zhanghao_list) {
2090 |     main(userinfo[0], userinfo[1]);
2091 |   }
2092 |   fClear();
2093 |   fInfo("登录回账号1");
2094 |   login(zhanghao_list[0][0], zhanghao_list[0][1]);
2095 | } else {
2096 |   main();
2097 | }
2098 | 
2099 | // main("18802583389", "xhbj.39000");
2100 | // main("15849082086", "zhangfpan0711");
2101 | // main("17684809426", "qxpcdodo");
2102 | // main("18647101545", "zhoukun147753");
2103 | 
2104 | function main(username, pwd) {
2105 |   // 检测更新提示代码，出现就点掉
2106 |   fInfo("开始更新弹窗检测");
2107 |   var noupdate_thread = threads.start(function() {
2108 |     //在新线程执行的代码
2109 |     className("android.widget.Button").text("立即升级").waitFor();
2110 |     fInfo("检测到升级弹窗");
2111 |     sleep(1000);
2112 |     var btn = className("android.widget.Button").text("取消").findOne();
2113 |     btn.click();
2114 |     fInfo("已取消升级");
2115 |   });
2116 | //   var keepQG_thread = threads.start(function() {
2117 | //     //在新线程执行的代码
2118 | //     let packageName = getPackageName('学习强国');
2119 | //     while (true) {
2120 | //       try {
2121 | //         if (currentPackage() != packageName) {
2122 | //           fInfo("请切换回学习强国");
2123 | //         }
2124 | //         text("当做sleep方法").findOne(1000);
2125 | //       } catch (e) {console.warn(e);}
2126 | //     }
2127 | //   });
2128 |   /********登录*********/
2129 |   fClear();
2130 |   login(username, pwd);
2131 |   /********获取用户姓名并读取本地数据*********/
2132 |   text("我的").findOne().click();
2133 |   name = id("my_display_name").findOne().text();
2134 |   storage_user = storages.create('songgedodo:'+name);
2135 |   fSet("username", name);
2136 |   back();
2137 |   ran_sleep();
2138 |   if (meizhou == "zhengxu") {meizhou_dao = false;}
2139 |   else if (meizhou == "daoxu") {meizhou_dao = true;}
2140 |   if (zhuanxiang == "zhengxu") {zhuanxiang_dao = false;}
2141 |   else if (zhuanxiang == "daoxu") {zhuanxiang_dao = true;}
2142 |   if (dingyue == "zhengxu") {dingyue_dao = false;}
2143 |   else if (dingyue == "daoxu") {dingyue_dao = true;}
2144 |   // 中断地理位置弹窗检测
2145 |   if (nolocate_thread.isAlive()) {
2146 |     nolocate_thread.interrupt();
2147 |     fInfo("终止位置权限弹窗检测");
2148 |   }
2149 |   // 中断更新弹窗检测
2150 |   if (noupdate_thread.isAlive()) {
2151 |     noupdate_thread.interrupt();
2152 |     fInfo("终止更新弹窗检测");
2153 |   }
2154 | 
2155 |   /********进入积分界面*********/
2156 |   // 点击积分
2157 |   id("comm_head_xuexi_score").findOne().click();
2158 |   // 等待"登录"项目加载
2159 |   // className("android.view.View").depth(24).text("登录").waitFor();
2160 |   text("登录").waitFor();
2161 |   // 往下滑一段加载
2162 |   className("android.webkit.WebView").depth(18).findOne().scrollForward();
2163 |   // jifen_list第一层child[0-14]为每一项，第二层child{0:项目名称; 1:积分规则; 2:已获分数; 3:跳转按钮}
2164 |   jifen_list = className("android.widget.ListView").depth(21).findOne();
2165 | 
2166 |   // 先判断评论分享
2167 |   if (fenxiang == "true") {
2168 |     if (jifen_list.child(11).child(2).text().match(/\d+/)[0] == "0" || jifen_list.child(12).child(2).text().match(/\d+/)[0] == "0") {
2169 |       toastLog("开始分享和评论");
2170 |       do_fenxiang();
2171 |       jifen_list = className("android.widget.ListView").depth(21).findOne();
2172 |     }
2173 |   }
2174 |   if (shipin == "true" && jifen_list.child(2).child(3).text() != "已完成") { // 视听学习
2175 |     toastLog("开始视听次数");
2176 |     do_shipin();
2177 |     jifen_list = className("android.widget.ListView").depth(21).findOne();
2178 |   }
2179 |   if (wenzhang == "true" && jifen_list.child(1).child(3).text() != "已完成") { // 文章
2180 |     toastLog("开始文章次数与时长");
2181 |     do_wenzhang();
2182 |     jifen_list = className("android.widget.ListView").depth(21).findOne();
2183 |   }
2184 |   if (meiri == "true" && jifen_list.child(4).child(3).text() != "已完成") { // 每日答题
2185 |     toastLog("每日答题开始");
2186 |     do_meiri();
2187 |     jifen_list = className("android.widget.ListView").depth(21).findOne();
2188 |   }
2189 |   var meizhou_right = 1;
2190 |   if (meizhou != "false" && jifen_list.child(5).child(2).text().match(/\d+/)[0] == "0") { // 每周答题
2191 |     toastLog("每周答题开始");
2192 |     var meizhou_right = do_meizhou();
2193 |     while (!meizhou_right) {meizhou_right = do_meizhou();}
2194 |     jifen_list = className("android.widget.ListView").depth(21).findOne();
2195 |   }
2196 |   var zhuanxiang_right = 1;
2197 |   if (zhuanxiang != "false" && jifen_list.child(6).child(2).text().match(/\d+/)[0] == "0") { // 专项答题
2198 |     toastLog("专项答题开始");
2199 |     var zhuanxiang_right = do_zhuanxiang();
2200 |     jifen_list = className("android.widget.ListView").depth(21).findOne();
2201 |   }
2202 |   if (tiaozhan == "true" && jifen_list.child(7).child(3).text() != "已完成") { // 挑战答题
2203 |     toastLog("挑战答题开始");
2204 |     do_tiaozhan();
2205 |     jifen_list = className("android.widget.ListView").depth(21).findOne();
2206 |   }
2207 |   // 四人赛前先ocr功能测试
2208 |   ocr_test();
2209 |   if (siren == "true" && parseInt(jifen_list.child(8).child(2).text().match(/\d+/)[0]) <= 3) { // 四人两次
2210 |     toastLog("四人赛开始");
2211 |     do_duizhan1(4);
2212 |     do_duizhan1(4);
2213 |     let dacuo_n = Number(dacuo_num);
2214 |     if (dacuo_n) {
2215 |       fSet("title", "平衡胜率…");
2216 |       fClear();
2217 |       console.info("开始平衡胜率，答错次数："+dacuo_n);
2218 |       for (i=0; i<dacuo_n; i++) {
2219 |         fInfo("答错第"+ (i+1) + "轮");
2220 |         dacuo(4);
2221 |         fClear();
2222 |       }
2223 |     }
2224 |     jifen_list = className("android.widget.ListView").depth(21).findOne();
2225 |   }
2226 |   if (shuangren == "true" && jifen_list.child(9).child(2).text().match(/\d+/)[0] == "0") { // 双人对战
2227 |     toastLog("双人对战开始");
2228 |     do_duizhan1(2);
2229 |     jifen_list = className("android.widget.ListView").depth(21).findOne();
2230 |   }
2231 |   if (bendi == "true" && jifen_list.child(13).child(3).text() != "已完成") {
2232 |     toastLog("本地开始");
2233 |     do_bendi();
2234 |     jifen_list = className("android.widget.ListView").depth(21).findOne();
2235 |   }
2236 |   var dingyue_right = 1;
2237 |   if (dingyue != "false" && jifen_list.child(10).child(2).text().match(/\d+/)[0] == "0") { // 订阅
2238 |     toastLog("订阅开始");
2239 |     var dingyue_right = do_dingyue();
2240 |     jifen_list = className("android.widget.ListView").depth(21).findOne();
2241 |   }
2242 |   jinri = jifen_list.parent().child(1).text();
2243 |   zongfen = text("成长总积分").findOne().parent().child(3).text();
2244 |   if (meizhou != "false" && !meizhou_right) {
2245 |     fError("每周答题可能由于识别错误、包含视频题而不能满分，请手动作答");
2246 |   }
2247 |   if (dingyue != "false" && !dingyue_right) {
2248 |     fError("未能识别出订阅界面，订阅不支持学习强国V2.33.0以上版本");
2249 |   }
2250 |   // push+推送
2251 |   if (pushplus) {
2252 |     try {send_pushplus(pushplus);}
2253 |     catch (e) {fError(e+":push+推送失败，请尝试切换流量运行或者设置114DNS");}
2254 |   }
2255 |   if (!zhanghao) {return true}
2256 |   // 退出登录
2257 |   back();
2258 |   text("我的").findOne().click();
2259 |   log("等待设置按钮");
2260 |   let setting = id("my_setting").findOne();
2261 |   sleep(1000);
2262 |   log("点击设置按钮");
2263 |   real_click(setting);
2264 |   // log(setting.click());
2265 |   log("等待退出登录");
2266 |   let signout = id("setting_sign_out").findOne();
2267 |   sleep(1000);
2268 |   log("点击退出登录");
2269 |   real_click(signout);
2270 |   // log(signout.click());
2271 |   text("确认").findOne().click();
2272 |   return true
2273 | }
2274 | /*****************结束后配置*****************/
2275 | launch('com.hamibot.hamibot');
2276 | //console.show();
2277 | // console.clear();
2278 | fInfo("已全部结束");
2279 | // 调回原始音量
2280 | if (yl_on) {
2281 |   fInfo("调回初始音量:"+ yuan_yl);
2282 |   device.setMusicVolume(yuan_yl);
2283 | }
2284 | // 取消屏幕常亮
2285 | fInfo("取消屏幕常亮");
2286 | device.cancelKeepingAwake();
2287 | // exit_app("学习强国");
2288 | // if (email) {
2289 | //   send_email(email);
2290 | // }
2291 | // 震动提示
2292 | device.vibrate(500);
2293 | fInfo("十秒后关闭悬浮窗");
2294 | sleep(10000);
2295 | console.hide();
2296 | home();
2297 | 
2298 | 


--------------------------------------------------------------------------------
/TTXS_Pro/info.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "dati_tiku_version" : 20220719,
 3 |     "dati_tiku_link": "https://gitcode.net/m0_64980826/songge_tiku/-/raw/master/dati_tiku_20220719.txt",
 4 |     "dati_tiku_link2": "https://mart-17684809426.coding.net/p/tiku/d/tiku/git/raw/master/dati_tiku_20220719.txt?download=false",
 5 |     "tiku_version": 20220719,
 6 |     "tiku_link": "https://gitcode.net/m0_64980826/songge_tiku/-/raw/master/tiku_json_20220719.txt",
 7 |     "tiku_link2": "https://mart-17684809426.coding.net/p/tiku/d/tiku/git/raw/master/tiku_json_20220719.txt?download=false",
 8 |     "question_reg": "魏晋时期|立春时节|投笔|永乐皇帝|古代建筑|志愿者|预警信号|公狮|七律长征|太阳的大气层|含氧量|国之大事|体育健身|三部著作|泓水之战|本土作物|甲肝|古代皇帝|古代社会|超流体|气囊中|一条鱼|生肖邮票|医学奖|痛风|台风根据|幽禽|以下水域|冷热病|古典文学|龙泉窑址|敌友|唇形科|江苏目前",
 9 |     "include_reg": "排水口|古代兵器|变脸|培大豆|节能减排|四岳|鸳鸯|子午觉|汉字产生|宇宙中|变声|血型|长征四号|标准文字|力量体制|原始农业",
10 |     "default_ocr_replace": {"\\+":"十"},
11 |     "old_ocr_replace": {"[闵阅]值":"阈值","[點赔精]然失色":"黯然失色","九雪云外":"九霄云外"},
12 |     "accent_ocr_replace": {
13 |         "草营人":"草菅人","消[强洱]":"消弭","切[碟槎碳]":"切磋","并行不[停惊]?(?!背)":"并行不悖","[评呼]然心动":"怦然心动","[此吃北][陀吃呢]风云":"叱咤风云","cuotu[od]":"cuōtuó",
14 |         "chaiqian":"chāiqiǎn","浓意妄为":"恣意妄为","魔品":"赝品","九[^宵]?云外":"九霄云外","葱是生非":"惹是生非","言简意购":"言简意赅","追不及待":"迫不及待",
15 |         "脸炙人口":"脍炙人口","不落[集案室][白自]":"不落窠臼","针碗时[蜂摔辩]":"针砭时弊","[哆哔]峻":"啰唆","既往不[答智]":"既往不咎","组拿":"缉拿","鞭答":"鞭笞",
16 |         "暖[陀跑]":"蹉跎","跨踏":"踌躇","调帐":"惆怅","[任仟]悔":"忏悔","快[寄密窑]":"诀窍","浙临":"濒临","底护":"庇护","抵悟":"抵牾","情懒":"慵懒",
17 |         "[泽溶]炼":"淬炼","博奔":"博弈","[痘痉]李":"痉挛","[凌演]合":"凑合","神抵":"神祗","发物":"发轫","声名[鸽韵]起":"声名鹊起","貂鲜":"貂蝉","b6":"bù",
18 |         "[悠慈]气":"憋气","[继绎伴]脚石":"绊脚石","河汉":"河汊","修营":"修葺","杯盘狼精":"杯盘狼藉","有特无恐":"有恃无恐","蒸[^溜]?水":"蒸馏水",
19 |         "嘴之以鼻":"嗤之以鼻","款收":"歉收","[链挺]而走险":"铤而走险","[进母][康庸]置疑":"毋庸置疑","叫苦不[选送]":"叫苦不迭","鱼鲤":"鱼鳔","夏然而止":"戛然而止",
20 |         "相形见细":"相形见绌","饮鸽止渴":"饮鸠止渴","不[胜胚]而走":"不胫而走","[晖蹄]红":"蹿红","挑三栋四":"挑三拣四","沉酒":"沉湎","[忆恒]气":"怄气",
21 |         "跌[容岩]起伏":"跌宕起伏","声内":"声呐","蓝等充数":"滥竽充数","[驻姓]款":"赃款","差[造道]":"差遣","再接再历":"再接再厉","菱摩不振":"萎靡不振",
22 |         "喉声叹气":"唉声叹气","点.zhui":"点缀zhuì","寒暗":"寒暄","[组祖]击手":"狙击手","奴.?bi":"奴婢bì","矫.造作":"矫揉造作","巨壁":"巨擘","[壁跨]浑水":"蹚浑水",
23 |         ".之若[跨鹭]":"趋之若鹜","白暴白弃":"自暴自弃",
24 |         "粗[^矿]?(?!矿)":"粗犷","陷[^井]?(?!井)":"陷阱","古今杂[^揉]?(?!揉)":"古今杂糅",
25 |         "[^蟹\\.]?伏":"蛰伏","[^阀\\.]?值":"阈值","[^暗\\.]?然失色":"黯然失色"
26 |         },
27 |     "other_ocr_replace": {
28 |         "[斐翡表]秀":"裴秀","何族":"侗族","从[我戒]":"从戎","朱捷":"朱棣","李诚":"李诫","\\+儿":"十八","黄色.橙色.红色":"黄色-橙色-红色","狐虎兽":"狮虎兽",
29 |         "五岭.乌蒙.金沙.+?山":"五岭、乌蒙、金沙、大渡、岷山","([a-d].?)光球层、?色球层.*?(?=[a-d].?|$)":"$1光球层、色球层、日冕层","动脉巾":"动脉血",
30 |         "[福祝][成戒]":"祀戎","准备活动.基本活动.放松活动":"准备活动-基本活动-放松活动","诗经\\W+?春秋\\W+?论语":"诗经-春秋-论语","宋囊公":"宋襄公","南稻北栗":"南稻北粟",
31 |         "娄.+?传播":"粪-口传播","([a-d].?)龙有.?五爪.*?四爪.?(?=[a-d].?|$)":"$1龙有“五爪”，蟒有“四爪”","令媛":"令嫒","液氨":"液氦","氨气":"氮气","鱼鲜":"鱼鳞",
32 |         "庚电年":"庚申年","青营素":"青蒿素","[嘎嘿漂][岭吟]":"嘌呤","热带风晶":"热带风暴","合风":"台风","婴武":"鹦鹉","潮海":"渤海","症疾":"疟疾","刘森思|刘想":"刘勰",
33 |         "蜜头":"窑头","嘎觉":"嗅觉","苦塞":"苦寒","游猴":"猕猴"
34 |     },
35 |     "include_ocr_replace":{
36 |         "排水口":[["麒麟|鹿其"],"[蜗璃蝙]","螭"],"古代兵器":[["戈","矛"],"载","戟"],"变脸":[["京","豫"],"JI","川"],"培大豆":[["泰"],"[藏救]","菽"],
37 |         "节能减排":[["26","24","28"],"[^C]C","℃"],"四岳":[["舜","禹"],"解|鱼系","鲧"],"鸳鸯":[["爸","驾"],"驾","鸳"],"子午觉":[["23时","11时"],"一","—"],
38 |         "汉字产生":[["行书","楷书"],"小[豪拿蒙]","小篆"],"宇宙中":[["氧","碳"],"氨","氦"],"变声":[["氧气"],"氨气","氦气"],"血型":[["A型","B型"],"0","O"],
39 |         "长征四号":[["甲","丙"],"Z","乙"],"标准文字":[["隶书","金文"],"小[豪拿蒙]","小篆"],"力量体制":[["工","士"],"衣","农"],"原始农业":[["豆","麦"],"菜","粟"]
40 |     }
41 | }


--------------------------------------------------------------------------------
/main.js:
--------------------------------------------------------------------------------
  1 | "ui";
  2 | 
  3 | importClass(java.net.HttpURLConnection);
  4 | importClass(java.net.URL);
  5 | importClass(java.io.File);
  6 | importClass(java.io.FileOutputStream);
  7 | importClass(android.graphics.Color);
  8 | 
  9 | var color = "#FF4FB3FF";
 10 | 
 11 | ui.statusBarColor("#FF4FB3FF")
 12 | 
 13 | ui.layout(
 14 |     <drawer id="drawer">
 15 |         <vertical>
 16 |             <appbar>
 17 |                 <toolbar id="toolbar" bg="#ff4fb3ff" title="强国助手Pro"/>
 18 |                 <tabs id="tabs" bg="#ff4fb3ff"/>
 19 |             </appbar>
 20 |             <viewpager id="viewpager">
 21 |                 <frame>
 22 |                     <vertical>
 23 |                         <vertical gravity="center" layout_weight="1">
 24 |                             <card w="*" h="70" margin="10 5" cardCornerRadius="2dp" cardElevation="1dp" foreground="?selectableItemBackground">
 25 |                                 <horizontal gravity="center_vertical">
 26 |                                     <vertical padding="10 8" h="auto" w="0" layout_weight="1">
 27 |                                         <text text="Author：南栀北辰 " textColor="#222222" textSize="16sp" maxLines="1" />
 28 |                                         <text text="软件基于Better-Auto-XXQG修改，全部开源" textColor="#999999" textSize="14sp" maxLines="1" />
 29 |                                     </vertical>
 30 |                                 </horizontal>
 31 |                             </card>
 32 |                             <card w="*" h="70" margin="10 5" cardCornerRadius="2dp" cardElevation="1dp" foreground="?selectableItemBackground">
 33 |                                 <horizontal gravity="center_vertical">
 34 |                                     <vertical padding="10 8" h="auto" w="0" layout_weight="1">
 35 |                                         <text text="脚本选择" textColor="#222222" textSize="16sp" maxLines="1" />
 36 |                                         <text text="切换脚本后需在配置页设置" textColor="#999999" textSize="14sp" maxLines="1" />
 37 |                                     </vertical>
 38 |                                     <spinner id="script_chosen" marginLeft="4" marginRight="6" entries="AOTUQG-FIXED" />
 39 |                                 </horizontal>
 40 |                             </card>
 41 |                             <card w="*" h="70" margin="10 5" cardCornerRadius="2dp" cardElevation="1dp" foreground="?selectableItemBackground">
 42 |                                 <horizontal gravity="center_vertical">
 43 |                                     <vertical padding="10 8" h="auto" w="0" layout_weight="1">
 44 |                                         <text text="无障碍服务" textColor="#222222" textSize="16sp" maxLines="1" />
 45 |                                         <text text="请确保开启" textColor="#999999" textSize="14sp" maxLines="1" />
 46 |                                     </vertical>
 47 |                                     <checkbox id="autoService" marginLeft="4" marginRight="6" checked="{{auto.service != null}}" />
 48 |                                 </horizontal>
 49 |                             </card>
 50 |                             <card w="*" h="70" margin="10 5" cardCornerRadius="2dp" cardElevation="1dp" foreground="?selectableItemBackground">
 51 |                                 <horizontal gravity="center_vertical">
 52 |                                     <vertical padding="10 8" h="auto" w="0" layout_weight="1">
 53 |                                         <text text="悬浮窗权限" textColor="#222222" textSize="16sp" maxLines="1" />
 54 |                                         <text text="请确保开启" textColor="#999999" textSize="14sp" maxLines="1" />
 55 |                                     </vertical>
 56 |                                     <checkbox id="consoleshow" marginLeft="4" marginRight="6" checked="{{floaty.checkPermission()}}" />
 57 |                                 </horizontal>
 58 |                             </card>
 59 |                             <card w="*" h="70" margin="10 5" cardCornerRadius="2dp" cardElevation="1dp" foreground="?selectableItemBackground">
 60 |                                 <horizontal gravity="center_vertical">
 61 |                                     <vertical padding="10 8" h="auto" w="0" layout_weight="1">
 62 |                                         <text text="音量上键可以停止所有脚本运行" textColor="#222222" textSize="16sp" maxLines="1" />
 63 |                                     </vertical>
 64 |                                 </horizontal>
 65 |                             </card>
 66 |                         </vertical>
 67 |                         <vertical>
 68 |                             <button h="50" layout_gravity="center" id="log" textSize="18sp" color="#000000" bg="#00FF00" foreground="?selectableItemBackground" text="查看日志" />
 69 |                             <button h="70" id="start" text="开 始 学 习" textSize="25sp" color="#000000" bg="#FF4FB3FF" foreground="?selectableItemBackground"/>
 70 |                             <button h="50"  id="join_QQ" text="QQ群" textSize="25sp" color="#000000" bg="#FF1493" foreground="?selectableItemBackground"/>
 71 |                         </vertical>
 72 |                     </vertical>
 73 |                 </frame>
 74 |                 <ScrollView>
 75 |                     <frame>
 76 |                         <vertical id="ttxs_pro" gravity="center">
 77 |                             <horizontal  gravity="center_vertical" padding="5 5" >
 78 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
 79 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
 80 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="看门狗(秒)" />
 81 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="填1800就是超过30分钟重试" />
 82 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="空着或0默认5400秒，超过即重新执行" />
 83 |                                 </vertical> 
 84 |                                 <input id="ttxs_pro_watchdog" marginLeft="4" marginRight="6" text="1800"  hint="秒"  textSize="13sp"  inputType="number" />
 85 |                             </horizontal>
 86 |                             <horizontal  gravity="center_vertical" padding="5 5" >
 87 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
 88 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
 89 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="滑动验证的滑动时间(ms)" />
 90 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="空着或0不开启自动滑动验证，滑动分3段" />
 91 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="中间会折返一下，总时间是填的数值*3" />
 92 |                                 </vertical> 
 93 |                                 <input id="ttxs_pro_slide_verify" marginLeft="4" marginRight="6" text="300" textSize="13sp"  inputType="number" />
 94 |                             </horizontal>
 95 |                             <horizontal  gravity="center_vertical" padding="5 5" >
 96 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
 97 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
 98 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="无障碍模式2" />
 99 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="无障碍服务没问题就不勾选" />
100 |                                 </vertical>
101 |                                 <checkbox id="ttxs_pro_fast_mode" marginLeft="4" marginRight="6" checked="false" />
102 |                             </horizontal>
103 |                             <horizontal  gravity="center_vertical" padding="5 5" >
104 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
105 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
106 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="点点通功能" />
107 |                                 </vertical>
108 |                                 <checkbox id="ttxs_pro_ddtong" marginLeft="4" marginRight="6" checked="false" />
109 |                             </horizontal>
110 |                             <horizontal  gravity="center_vertical" padding="5 5" >
111 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
112 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
113 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="开始前强制结束强国" />
114 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="如果关闭，请确保强国已退出或在首页" />
115 |                                 </vertical>
116 |                                 <checkbox id="ttxs_pro_is_exit" marginLeft="4" marginRight="6" checked="true" />
117 |                             </horizontal>
118 |                             <horizontal  gravity="center_vertical" padding="5 5" >
119 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
120 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
121 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="评论" />
122 |                                 </vertical>
123 |                                 <checkbox id="ttxs_pro_pinglun" marginLeft="4" marginRight="6" checked="true" />
124 |                             </horizontal>
125 |                             <horizontal  gravity="center_vertical" padding="5 5" >
126 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
127 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
128 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="视听学习次数" />
129 |                                 </vertical>
130 |                                 <checkbox id="ttxs_pro_shipin" marginLeft="4" marginRight="6" checked="true" />
131 |                             </horizontal>
132 |                             <horizontal  gravity="center_vertical" padding="5 5" >
133 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
134 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
135 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="文章次数与时长" />
136 |                                 </vertical>
137 |                                 <checkbox id="ttxs_pro_wenzhang" marginLeft="4" marginRight="6" checked="true" />
138 |                             </horizontal>
139 |                             <horizontal  gravity="center_vertical" padding="5 5" >
140 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
141 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
142 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="每日答题" />
143 |                                 </vertical>
144 |                                 <checkbox id="ttxs_pro_meiri" marginLeft="4" marginRight="6" checked="true" />
145 |                             </horizontal>
146 |                             <horizontal  gravity="center_vertical" padding="5 5" >
147 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
148 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
149 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="每周答题" />
150 |                                     <spinner id="ttxs_pro_meizhou" marginLeft="4" marginRight="6" entries="最近一次已作答开始倒序|正序答题|不做" />
151 |                                 </vertical> 
152 |                             </horizontal>
153 |                             <horizontal  gravity="center_vertical" padding="5 5" >
154 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
155 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
156 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="专项答题" />
157 |                                     <spinner id="ttxs_pro_zhuanxiang" marginLeft="4" marginRight="6" entries="最近一次已作答开始倒序|正序答题|不做" />
158 |                                 </vertical> 
159 |                             </horizontal>
160 |                             <horizontal  gravity="center_vertical" padding="5 5" >
161 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
162 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
163 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="挑战答题" />
164 |                                 </vertical>
165 |                                 <checkbox id="ttxs_pro_tiaozhan" marginLeft="4" marginRight="6" checked="true" />
166 |                             </horizontal>
167 |                             <horizontal  gravity="center_vertical" padding="5 5" >
168 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
169 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
170 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="OCR选择" />
171 |                                     <spinner id="ttxs_pro_ocr_choice" marginLeft="4" marginRight="6" entries="GoogleMLKit|PaddleOCR|第三方插件" />
172 |                                 </vertical> 
173 |                             </horizontal>
174 |                             <horizontal  gravity="center_vertical" padding="5 5" >
175 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
176 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
177 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="ocr识别跳过阈值(ms)" />
178 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="空着或0默认5000，超过此时间会跳过多人对战" />
179 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="建议按照平时正常的ocr识别时间设置" />
180 |                                 </vertical> 
181 |                                 <input id="ttxs_pro_ocr_maxtime" marginLeft="4" marginRight="6" text="5000" textSize="13sp"  inputType="number" />
182 |                             </horizontal>
183 |                             <horizontal  gravity="center_vertical" padding="5 5" >
184 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
185 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
186 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="对战选项模式" />
187 |                                     <spinner id="ttxs_pro_duizhan_mode" marginLeft="4" marginRight="6" entries="随机顺序(等选项显示后识别答案)|固定顺序(历史遗留选项)|手动答题(识别答案后等待用户手动点击)" />
188 |                                 </vertical> 
189 |                             </horizontal>
190 |                             <horizontal  gravity="center_vertical" padding="5 5" >
191 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
192 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
193 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="对战极速模式延迟(历史遗留选项)" />
194 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="只在选项固定顺序时生效" />
195 |                                 </vertical> 
196 |                                 <input id="ttxs_pro_jisu" marginLeft="4" marginRight="6" text="0" textSize="13sp"  inputType="number" />
197 |                             </horizontal>
198 |                             <horizontal  gravity="center_vertical" padding="5 5" >
199 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
200 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
201 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="是否挂机跳过四人赛首局" />
202 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="首局匹配对手较强，挂机不会扣积分局数" />
203 |                                 </vertical>
204 |                                 <checkbox id="ttxs_pro_guaji" marginLeft="4" marginRight="6" checked="true" />
205 |                             </horizontal>
206 |                             <horizontal  gravity="center_vertical" padding="5 5" >
207 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
208 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
209 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="四人赛" />
210 |                                 </vertical>
211 |                                 <checkbox id="ttxs_pro_siren" marginLeft="4" marginRight="6" checked="true" />
212 |                             </horizontal>
213 |                             <horizontal  gravity="center_vertical" padding="5 5" >
214 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
215 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
216 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="平衡胜率(答错)次数" />
217 |                                 </vertical> 
218 |                                 <input id="ttxs_pro_dacuo_num" marginLeft="4" marginRight="6" text="2" textSize="13sp"  inputType="number" />
219 |                             </horizontal>
220 |                             <horizontal  gravity="center_vertical" padding="5 5" >
221 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
222 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
223 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="双人对战" />
224 |                                 </vertical>
225 |                                 <checkbox id="ttxs_pro_shuangren" marginLeft="4" marginRight="6" checked="true" />
226 |                             </horizontal>
227 |                             <horizontal  gravity="center_vertical" padding="5 5" >
228 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
229 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
230 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="本地" />
231 |                                 </vertical>
232 |                                 <checkbox id="ttxs_pro_bendi" marginLeft="4" marginRight="6" checked="true" />
233 |                             </horizontal>
234 |                             <horizontal  gravity="center_vertical" padding="5 5" >
235 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
236 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
237 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="订阅" />
238 |                                     <spinner id="ttxs_pro_dingyue" marginLeft="4" marginRight="6" entries="不做|正序订阅|只订阅年度上新" />
239 |                                 </vertical> 
240 |                             </horizontal>
241 |                             <horizontal  gravity="center_vertical" padding="5 5" >
242 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
243 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
244 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="pushplus_token(微信推送)" />
245 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="微信关注pushplus推送加，复制token填入" />
246 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="注意！搜索结果有两个，一定要关注正确" />
247 |                                     <input id="ttxs_pro_pushplus" text="" textSize="13sp" />
248 |                                 </vertical> 
249 |                             </horizontal>
250 |                             <horizontal  gravity="center_vertical" padding="5 5" >
251 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
252 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
253 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="是否启用音量调节" />
254 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="每次运行脚本后调节音量百分比" />
255 |                                 </vertical>
256 |                                 <checkbox id="ttxs_pro_yl_on" marginLeft="4" marginRight="6" checked="true" />
257 |                             </horizontal>
258 |                             <horizontal  gravity="center_vertical" padding="5 5" >
259 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
260 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
261 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="音量" />
262 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="调节音量百分比(只填数字)" />
263 |                                 </vertical> 
264 |                                 <input id="ttxs_pro_yinliang" marginLeft="4" marginRight="6" text="0" textSize="13sp"  inputType="number" />
265 |                             </horizontal>
266 |                             <horizontal  gravity="center_vertical" padding="5 5" >
267 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
268 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
269 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="多账号(选填，不限个数)" />
270 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="使用前确保所有账号都已完成短信验证" />
271 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="账号1:密码1:token1(换行/回车)账号2:密码2:token2(换行/回车)账号3:密码3:token3" />
272 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="结束后会自动登录回账号1" />
273 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="新增多账号1对1微信推送，按格式配置即可" />
274 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="没有则根据上面配置的pushplus_token为主" />
275 |                                     <input id="ttxs_pro_zhanghao" text="" textSize="13sp" />
276 |                                 </vertical> 
277 |                             </horizontal>
278 |                             <horizontal>
279 |                                 <button style="Widget.AppCompat.Button.Colored" id="ttxs_pro_save" text="保存配置" padding="12dp" w="*" />
280 |                             </horizontal>
281 |                             <horizontal>
282 |                                 <button style="Widget.AppCompat.Button.Colored" id="ttxs_pro_reset" text="恢复默认" padding="12dp" w="*" />
283 |                             </horizontal>
284 |                         </vertical>
285 |                         <vertical id="ttxs" gravity="center">
286 |                             <horizontal  gravity="center_vertical" padding="5 5" >
287 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
288 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
289 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="测试" />
290 |                                 </vertical>
291 |                                 <checkbox id="test_article1" marginLeft="4" marginRight="6" checked="true" />
292 |                             </horizontal>
293 |                         </vertical>
294 |                         <vertical id="study" gravity="center">
295 |                             <horizontal  gravity="center_vertical" padding="5 5" >
296 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
297 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
298 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="文章学习和广播收听" />
299 |                                 </vertical>
300 |                                 <checkbox id="study_article" marginLeft="4" marginRight="6" checked="true" />
301 |                             </horizontal>
302 |                             <horizontal  gravity="center_vertical" padding="5 5" >
303 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
304 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
305 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="视频学习" />
306 |                                     <spinner id="study_video" marginLeft="4" marginRight="6" entries="新百灵视频学习|看电视视频学习|百灵视频学习|不进行学习" />
307 |                                 </vertical> 
308 |                             </horizontal>
309 |                             <horizontal  gravity="center_vertical" padding="5 5" >
310 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
311 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
312 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="每日答题" />
313 |                                 </vertical> 
314 |                                 <checkbox id="study_meiri" marginLeft="4" marginRight="6" checked="true" />
315 |                             </horizontal>
316 |                             <horizontal  gravity="center_vertical" padding="5 5" >
317 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
318 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
319 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="挑战答题" />
320 |                                 </vertical> 
321 |                                 <checkbox id="study_tiaozhan" marginLeft="4" marginRight="6" checked="true" />
322 |                             </horizontal>
323 |                             <horizontal  gravity="center_vertical" padding="5 5" >
324 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
325 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
326 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="专项答题" />
327 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="建议手动答题，否则不保证全对" />
328 |                                 </vertical> 
329 |                                 <checkbox id="study_checkbox_01" marginLeft="4" marginRight="6" checked="true" />
330 |                             </horizontal>
331 |                             <horizontal  gravity="center_vertical" padding="5 5" >
332 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
333 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
334 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="每周答题" />
335 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="建议手动答题，否则不保证全对" />
336 |                                 </vertical> 
337 |                                 <checkbox id="study_checkbox_02" marginLeft="4" marginRight="6" checked="true" />
338 |                             </horizontal>
339 |                             <horizontal  gravity="center_vertical" padding="5 5" >
340 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
341 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
342 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="滑块验证延迟" />
343 |                                 </vertical> 
344 |                                 <input id="study_huakuaidelay" marginLeft="4" marginRight="6" text="300" textSize="13sp"  inputType="number" />
345 |                             </horizontal>
346 |                             <horizontal  gravity="center_vertical" padding="5 5" >
347 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
348 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
349 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="四人赛" />
350 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="可在答题页选择OCR配置，默认本地OCR" />
351 |                                 </vertical> 
352 |                                 <checkbox id="study_checkbox_03" marginLeft="4" marginRight="6" checked="true" />
353 |                             </horizontal>
354 |                             <horizontal  gravity="center_vertical" padding="5 5" >
355 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
356 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
357 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="双人对抗" />
358 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="可在答题页选择OCR配置，默认本地OCR" />
359 |                                 </vertical> 
360 |                                 <checkbox id="study_shuangren" marginLeft="4" marginRight="6" checked="true" />
361 |                             </horizontal>
362 |                             <horizontal  gravity="center_vertical" padding="5 5" >
363 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
364 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
365 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="专项答题模式选择" /> 
366 |                                     <spinner id="study_select" marginLeft="4" marginRight="6" entries="不向下滑动，只答当天的题目,没有则返回|向下滑动，直到找到可答题的题目" />
367 |                                 </vertical> 
368 |                             </horizontal>
369 |                             <horizontal  gravity="center_vertical" padding="5 5" >
370 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
371 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
372 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="每周答题模式选择" />
373 |                                     <spinner id="study_selectm" marginLeft="4" marginRight="6" entries="不向下滑动，只答当天的题目,没有则返回|向下滑动，直到找到可答题的题目" />
374 |                                 </vertical> 
375 |                             </horizontal>
376 |                             <horizontal  gravity="center_vertical" padding="5 5" >
377 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
378 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
379 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="四人赛模式选择" />
380 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="注：一般手机本地识别速度大于云端，部分手机内置ocr识别较慢，请自行测试" />
381 |                                     <spinner id="study_select_01" marginLeft="4" marginRight="6" entries="内置PaddleOCR->推荐|百度OCR接口,在OCR页配置" />
382 |                                 </vertical> 
383 |                             </horizontal>
384 |                             <horizontal  gravity="center_vertical" padding="5 5" >
385 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
386 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
387 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="四人/双人不受积分限制开关" />
388 |                                 </vertical> 
389 |                                 <checkbox id="study_xianzhi" marginLeft="4" marginRight="6" checked="false" />
390 |                             </horizontal>
391 |                             <horizontal  gravity="center_vertical" padding="5 5" >
392 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
393 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
394 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="四人/双人额外的随机答题次数(乱答)" />
395 |                                 </vertical> 
396 |                                 <input id="study_another" marginLeft="4" marginRight="6" text="1"  hint="乱答次数"  textSize="13sp"  inputType="number" />
397 |                             </horizontal>
398 |                             <horizontal  gravity="center_vertical" padding="5 5" >
399 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
400 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
401 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="每日、每周、专项答题增强模式" />
402 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="使用在线OCR识别答案" />
403 |                                     <spinner id="study_stronger" marginLeft="4" marginRight="6" entries="关闭|使用百度OCR识别答案" />
404 |                                 </vertical> 
405 |                             </horizontal>
406 |                             <horizontal  gravity="center_vertical" padding="5 5" >
407 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
408 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
409 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="百度OCR的API Key" />
410 |                                     <input id="study_AK" text=""  gravity="center" textSize="13sp" />
411 |                                 </vertical> 
412 |                             </horizontal>
413 |                             <horizontal  gravity="center_vertical" padding="5 5" >
414 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
415 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
416 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="百度OCR的Secret Key" />
417 |                                     <input id="study_SK" text=""  gravity="center" textSize="13sp" />
418 |                                 </vertical> 
419 |                             </horizontal>
420 |                             <horizontal>
421 |                                 <button style="Widget.AppCompat.Button.Colored" id="study_baidusave" text="保存并检查" padding="12dp" w="*" />
422 |                             </horizontal>
423 |                             <horizontal>
424 |                                 <button style="Widget.AppCompat.Button.Colored" id="study_baidureset" text="清空" padding="12dp" w="*" />
425 |                             </horizontal>
426 |                             <horizontal>
427 |                                 <button style="Widget.AppCompat.Button.Colored" id="study_baiduregister" text="注册百度智能云" padding="12dp" w="*" />
428 |                             </horizontal><horizontal  gravity="center_vertical" padding="5 5" >
429 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
430 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
431 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="订阅" />
432 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="仅支持学习强国2.33.0及以下版本" />
433 |                                     <spinner id="study_ssub" marginLeft="4" marginRight="6" entries="关闭|翻遍全部，直到订阅完成|只查看上新" />
434 |                                 </vertical> 
435 |                             </horizontal>
436 |                             <horizontal  gravity="center_vertical" padding="5 5" >
437 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
438 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
439 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="点点通刷满" />
440 |                                 </vertical> 
441 |                                 <checkbox id="study_diandian" marginLeft="4" marginRight="6" checked="false" />
442 |                             </horizontal>
443 |                             <horizontal  gravity="center_vertical" padding="5 5" >
444 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
445 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
446 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="看门狗(秒)" />
447 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="脚本运行的最长时间,超时/错误自动重启脚本" />
448 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="防止出现不可控错误,一般重启脚本即可解决" />
449 |                                 </vertical> 
450 |                                 <input id="study_alltime" marginLeft="4" marginRight="6" text="2000"  hint="秒"  textSize="13sp"  inputType="number" />
451 |                             </horizontal>
452 |                             <horizontal  gravity="center_vertical" padding="5 5" >
453 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
454 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
455 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="每篇文章学习时间" />
456 |                                 </vertical> 
457 |                                 <input id="study_time1" marginLeft="4" marginRight="6" text="61"  hint="秒"  textSize="13sp"  inputType="number" />
458 |                             </horizontal>
459 |                             <horizontal  gravity="center_vertical" padding="5 5" >
460 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
461 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
462 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="每个视频学习时间" />
463 |                                 </vertical> 
464 |                                 <input id="study_time2" marginLeft="4" marginRight="6" text="6"  hint="秒"  textSize="13sp"  inputType="number" />
465 |                             </horizontal>
466 |                             <horizontal  gravity="center_vertical" padding="5 5" >
467 |                                 <View bg="#00BFFF" h="*" w="10"  ></View>
468 |                                 <vertical padding="10 8" h="auto" w="0" layout_weight="1">
469 |                                     <text w="auto" textColor="#222222" textSize="15sp" text="push+ 消息推送" />
470 |                                     <text w="auto" textColor="#999999" textSize="12sp" text="注：有需要的自行填写push+的Token，否则留空即可" />
471 |                                     <input id="study_Token" text="" textSize="13sp" />
472 |                                 </vertical> 
473 |                             </horizontal>
474 |                             <horizontal>
475 |                                 <button style="Widget.AppCompat.Button.Colored" id="study_save" text="保存配置" padding="12dp" w="*" />
476 |                             </horizontal>
477 |                             <horizontal>
478 |                                 <button style="Widget.AppCompat.Button.Colored" id="study_reset" text="恢复默认" padding="12dp" w="*" />
479 |                             </horizontal>
480 |                         </vertical>
481 |                     </frame>
482 |                 </ScrollView>
483 |             </viewpager>
484 |         </vertical>
485 |     </drawer>
486 | );
487 | 
488 | 
489 | http.__okhttp__.setTimeout(10000);
490 | 
491 | 
492 | var GLOBAL_CONFIG = storages.create("GLOBAL_CONFIG");
493 | var TTXS_PRO_CONFIG = storages.create("TTXS_PRO_CONFIG");
494 | var STUDY_CONFIG = storages.create("STUDY_CONFIG");
495 | var BAIDUAPI = storages.create("BAIDUAPI");
496 | var execution = "";
497 | var thread = null;
498 | Initialize();
499 | 
500 | // 创建选项菜单(右上角)
501 | ui.emitter.on("create_options_menu", menu=>{
502 |     menu.add("日志");
503 |     menu.add("关于");
504 |     menu.add("Github");
505 |     menu.add("V2.33.0下载");
506 | });
507 | 
508 | //一键加qq群
509 | ui.join_QQ.click(function() {
510 |     // threads.start(加群)
511 |     //加群(qq群号);
512 |     var qq群号 = 938162384;
513 |     //加群(qq群号);
514 |     app.startActivity({
515 |         action: "android.intent.action.VIEW",
516 |         data: "mqqapi://card/show_pslcard?card_type=group&uin=" + qq群号,
517 |         packageName: "com.tencent.mobileqq",
518 |     }); //打开qq群名片
519 | })
520 | 
521 | // 监听选项菜单点击
522 | ui.emitter.on("options_item_selected", (e, item)=>{
523 |     switch(item.getTitle()){
524 |         case "日志":
525 |             app.startActivity("console");
526 |             break;
527 |         case "关于":
528 |             alert("关于", "强国助手Pro v"+latest_version);
529 |             break;
530 |         case "Github":
531 |             app.openUrl("https://github.com/Mr-zhao98");
532 |             break;
533 |         case "学习强国V2.33.0下载":
534 |             app.openUrl("https://android-apps.pp.cn/fs08/2021/12/28/3/110_f37c420b0944cb7b9f60a2ad9b5518d2.apk?yingid=web_space&packageid=500730793&md5=664bb7bdcae57be189fc86100f4371c4&minSDK=21&size=191654161&shortMd5=1fee0bd160d08108a9d9e5f4773ce741&crc32=3879122865&did=ad484a175e19d0928044435e24bf03cb");
535 |             break;
536 |     }
537 |     e.consumed = true;
538 | });
539 | activity.setSupportActionBar(ui.toolbar);
540 | 
541 | // 设置滑动页面的标题
542 | ui.viewpager.setTitles(["首页", "脚本配置"]);
543 | // 让滑动页面和标签栏联动
544 | ui.tabs.setupWithViewPager(ui.viewpager);
545 | 
546 | // 脚本选择监听
547 | var script_chosen_Listener = new android.widget.AdapterView.OnItemSelectedListener({
548 |     onItemSelected: function (parent, view, position, id) {
549 |         toastLog('选择脚本：' + ui.script_chosen.getSelectedItem());
550 |         if (ui.script_chosen.getSelectedItemPosition() == 0) {
551 |             ui.ttxs.visibility = 8;
552 |             ui.study.visibility = 8;
553 |             ui.ttxs_pro.visibility = 0;
554 |         }
555 |         else if (ui.script_chosen.getSelectedItemPosition() == 1) {
556 |             ui.ttxs_pro.visibility = 8;
557 |             ui.study.visibility = 8;
558 |             ui.ttxs.visibility = 0;
559 |         }
560 |         else if (ui.script_chosen.getSelectedItemPosition() == 2) {
561 |             ui.ttxs_pro.visibility = 8;
562 |             ui.ttxs.visibility = 8;
563 |             ui.study.visibility = 0;
564 |         }
565 |         GLOBAL_CONFIG.put("script_chosen", ui.script_chosen.getSelectedItemPosition());
566 |     }
567 | })
568 | ui.script_chosen.setOnItemSelectedListener(script_chosen_Listener);
569 | 
570 | // 用户勾选无障碍服务的选项时，跳转到页面让用户去开启 
571 | // android.permission.SYSTEM_ALERT_WINDOW
572 | ui.autoService.on("check", function (checked) {
573 |     if (checked && auto.service == null) {
574 |         app.startActivity({
575 |             action: "android.settings.ACCESSIBILITY_SETTINGS"
576 |         });
577 |     }
578 |     if (!checked && auto.service != null) {
579 |         auto.service.disableSelf();
580 |     }
581 | });
582 | 
583 | // 悬浮窗权限
584 | ui.consoleshow.on("check", function (checked) {
585 |     if (checked && !floaty.checkPermission()) {
586 |         app.startActivity({
587 |             packageName: "com.android.settings",
588 |             className: "com.android.settings.Settings$AppDrawOverlaySettingsActivity",
589 |             data: "package:" + context.getPackageName(),
590 |         });
591 |     }
592 | });
593 |  
594 | // 当用户回到本界面时，resume事件会被触发
595 | ui.emitter.on("resume", function () {
596 |     // 此时根据无障碍服务的开启情况，同步开关的状态
597 |     ui.autoService.checked = auto.service != null;
598 |     ui.consoleshow.checked = floaty.checkPermission();
599 | });
600 | 
601 | // 打开日志
602 | ui.log.click(function () {
603 |     app.startActivity("console");
604 | });
605 | 
606 | /*    //远程更新  ----------------------------------------------------窃取源码
607 | // 下载并运行所选脚本
608 | ui.start.click(function () {
609 |     threads.shutDownAll();
610 |     if (thread != null && thread.isAlive()) {
611 |         alert("注意", "脚本正在运行，请结束之前进程");
612 |         return;
613 |     }
614 |     threads.start(function () {
615 |         let url = 'https://ghproxy.com/https://raw.githubusercontent.com/sec-an/Better-Auto-XXQG/main/'+ui.script_chosen.getSelectedItemPosition()+'.js';
616 |         execution = engines.execScript("强国助手", http.get(url).body.string());
617 |     });
618 | });
619 |  */
620 | 
621 | 
622 | ui.start.click(function () {
623 |     threads.shutDownAll();
624 |     if (thread != null && thread.isAlive()) {
625 |         alert("注意", "脚本正在运行，请结束之前进程");
626 |         return;
627 |     }
628 |     threads.start(function () {
629 |         execution = engines.execScriptFile("./xxqg.js");
630 |     });
631 | });
632 | 
633 | 
634 | // 保存天天向上pro脚本设置
635 | ui.ttxs_pro_save.click(function () {
636 |     TTXS_PRO_CONFIG.put("watchdog", ui.ttxs_pro_watchdog.getText()+"");
637 |     TTXS_PRO_CONFIG.put("slide_verify", ui.ttxs_pro_slide_verify.getText()+"");
638 |     TTXS_PRO_CONFIG.put("fast_mode", ui.ttxs_pro_fast_mode.isChecked());
639 |     TTXS_PRO_CONFIG.put("ddtong", ui.ttxs_pro_ddtong.isChecked());
640 |     TTXS_PRO_CONFIG.put("is_exit", ui.ttxs_pro_is_exit.isChecked());
641 |     TTXS_PRO_CONFIG.put("pinglun", ui.ttxs_pro_pinglun.isChecked());
642 |     TTXS_PRO_CONFIG.put("shipin", ui.ttxs_pro_shipin.isChecked());
643 |     TTXS_PRO_CONFIG.put("wenzhang", ui.ttxs_pro_wenzhang.isChecked());
644 |     TTXS_PRO_CONFIG.put("meiri", ui.ttxs_pro_meiri.isChecked());
645 |     TTXS_PRO_CONFIG.put("meizhou", ui.ttxs_pro_meizhou.getSelectedItemPosition());
646 |     TTXS_PRO_CONFIG.put("zhuanxiang", ui.ttxs_pro_zhuanxiang.getSelectedItemPosition());
647 |     TTXS_PRO_CONFIG.put("tiaozhan", ui.ttxs_pro_tiaozhan.isChecked());
648 |     TTXS_PRO_CONFIG.put("ocr_choice", ui.ttxs_pro_ocr_choice.getSelectedItemPosition());
649 |     TTXS_PRO_CONFIG.put("ocr_maxtime", ui.ttxs_pro_ocr_maxtime.getText()+"");
650 |     TTXS_PRO_CONFIG.put("duizhan_mode", ui.ttxs_pro_duizhan_mode.getSelectedItemPosition());
651 |     TTXS_PRO_CONFIG.put("jisu", ui.ttxs_pro_jisu.getText()+"");
652 |     TTXS_PRO_CONFIG.put("guaji", ui.ttxs_pro_guaji.isChecked());
653 |     TTXS_PRO_CONFIG.put("siren", ui.ttxs_pro_siren.isChecked());
654 |     TTXS_PRO_CONFIG.put("dacuo_num", ui.ttxs_pro_dacuo_num.getText()+"");
655 |     TTXS_PRO_CONFIG.put("shuangren", ui.ttxs_pro_shuangren.isChecked());
656 |     TTXS_PRO_CONFIG.put("bendi", ui.ttxs_pro_bendi.isChecked());
657 |     TTXS_PRO_CONFIG.put("dingyue", ui.ttxs_pro_dingyue.getSelectedItemPosition());
658 |     TTXS_PRO_CONFIG.put("pushplus", ui.ttxs_pro_pushplus.getText()+"");
659 |     TTXS_PRO_CONFIG.put("yl_on", ui.ttxs_pro_yl_on.isChecked());
660 |     TTXS_PRO_CONFIG.put("yinliang", ui.ttxs_pro_yinliang.getText()+"");
661 |     TTXS_PRO_CONFIG.put("zhanghao", ui.ttxs_pro_zhanghao.getText()+"");
662 | 
663 |     toastLog("AUTOQG-FIXED配置保存成功！");
664 | });
665 | 
666 | // 重置天天向上pro脚本设置
667 | ui.ttxs_pro_reset.click(function () {
668 |     TTXS_PRO_CONFIG.put("watchdog", "1800");
669 |     ui.ttxs_pro_watchdog.setText(TTXS_PRO_CONFIG.get("watchdog"));
670 |     TTXS_PRO_CONFIG.put("slide_verify", "300");
671 |     ui.ttxs_pro_slide_verify.setText(TTXS_PRO_CONFIG.get("slide_verify"));
672 |     TTXS_PRO_CONFIG.put("fast_mode", false);
673 |     ui.ttxs_pro_fast_mode.setChecked(TTXS_PRO_CONFIG.get("fast_mode"));
674 |     TTXS_PRO_CONFIG.put("ddtong", false);
675 |     ui.ttxs_pro_ddtong.setChecked(TTXS_PRO_CONFIG.get("ddtong"));
676 |     TTXS_PRO_CONFIG.put("is_exit", true);
677 |     ui.ttxs_pro_is_exit.setChecked(TTXS_PRO_CONFIG.get("is_exit"));
678 |     TTXS_PRO_CONFIG.put("pinglun", true);
679 |     ui.ttxs_pro_pinglun.setChecked(TTXS_PRO_CONFIG.get("pinglun"));
680 |     TTXS_PRO_CONFIG.put("shipin", true);
681 |     ui.ttxs_pro_shipin.setChecked(TTXS_PRO_CONFIG.get("shipin"));
682 |     TTXS_PRO_CONFIG.put("wenzhang", true);
683 |     ui.ttxs_pro_wenzhang.setChecked(TTXS_PRO_CONFIG.get("wenzhang"));
684 |     TTXS_PRO_CONFIG.put("meiri", true);
685 |     ui.ttxs_pro_meiri.setChecked(TTXS_PRO_CONFIG.get("meiri"));
686 |     TTXS_PRO_CONFIG.put("meizhou", 0);
687 |     ui.ttxs_pro_meizhou.setSelection(TTXS_PRO_CONFIG.get("meizhou"));
688 |     TTXS_PRO_CONFIG.put("zhuanxiang", 0);
689 |     ui.ttxs_pro_zhuanxiang.setSelection(TTXS_PRO_CONFIG.get("zhuanxiang"));
690 |     TTXS_PRO_CONFIG.put("tiaozhan", true);
691 |     ui.ttxs_pro_tiaozhan.setChecked(TTXS_PRO_CONFIG.get("tiaozhan"));
692 |     TTXS_PRO_CONFIG.put("ocr_choice", 0);
693 |     ui.ttxs_pro_ocr_choice.setSelection(TTXS_PRO_CONFIG.get("ocr_choice"));
694 |     TTXS_PRO_CONFIG.put("ocr_maxtime", "5000");
695 |     ui.ttxs_pro_ocr_maxtime.setText(TTXS_PRO_CONFIG.get("ocr_maxtime"));
696 |     TTXS_PRO_CONFIG.put("duizhan_mode", 0);
697 |     ui.ttxs_pro_duizhan_mode.setSelection(TTXS_PRO_CONFIG.get("duizhan_mode"));
698 |     TTXS_PRO_CONFIG.put("jisu", "0");
699 |     ui.ttxs_pro_jisu.setText(TTXS_PRO_CONFIG.get("jisu"));
700 |     TTXS_PRO_CONFIG.put("guaji", true);
701 |     ui.ttxs_pro_guaji.setChecked(TTXS_PRO_CONFIG.get("guaji"));
702 |     TTXS_PRO_CONFIG.put("siren", true);
703 |     ui.ttxs_pro_siren.setChecked(TTXS_PRO_CONFIG.get("siren"));
704 |     TTXS_PRO_CONFIG.put("dacuo_num", "2");
705 |     ui.ttxs_pro_dacuo_num.setText(TTXS_PRO_CONFIG.get("dacuo_num"));
706 |     TTXS_PRO_CONFIG.put("shuangren", true);
707 |     ui.ttxs_pro_shuangren.setChecked(TTXS_PRO_CONFIG.get("shuangren"));
708 |     TTXS_PRO_CONFIG.put("bendi", true);
709 |     ui.ttxs_pro_bendi.setChecked(TTXS_PRO_CONFIG.get("bendi"));
710 |     TTXS_PRO_CONFIG.put("dingyue", 0);
711 |     ui.ttxs_pro_dingyue.setSelection(TTXS_PRO_CONFIG.get("dingyue"));
712 |     TTXS_PRO_CONFIG.put("pushplus", "");
713 |     ui.ttxs_pro_pushplus.setText(TTXS_PRO_CONFIG.get("pushplus"));
714 |     TTXS_PRO_CONFIG.put("yl_on", true);
715 |     ui.ttxs_pro_yl_on.setChecked(TTXS_PRO_CONFIG.get("yl_on"));
716 |     TTXS_PRO_CONFIG.put("yinliang", "0");
717 |     ui.ttxs_pro_yinliang.setText(TTXS_PRO_CONFIG.get("yinliang"));
718 |     TTXS_PRO_CONFIG.put("zhanghao", "");
719 |     ui.ttxs_pro_zhanghao.setText(TTXS_PRO_CONFIG.get("zhanghao"));
720 | 
721 |     toastLog("AUTOQG-FIXED配置恢复默认！");
722 | });
723 | 
724 | // 保存study脚本设置
725 | ui.study_save.click(function () {
726 |     STUDY_CONFIG.put("article", ui.study_article.isChecked());
727 |     STUDY_CONFIG.put("video", ui.study_video.getSelectedItemPosition());
728 |     STUDY_CONFIG.put("meiri", ui.study_meiri.isChecked());
729 |     STUDY_CONFIG.put("tiaozhan", ui.study_tiaozhan.isChecked());
730 |     STUDY_CONFIG.put("checkbox_01", ui.study_checkbox_01.isChecked());
731 |     STUDY_CONFIG.put("checkbox_02", ui.study_checkbox_02.isChecked());
732 |     STUDY_CONFIG.put("checkbox_03", ui.study_checkbox_03.isChecked());
733 |     STUDY_CONFIG.put("shuangren", ui.study_shuangren.isChecked());
734 | 
735 |     STUDY_CONFIG.put("huakuaidelay", ui.study_huakuaidelay.getText()+"");
736 |     STUDY_CONFIG.put("select", ui.study_select.getSelectedItemPosition());
737 |     STUDY_CONFIG.put("selectm", ui.study_selectm.getSelectedItemPosition());
738 |     STUDY_CONFIG.put("select_01", ui.study_select_01.getSelectedItemPosition());
739 |     STUDY_CONFIG.put("xianzhi", ui.study_xianzhi.isChecked());
740 |     STUDY_CONFIG.put("another", ui.study_another.getText()+"");
741 |     STUDY_CONFIG.put("stronger", ui.study_stronger.getSelectedItemPosition());
742 | 
743 |     STUDY_CONFIG.put("ssub", ui.study_ssub.getSelectedItemPosition());
744 |     STUDY_CONFIG.put("diandian", ui.study_diandian.isChecked());
745 |     STUDY_CONFIG.put("alltime", ui.study_alltime.getText()+"");
746 |     STUDY_CONFIG.put("time1", ui.study_time1.getText()+"");
747 |     STUDY_CONFIG.put("time2", ui.study_time2.getText()+"");
748 |     STUDY_CONFIG.put("Token", ui.study_Token.getText()+"");
749 | 
750 |     toastLog("STUDY配置保存成功！");
751 | });
752 | 
753 | // 重置study脚本设置
754 | ui.study_reset.click(function () {
755 |     STUDY_CONFIG.put("article", true);
756 |     STUDY_CONFIG.put("video", 0);
757 |     STUDY_CONFIG.put("meiri", true);
758 |     STUDY_CONFIG.put("tiaozhan", true);
759 |     STUDY_CONFIG.put("checkbox_01", true);
760 |     STUDY_CONFIG.put("checkbox_02", true);
761 |     STUDY_CONFIG.put("checkbox_03", true);
762 |     STUDY_CONFIG.put("shuangren", true);
763 |     ui.study_article.setChecked(STUDY_CONFIG.get("article"));
764 |     ui.study_video.setSelection(STUDY_CONFIG.get("video"));
765 |     ui.study_meiri.setChecked(STUDY_CONFIG.get("meiri"));
766 |     ui.study_tiaozhan.setChecked(STUDY_CONFIG.get("tiaozhan"));
767 |     ui.study_checkbox_01.setChecked(STUDY_CONFIG.get("checkbox_01"));
768 |     ui.study_checkbox_02.setChecked(STUDY_CONFIG.get("checkbox_02"));
769 |     ui.study_checkbox_03.setChecked(STUDY_CONFIG.get("checkbox_03"));
770 |     ui.study_shuangren.setChecked(STUDY_CONFIG.get("shuangren"));
771 | 
772 |     STUDY_CONFIG.put("huakuaidelay", "300");
773 |     STUDY_CONFIG.put("select", 0);
774 |     STUDY_CONFIG.put("selectm", 0);
775 |     STUDY_CONFIG.put("select_01", 0);
776 |     STUDY_CONFIG.put("xianzhi", false);
777 |     STUDY_CONFIG.put("another", "1");
778 |     STUDY_CONFIG.put("stronger", 0);
779 |     ui.study_huakuaidelay.setText(STUDY_CONFIG.get("huakuaidelay"));
780 |     ui.study_select.setSelection(STUDY_CONFIG.get("select"));
781 |     ui.study_selectm.setSelection(STUDY_CONFIG.get("selectm"));
782 |     ui.study_select_01.setSelection(STUDY_CONFIG.get("select_01"));
783 |     ui.study_xianzhi.setChecked(STUDY_CONFIG.get("xianzhi"));
784 |     ui.study_another.setText(STUDY_CONFIG.get("another"));
785 |     ui.study_stronger.setSelection(STUDY_CONFIG.get("stronger"));
786 | 
787 |     STUDY_CONFIG.put("ssub", 0);
788 |     STUDY_CONFIG.put("diandian", false);
789 |     STUDY_CONFIG.put("alltime", "2000");
790 |     STUDY_CONFIG.put("time1", "61");
791 |     STUDY_CONFIG.put("time2", "6");
792 |     STUDY_CONFIG.put("Token", "");
793 |     ui.study_ssub.setSelection(STUDY_CONFIG.get("ssub"));
794 |     ui.study_diandian.setChecked(STUDY_CONFIG.get("diandian"));
795 |     ui.study_alltime.setText(STUDY_CONFIG.get("alltime"));
796 |     ui.study_time1.setText(STUDY_CONFIG.get("time1"));
797 |     ui.study_time2.setText(STUDY_CONFIG.get("time2"));
798 |     ui.study_Token.setText(STUDY_CONFIG.get("Token"));
799 | 
800 |     toastLog("STUDY配置恢复默认！");
801 | });
802 | 
803 | ui.study_baidusave.click(function () {
804 |     check_baidu_api();
805 | });
806 | 
807 | ui.study_baidureset.click(function () {
808 |     BAIDUAPI.put("AK", "");
809 |     BAIDUAPI.put("SK", "");
810 |     ui.study_AK.setText(BAIDUAPI.get("AK", ""));
811 |     ui.study_SK.setText(BAIDUAPI.get("SK", ""));
812 |     toastLog("百度API恢复默认！");
813 | });
814 | 
815 | ui.study_baiduregister.click(function () {
816 |     app.openUrl("https://cloud.baidu.com/doc/OCR/s/dk3iqnq51");
817 | });
818 | 
819 | // 读取脚本设置
820 | function Initialize() {
821 |     ui.script_chosen.setSelection(GLOBAL_CONFIG.get("script_chosen", 0));
822 | 
823 |     ui.ttxs_pro_watchdog.setText(TTXS_PRO_CONFIG.get("watchdog", "1800"));
824 |     ui.ttxs_pro_slide_verify.setText(TTXS_PRO_CONFIG.get("slide_verify", "300"));
825 |     ui.ttxs_pro_fast_mode.setChecked(TTXS_PRO_CONFIG.get("fast_mode", false));
826 |     ui.ttxs_pro_ddtong.setChecked(TTXS_PRO_CONFIG.get("ddtong", false));
827 |     ui.ttxs_pro_is_exit.setChecked(TTXS_PRO_CONFIG.get("is_exit", true));
828 |     ui.ttxs_pro_pinglun.setChecked(TTXS_PRO_CONFIG.get("pinglun", true));
829 |     ui.ttxs_pro_shipin.setChecked(TTXS_PRO_CONFIG.get("shipin", true));
830 |     ui.ttxs_pro_wenzhang.setChecked(TTXS_PRO_CONFIG.get("wenzhang", true));
831 |     ui.ttxs_pro_meiri.setChecked(TTXS_PRO_CONFIG.get("meiri", true));
832 |     ui.ttxs_pro_meizhou.setSelection(TTXS_PRO_CONFIG.get("meizhou", 0));
833 |     ui.ttxs_pro_zhuanxiang.setSelection(TTXS_PRO_CONFIG.get("zhuanxiang", 0));
834 |     ui.ttxs_pro_tiaozhan.setChecked(TTXS_PRO_CONFIG.get("tiaozhan", true));
835 |     ui.ttxs_pro_ocr_choice.setSelection(TTXS_PRO_CONFIG.get("ocr_choice", 0));
836 |     ui.ttxs_pro_ocr_maxtime.setText(TTXS_PRO_CONFIG.get("ocr_maxtime", "5000"));
837 |     ui.ttxs_pro_duizhan_mode.setSelection(TTXS_PRO_CONFIG.get("duizhan_mode", 0));
838 |     ui.ttxs_pro_jisu.setText(TTXS_PRO_CONFIG.get("jisu", "0"));
839 |     ui.ttxs_pro_guaji.setChecked(TTXS_PRO_CONFIG.get("guaji", true));
840 |     ui.ttxs_pro_siren.setChecked(TTXS_PRO_CONFIG.get("siren", true));
841 |     ui.ttxs_pro_dacuo_num.setText(TTXS_PRO_CONFIG.get("dacuo_num", "2"));
842 |     ui.ttxs_pro_shuangren.setChecked(TTXS_PRO_CONFIG.get("shuangren", true));
843 |     ui.ttxs_pro_bendi.setChecked(TTXS_PRO_CONFIG.get("bendi", true));
844 |     ui.ttxs_pro_dingyue.setSelection(TTXS_PRO_CONFIG.get("dingyue", 0));
845 |     ui.ttxs_pro_pushplus.setText(TTXS_PRO_CONFIG.get("pushplus", ""));
846 |     ui.ttxs_pro_yl_on.setChecked(TTXS_PRO_CONFIG.get("yl_on", true));
847 |     ui.ttxs_pro_yinliang.setText(TTXS_PRO_CONFIG.get("yinliang", "0"));
848 |     ui.ttxs_pro_zhanghao.setText(TTXS_PRO_CONFIG.get("zhanghao", ""));
849 | 
850 |     ui.study_article.setChecked(STUDY_CONFIG.get("article", true));
851 |     ui.study_video.setSelection(STUDY_CONFIG.get("video", 0));
852 |     ui.study_meiri.setChecked(STUDY_CONFIG.get("meiri", true));
853 |     ui.study_tiaozhan.setChecked(STUDY_CONFIG.get("tiaozhan", true));
854 |     ui.study_checkbox_01.setChecked(STUDY_CONFIG.get("checkbox_01", true));
855 |     ui.study_checkbox_02.setChecked(STUDY_CONFIG.get("checkbox_02", true));
856 |     ui.study_checkbox_03.setChecked(STUDY_CONFIG.get("checkbox_03", true));
857 |     ui.study_huakuaidelay.setText(STUDY_CONFIG.get("huakuaidelay", "300"));
858 |     ui.study_shuangren.setChecked(STUDY_CONFIG.get("shuangren", true));
859 |     ui.study_select.setSelection(STUDY_CONFIG.get("select", 0));
860 |     ui.study_selectm.setSelection(STUDY_CONFIG.get("selectm", 0));
861 |     ui.study_select_01.setSelection(STUDY_CONFIG.get("select_01", 0));
862 |     ui.study_xianzhi.setChecked(STUDY_CONFIG.get("xianzhi", false));
863 |     ui.study_another.setText(STUDY_CONFIG.get("another", "1"));
864 |     ui.study_stronger.setSelection(STUDY_CONFIG.get("stronger", 0));
865 |     ui.study_AK.setText(BAIDUAPI.get("AK", ""));
866 |     ui.study_SK.setText(BAIDUAPI.get("SK", ""));
867 |     ui.study_ssub.setSelection(STUDY_CONFIG.get("ssub", 0));
868 |     ui.study_diandian.setChecked(STUDY_CONFIG.get("diandian", false));
869 |     ui.study_alltime.setText(STUDY_CONFIG.get("alltime", "2000"));
870 |     ui.study_time1.setText(STUDY_CONFIG.get("time1", "61"));
871 |     ui.study_time2.setText(STUDY_CONFIG.get("time2", "6"));
872 |     ui.study_Token.setText(STUDY_CONFIG.get("Token", ""));
873 | }
874 | 
875 | // 检查百度API
876 | function check_baidu_api() {
877 |     thread = threads.start(function () {
878 |         let AK = String(ui.study_AK.getText());
879 |         let SK = String(ui.study_SK.getText());
880 |         var res = http.post(
881 |             'https://aip.baidubce.com/oauth/2.0/token', {
882 |                 grant_type: 'client_credentials',
883 |                 client_id: AK,
884 |                 client_secret: SK
885 |             }
886 |         ).body.json();
887 |         if ("error" in res) {
888 |             toastLog("API Key或Secret Key存在错误");
889 |             console.log(AK);
890 |             console.log(SK);
891 |             ui.study_AK.setText(BAIDUAPI.get("AK", ""));
892 |             ui.study_SK.setText(BAIDUAPI.get("SK", ""));
893 |             BAIDUAPI.put("AK", "");
894 |             BAIDUAPI.put("SK", "");
895 |         } else {
896 |             toastLog("API Key、Secret Key正确，且已缓存");
897 |             BAIDUAPI.put("AK", AK);
898 |             BAIDUAPI.put("SK", SK);
899 |         }
900 |     });
901 | }
902 | 
903 | // APP更新提示
904 | function checkversion() {
905 |     var releaseNotes = "版本 v" + latest_version + "\n" +
906 |         "更新日志:\n" +
907 |         "* 1.基于AutoX v6.3.4重新打包\n" +
908 |         "* 2.调整默认OCR为Google ML kIT OCR"
909 |     dialogs.build({
910 |             title: "发现新版本",
911 |             content: releaseNotes,
912 |             positive: "立即下载",
913 |             negative: "取消",
914 |             neutral: "浏览器下载",
915 |             checkBoxPrompt: "不再提示",
916 |             cancelable: false
917 |         })
918 |         .on("positive", () => {
919 |             download(apkurl);
920 |         })
921 |         .on("neutral", () => {
922 |             app.openUrl(apkurl);
923 |         })
924 |         .on("check", (checked) => {
925 |             GLOBAL_CONFIG.put("NO_UPDATE", 1);
926 |         }).show();
927 | }
928 | 
929 | // 打开下载进度面板
930 | function download(url) {
931 |     downloadDialog = dialogs.build({
932 |         title: "正在下载...",
933 |         progress: {
934 |             max: 100,
935 |             showMinMax: true
936 |         },
937 |         autoDismiss: false,
938 |         cancelable: false
939 |     }).show();
940 |     startDownload(url);
941 | }
942 | 
943 | // 下载apk的主方法体
944 | function startDownload(url) {
945 |     threads.start(function () {
946 |         var path = files.cwd() + "/new.apk";
947 |         let apkFile = new File(path);
948 |         var conn = new URL(url).openConnection();
949 |         conn.connect();
950 |         let is = conn.getInputStream();
951 |         let length = conn.getContentLength();
952 |         let fos = new FileOutputStream(apkFile);
953 |         let count = 0;
954 |         let buffer = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, 1024);
955 |         while (true) {
956 |             var p = ((count / length) * 100);
957 |             let numread = is.read(buffer);
958 |             count += numread;
959 |             // 下载完成
960 |             if (numread < 0) {
961 |                 toast("下载完成");
962 |                 downloadDialog.dismiss();
963 |                 downloadDialog = null;
964 |                 break;
965 |             }
966 |             // 更新进度条
967 |             downloadDialog.setProgress(p);
968 |             fos.write(buffer, 0, numread);
969 |         }
970 |         fos.close();
971 |         is.close();
972 |         //自动打开进行安装
973 |         app.viewFile(path);
974 |     })
975 | }


--------------------------------------------------------------------------------
/project.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "assets": [],
 3 |   "build": {
 4 |     "build_number": 0,
 5 |     "build_time": 0
 6 |   },
 7 |   "useFeatures": [],
 8 |   "icon": "res/logo.png",
 9 |   "main": "main.js",
10 |   "name": "强国助手Pro",
11 |   "packageName": "com.auto.xxqgpro",
12 |   "scripts": {},
13 |   "versionCode": 1,
14 |   "versionName": "1.0.0"
15 | }


--------------------------------------------------------------------------------