.
675 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
学习强国——挑战答题题库
3 |
4 |
5 | 
6 |
7 |
8 | 
9 |
10 |
11 |
12 |
13 |
14 | 简单胜过繁杂
15 |
16 | ---
17 | ##### 一、注意：
18 | 1. 格式：
19 | json文件中的格式是：`问题|答案1|答案2|...:正确答案`。问题(去除空格)，与可选答案之间以`|`符号分隔。
20 | `题库_排序版.json`为保证题目的唯一性，先去除可选答案的序号，再对几个选项进行列表排序。
21 | 2. 预览
22 | 首页不再显示题目，可点击`题库_排序版.md`文件全览题目
23 | 3. 数据来源
24 | 根据安卓手机无障碍服务获取控件内容，并在`挑战答题`页面自动答题获得全部题目与正确答案。
25 | 因获取时间跨度较长，同一题目可能存在不同版本，一并保留。
26 | 4. 脚本
27 | 详情见`xxqg_tiku_client/建立题库.js`代码文件（不再支持本地json），注释个人认为比较清楚。有问题提issue。
28 | 5. 服务器
29 | 服务器端仅提供简单flask单文件版本，不再使用复杂版本。
30 | 6. 隐私模式
31 | 隐私安全模式下无法截屏，只能通过随机选项点击后观察答案是否正确的步骤来获取正确答案。
32 |
33 | ##### 二、免责声明
34 | 本题库及相关代码仅用于个人学习，下载后请勿用于商业或违法活动。使用本题库时请**添加题库的来源说明**，增加本项目的曝光度。
35 | 疑似使用：App Store上的“强国题库 - 强国学习好帮手”
36 | ##### 三、题库网站
37 | 我发现了一个网站：[学习强国挑战答题](http://www.syiban.com/)。 若本题库没更新（精力有限），大家可以去这个网站搜搜，看起来更新很快，题目还蛮多。
38 |
39 | ##### 四、更新日志
40 | ###### 20231206
41 | 1. 修改服务器程序代码，支持错误答案上传，支持遇到新题或错题自动保存，服务器端存储方式退回到json格式
42 | 2. 移除：~~js脚本将json题库保存到本地~~
43 | 3. 移除：~~服务端通过docker部署~~
44 | 4. 修复：js脚本不能自动等待10秒连续答题的bug
45 | 5. 修复：js脚本因控件内容更改而无法保存的bug
46 | 6. 修改：每次答题等待结果的时间100ms->200ms，注意等待时间太少会重复上传不同选项的错题
47 | ###### 20230709
48 | 1. 添加：合并推送请求，增加一个基于Tkinter的，带有图形用户界面的学习强国挑战答题题库查询工具(pooneyy)
49 | ###### 20230106
50 | 1. 修改服务器程序代码，服务器端存储方式改为SQL数据库
51 | 2. 修改仓库代码结构，使架构更合理
52 | 3. 修改Dockerhub镜像文件，使其更易部署
53 | ###### 20221013
54 | 1. 添加js脚本，可从Autox.js(Autox.js为Auto.js的分支, 应当支持Auto.js)创建db数据库(PutinYpa)。
55 | ###### 20220920
56 | 1. 缩短等待时间（2s->0.1s），来加快答题速度。可自行修改
57 | ###### 20220918
58 | 1. 修复一处逻辑Bug(Tq7)并对截图识别区域进行限制(wangwang-code)
59 | ###### 20220917
60 | 1. 适配隐私安全版本，无法截屏时采用试错法
61 | 2. 自动点击访问异常（借鉴）
62 | 3. 减少答题错误再次答题的等待时间。
63 | 等待时间从固定时间间隔变为距该轮答题开始10秒。当连续答对较多时，发起的新一轮挑战答题不会再等待。
64 | 1. 避免错误选项提交，当截图没有找到正确答案时退出脚本
65 | 2. 问题先去除空格，因空格的增减出现的题目现在唯一
66 | 3. 答案错误自动修复，从题库中获取的答案也检查正确性
67 | ###### 更早
68 | ...
69 |
--------------------------------------------------------------------------------
/scripts/db2json.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 | import json
3 |
4 | tk_database_path = "xxqg_tiku.db"
5 | tk_json_path = "题库_排序版.json"
6 |
7 | connect = sqlite3.connect(tk_database_path) # 连接数据库，没有就创建
8 | cursor = connect.cursor() # 获取游标
9 |
10 | # 查询表单全部数据并输出
11 | tk_json = {}
12 | for question, answer in cursor.execute('select * from TZDT').fetchall():
13 | tk_json[question] = answer
14 |
15 | # 写入json文件
16 | with open(tk_json_path, "w", encoding='utf-8') as f:
17 | f.write(json.dumps(tk_json, ensure_ascii=False))
--------------------------------------------------------------------------------
/scripts/json2anki.py:
--------------------------------------------------------------------------------
1 | """
2 | 将json文件转换为方便浏览的ANKI格式题库文件, 分隔符为tab, options之间用"||"分割, 答案用数字表示位置(从1开始)
3 | """
4 | import json
5 | import hashlib
6 |
7 | src_path = "题库_排序版.json"
8 | dst_path = "题库_排序版_ANKI.txt"
9 |
10 | with open(src_path, "r", encoding="utf8") as f:
11 | data = json.loads(f.read())
12 |
13 | with open(dst_path, "w", encoding="utf-8") as f:
14 | f.write("#guid column:1\n")
15 | for idx, i in enumerate(data, 1):
16 | # 使用md5的前8位生成guid, 保证编号的唯一性
17 | guid = "xxqgtzdt" + hashlib.md5(i.encode('utf-8')).hexdigest()[:8]
18 | print(guid, i)
19 | question = (i.split("|")[0]).replace(" ", "____")
20 | options = "||".join(i.split("|")[1:])
21 | answer = data[i]
22 | answer_index = i.split("|")[1:].index(answer) + 1
23 | f.write(f"{guid}\t{idx}\t{question}\t{options}\t{answer_index}\n")
24 |
--------------------------------------------------------------------------------
/scripts/json2db.js:
--------------------------------------------------------------------------------
1 | importClass('android.database.sqlite.SQLiteDatabase');
2 | auto.waitFor();
3 | console.show();
4 | var db_name="tiku.db"
5 | var tiku_url='https://ghproxy.com/https://raw.githubusercontent.com/mondayfirst/XXQG_TiKu/main/%E9%A2%98%E5%BA%93_%E6%8E%92%E5%BA%8F%E7%89%88.json';
6 |
7 | var db = SQLiteDatabase.openOrCreateDatabase(files.cwd() + "/" + db_name,null);
8 | if(!db) {
9 | console.log("无法打开数据库:" + db_name);
10 | exit;
11 | }
12 | db.execSQL(
13 | "CREATE TABLE IF NOT EXISTS " +
14 | "tiku" +
15 | "(" +
16 | "`question` varchar, " +
17 | "`answer` varchar" +
18 | ")"
19 | );
20 |
21 | var cu = db.rawQuery("select count(*) from tiku", null);
22 | var db_count=0;
23 | if (cu.moveToFirst()) {
24 | db_count = cu.getString(0);
25 | cu.close();
26 | }
27 |
28 | console.info("当前数据库记录数:" + db_count);
29 |
30 |
31 | function get_tiku_by_http(link) {
32 | // 通过gitee的原始数据保存题库
33 |
34 | let req = http.get(link);
35 |
36 | // 更新题库时若获取不到，则文件名+1
37 | if (req.statusCode != 200) {
38 | log(req.statusCode);
39 | throw "网络原因未获取到题库，请尝试切换流量或者更换114DNS，退出脚本";
40 | return false;
41 | }
42 | return JSON.stringify(req.body.json());
43 | }
44 |
45 | var json_count=0;
46 | var json_tiku = get_tiku_by_http(tiku_url);
47 | //json_tiku = files.read(files.cwd()+"/tiku.json");
48 | if(json_tiku) {
49 |
50 |
51 | JSON.parse(json_tiku,function(key, value) {
52 | if(key!="")
53 | json_count++;
54 | });
55 | console.info("JSON题库记录数:" + json_count);
56 |
57 |
58 | if(db_count != json_count && json_count > 0) {
59 | if(db_count !=0 ) {
60 | db.execSQL("DROP TABLE tiku");
61 | db.execSQL("vacuum");
62 | db.execSQL(
63 | "CREATE TABLE IF NOT EXISTS " +
64 | "tiku" +
65 | "(" +
66 | "`question` varchar, " +
67 | "`answer` varchar" +
68 | ")"
69 | );
70 | //db.execSQL("delete from tiku");
71 | //db.execSQL("vacuum");
72 | }
73 | db_count=0;
74 | db.beginTransaction();
75 | JSON.parse(json_tiku,function(key, value) {
76 | if(key!=""){
77 | var question=key;
78 | var answer=value;
79 | var sqlStr = "INSERT INTO " +
80 | "tiku(question, answer) " +
81 | "values('" +
82 | question + "', '" +
83 | answer + "') " ;
84 | db.execSQL(sqlStr);
85 | db_count ++;
86 |
87 | }
88 | })
89 | db.setTransactionSuccessful();
90 | db.endTransaction();
91 | console.info("题库已更新，重新生成题库记录数:"+ db_count);
92 | db.close();
93 |
94 |
95 | }
96 | else if(db_count == json_count){
97 | console.info("记录数无变化，题库未更新");
98 | }
99 | else {
100 | console.info("未获取到有效题库记录");
101 | }
102 |
103 | }
104 | console.info("10s后自动关闭提示窗口");
105 | sleep(10000);
106 | console.hide();
107 |
--------------------------------------------------------------------------------
/scripts/json2db.py:
--------------------------------------------------------------------------------
1 | # 转换为数据库的简单示例
2 |
3 | import sqlite3
4 | import json
5 |
6 | tk_database_path = "xxqg_tiku.db"
7 | tk_json_path = "题库_排序版.json"
8 |
9 | connect = sqlite3.connect(tk_database_path) # 连接数据库，没有就创建
10 | cursor = connect.cursor() # 获取游标
11 |
12 | # 读取json文件
13 | with open(tk_json_path, "r", encoding="utf8") as f:
14 | tk_json = json.loads(f.read())
15 |
16 | # 创建表单并添加数据
17 | cursor.execute(f'''CREATE TABLE IF NOT EXISTS TZDT
18 | (question TEXT PRIMARY KEY NOT NULL,
19 | answer TEXT NOT NULL);''')
20 | for question, answer in tk_json.items():
21 | cursor.execute(f'''insert or ignore into TZDT (question,answer) values (?,?)''', (question,answer))
22 |
23 | # 查询表单全部数据并输出
24 | for question, answer in cursor.execute('select * from TZDT').fetchall():
25 | print(question, answer)
26 |
27 | cursor.close() # 关闭游标
28 | connect.commit() # 提交更改
29 | connect.close() # 关闭数据库连接
30 |
--------------------------------------------------------------------------------
/scripts/json2md.py:
--------------------------------------------------------------------------------
1 | """
2 | 将json文件转换为方便浏览的markdown格式题库文件
3 | """
4 | import ast
5 | import json
6 | import os
7 |
8 | # 输入参数设置
9 | for src_file in [file for file in os.listdir() if file.endswith(".json")]:
10 | obj_file = os.path.splitext(src_file)[0] + ".md"
11 |
12 | # 读取json文件
13 | with open(src_file, 'r', encoding='utf-8') as f:
14 | txt = f.read()
15 | dict = ast.literal_eval(txt)
16 |
17 | # 添加markdown字符
18 | count = 0
19 | res = []
20 | for i in dict:
21 | count += 1
22 | # 分割问题与答案
23 | a = i.split("|")
24 | # 添加序号，并将空白符转为下划线
25 | a[0] = str(count) + ". " + a[0].replace(" ", "____")
26 | # 可选答案前添加 * 转为无序列表
27 | for j in range(1, len(a)):
28 | a[j] = "* " + a[j]
29 | # 正确答案处理
30 | a.append("> 正确答案为：`" + dict[i] + "`")
31 | # 所有答案前添加空格以缩进
32 | for j in range(1, len(a)):
33 | a[j] = " " + a[j]
34 | # 添加换行符
35 | res.append(" \n".join(a))
36 |
37 | # 保存到.md文件中
38 | with open(obj_file, 'w', encoding='utf-8') as f:
39 | f.write("\n\n".join(res))
40 | with open(src_file, "w", encoding='utf-8') as f:
41 | f.write(json.dumps(dict, ensure_ascii=False))
--------------------------------------------------------------------------------
/scripts/题库查询器.py:
--------------------------------------------------------------------------------
1 | import json
2 | import requests
3 | import tkinter as tk
4 | from tkinter import messagebox, font
5 |
6 | # 如果题库加载过慢，请更换其他CDN
7 | TIKU_JSON_URL = "https://fastly.jsdelivr.net/gh/mondayfirst/XXQG_TiKu@main/%E9%A2%98%E5%BA%93_%E6%8E%92%E5%BA%8F%E7%89%88.json"
8 |
9 | def load_questions():
10 | url = TIKU_JSON_URL
11 | response = requests.get(url)
12 | questions = json.loads(response.text)
13 | return questions
14 |
15 | def search_questions(event=None):
16 | keywords = entry.get().strip().split()
17 | result_text.delete("1.0", tk.END)
18 | found_questions = []
19 |
20 | for question, answer in questions.items():
21 | question_lower = question.lower()
22 | if all(keyword.lower() in question_lower for keyword in keywords):
23 | found_questions.append((question, answer))
24 |
25 | if found_questions:
26 | for i, (question, answer) in enumerate(found_questions):
27 | result_text.insert(tk.END, f"Q{i + 1}: \n")
28 | options = question.split("|")
29 | for option in options:
30 | result_text.insert(tk.END, f"{option}\n")
31 | result_text.insert(tk.END, f"Answer: {answer}\n")
32 | result_text.insert(tk.END, "\n")
33 | else:
34 | messagebox.showinfo("结果", "未找到匹配的问题")
35 |
36 | def clear_entry(event):
37 | entry.delete(0, tk.END)
38 |
39 | root = tk.Tk()
40 |
41 | root.title("学习强国挑战答题题库")
42 |
43 | print("正在加载题库，请稍后")
44 | questions = load_questions()
45 |
46 | title_font = font.Font(family="SimSun", size=16, weight="bold")
47 |
48 | label = tk.Label(root, text="请输入关键词进行查询（关键词之间使用空格分开）", font=title_font)
49 | label.grid(row=0, column=0, columnspan=2)
50 |
51 | entry_font = font.Font(family="SimSun", size=16)
52 | entry = tk.Entry(root, width=30, font=entry_font)
53 | entry.grid(row=1, column=0, padx=10, pady=5, sticky="e")
54 | entry.bind("", clear_entry) # 点击输入框清空内容
55 | entry.bind("", search_questions) # 回车键触发查询
56 | entry.focus_set() # 焦点位于输入框
57 |
58 | button_font = font.Font(family="SimSun", size=16, weight="bold")
59 | search_button = tk.Button(root, text="查询", command=search_questions, font=button_font)
60 | search_button.grid(row=1, column=1, padx=10, pady=5, sticky="w")
61 |
62 | result_text_font = font.Font(family="SimSun", size=16)
63 | result_text = tk.Text(root, width=100, font=result_text_font, wrap=tk.WORD)
64 | result_text.grid(row=2, column=0, columnspan=2, padx=10, pady=5, sticky="nsew")
65 |
66 | result_scrollbar = tk.Scrollbar(root)
67 | result_scrollbar.grid(row=2, column=2, padx=5, pady=5, sticky="ns")
68 | result_scrollbar.configure(command=result_text.yview)
69 | result_text.configure(yscrollcommand=result_scrollbar.set)
70 |
71 | root.grid_rowconfigure(2, weight=1)
72 | root.grid_columnconfigure((0, 1), weight=1)
73 |
74 | root.mainloop()
--------------------------------------------------------------------------------
/xxqg_tiku_client/examples/python-query.py:
--------------------------------------------------------------------------------
1 | import requests
2 |
3 | data = {"q": "扑救火灾最有利的阶段是 。|火灾初起阶段|火灾发展阶段|火灾猛烈燃烧阶段"}
4 |
5 | # 正确访问
6 | response = requests.post("http://127.0.0.1:5000/query", data)
7 | print(response.status_code, response.text)
8 |
9 | # # 错误访问
10 | # response = requests.post("https://mondayfirst.top/tiku/query", {"q": "扑救火灾最有利的阶段是 。"})
11 | # print(response.status_code, response.text)
12 |
13 | # response = requests.post("https://mondayfirst.top/tiku/query", {})
14 | # print(response.status_code, response.text)
15 |
16 | # response = requests.get("https://mondayfirst.top/tiku/query", data)
17 | # print(response.status_code, response.text)
18 |
--------------------------------------------------------------------------------
/xxqg_tiku_client/建立题库.js:
--------------------------------------------------------------------------------
1 | /*
2 | @author: mondayfirst
3 | @github: https://github.com/mondayfirst/XXQG_TiKu
4 | @description: 本脚本可在AutoX.js上执行。
5 | */
6 | // 关闭所有线程
7 | threads.shutDownAll()
8 | // =====================参数设置====================
9 | var 挑战答题索引 = "000001000000000000002010" // 挑战答题部分ui相对根节点的嵌套位置索引
10 | var host = "http://192.168.3.2:5000" // 网络题库URL路径，请自行修改为服务器IP地址和端口
11 | var imagetext_true = "SGLxINmefgEhdVfQxDvcygAAAABJRU5ErkJggg==" // 答题正确时Image控件文本
12 | var imagetext_false = "LqFTlORbAU3kyEmgqiqE0FUU7iGyTs0AbJ0AEAbUJkGsQXyjcAAAAASUVORK5CYII=+8sGvTRDzFnDeO+BcOEpP0Rte6f+HwcGxeN2dglWfgH8P0C7HkCMJOAAAAAElFTkSuQmCC" // 答题错误时Image控件文本
13 | var image_color_when_true = "#3dbf75" // 答题正确时Image控件颜色
14 | var privateModeStartVersion = "5.33.999"
15 | var cycle_wait_time = 200 // 单位是毫秒
16 | var start_wait_time = 10100 // 每轮答题最低时长，单位是毫秒
17 | http.__okhttp__.setTimeout(1000);
18 |
19 | // ================================================
20 | // =====================主程序运行====================
21 | // ================================================
22 | // 判断是否是隐私模式版本，新版本为隐私模式不可截屏，2.33版本可截屏
23 | var isPrivateMode = version1GreaterVersion2(getVersion("cn.xuexi.android"), privateModeStartVersion)
24 | // 其它全局变量定义
25 | var globalAnswerRunning = false
26 | var globalLastdate = new Date().getTime();
27 |
28 |
29 | if (!isPrivateMode) {
30 | requestScreenCapture() // 请求截屏
31 | }
32 |
33 | var thread_handling_access_exceptions = handling_access_exceptions();
34 | var thread_handling_submit_exceptions = handling_submit_exceptions();
35 |
36 | // 循环运行
37 | while (true) {
38 | // 获取根节点
39 | if (!className("android.widget.Image").depth(26).textMatches(/\S+/).exists()) {
40 | sleep(100)
41 | var obj_node = get_ui_obj_from_posstr(挑战答题索引)
42 | if (obj_node == null) {
43 | sleep(random_time(1000))
44 | continue
45 | }
46 | // 记录开始时间
47 | if (!globalAnswerRunning) {
48 | globalLastdate = new Date().getTime();
49 | globalAnswerRunning = true
50 | }
51 | // 获取目标控件和文本
52 | var q_ui = get_ui_question_from_obj_node(obj_node);
53 | var a_uis = get_ui_answsers_from_obj_node(obj_node);
54 | var question = q_ui.text();
55 | var answers = new Array()
56 | for (var i = 0; i < a_uis.length; i++) {
57 | answers.push(a_uis[i].text())
58 | }
59 | console.log(join_question_with_answer(question, answers)) // 显示拼接后的键
60 | // 滑动窗口
61 | swipe_to_view_the_last_answer(a_uis); // 滑动窗口来显示最后一个答案
62 | // 点击答案
63 | var true_answer_index = get_answer_from_server(question, answers)
64 | if (true_answer_index >= 0) {
65 | click_answer_radio_button(a_uis, question, answers, true_answer_index, true, obj_node);
66 | }
67 | else {
68 | // 如果没有查找到答案，就随机一个选项来点击，如果是非隐私模式，截屏查找正确答案，否则选项正确才更新答案
69 | click_answer_radio_button(a_uis, question, answers, random(0, a_uis.length - 1), true, obj_node);
70 | }
71 | }
72 | sleep(cycle_wait_time)
73 | // 处理答题失败和50题选项
74 | if (jump_tips_50TrueQuestions() || jump_tips_ErrorAnswer()) {
75 | sleep(1000)
76 | }
77 | }
78 | // ================================================
79 | // =======================函数======================
80 | // =====================操作函数====================
81 | function jump_tips_ErrorAnswer() {
82 | if (text("结束本局").exists() && (text("立即复活").exists())) {
83 | var nowdate = new Date().getTime();
84 | console.log((nowdate - globalLastdate))
85 | console.log(start_wait_time)
86 | if ((nowdate - globalLastdate) < start_wait_time) {
87 | toastLog("等待" + (start_wait_time + (globalLastdate - nowdate)) + "毫秒")
88 | sleep(random_time(start_wait_time + (globalLastdate - nowdate)))
89 | }
90 | text("结束本局").findOne().click()
91 | text("再来一局").findOne().click()
92 | globalAnswerRunning = false
93 | return true;
94 | }
95 | return false;
96 | }
97 | function jump_tips_50TrueQuestions() {
98 | if (text("结束本局").exists() && text("继续").exists() && textContains("您已答对了50题").exists() && (textContains("稍作休息").exists())) {
99 | text("继续").findOne(3000).click()
100 | return true;
101 | }
102 | return false;
103 | }
104 | function swipe_to_view_the_last_answer(answer_uis) {
105 | var length = answer_uis.length
106 | var flag = false
107 | if (length <= 1) {
108 | return null
109 | }
110 | for (var i = 0; i < 10; i++) {
111 | flag = answer_uis[length - 1].bounds().bottom == answer_uis[length - 1].bounds().top
112 | if (flag) {
113 | // 滑动参数，当题目与答案较长时，需要滑动屏幕让最后一个答案显露出来。
114 | swipe(answer_uis[0].bounds().left, parseInt(device.height / 2), answer_uis[0].bounds().left, parseInt(device.height * 4 / 5), 500)
115 | sleep(random_time(0))
116 | }
117 | else {
118 | break
119 | }
120 | }
121 | }
122 | function click_answer_radio_button(answer_uis, question, answers, idx, isMustPost, obj_node) {
123 | answer_uis[idx].parent().click();
124 | var ansb = obj_node.child(1).bounds()
125 | var answers_region = [ansb.left, ansb.top, ansb.width(), ansb.height()]
126 | sleep(200)
127 | if (text(imagetext_true).exists()) {
128 | // 点击正确，视参数来更新答案
129 | var select_ans = answers[idx]
130 | if (isMustPost) {
131 | post_answer_to_server(question, answers, select_ans, true)
132 | }
133 | }
134 | else {
135 | // 点击错误
136 | if (!isPrivateMode) {
137 | // 如果是非隐私安全模式，立刻截图更新本次答案，答案选择正确
138 | sleep(500)
139 | var select_ans = find_true_answer_from_img(answer_uis, answers_region)
140 | post_answer_to_server(question, answers, select_ans, true)
141 | } else {
142 | // 如果是隐私安全模式，上传本次答案，答案选择错误
143 | post_answer_to_server(question, answers, answers[idx], false)
144 | }
145 | }
146 | }
147 |
148 | function handling_submit_exceptions() {
149 | var thread_handling_submit_exceptions = threads.start(function () {
150 | while (true) {
151 | text("提交失败").waitFor();
152 | textContains("重试").className("android.widget.Button").findOne(3000).click()
153 | sleep(random_time(2000));
154 | }
155 | });
156 | return thread_handling_submit_exceptions;
157 | }
158 | function handling_access_exceptions() {
159 | /**
160 | * 处理访问异常
161 | * 该函数来源：https://github.com/dundunnp/auto_xuexiqiangguo
162 | */
163 | // 在子线程执行的定时器，如果不用子线程，则无法获取弹出页面的控件
164 | var thread_handling_access_exceptions = threads.start(function () {
165 | while (true) {
166 | textContains("访问异常").waitFor();
167 | // 滑动按钮">>"位置
168 | idContains("nc_1_n1t").waitFor();
169 | var bound = idContains("nc_1_n1t").findOne().bounds();
170 | // 滑动边框位置
171 | text("向右滑动验证").waitFor();
172 | var slider_bound = text("向右滑动验证").findOne().bounds();
173 | // 通过更复杂的手势验证（先右后左再右）
174 | var x_start = bound.centerX();
175 | var dx = x_start - slider_bound.left;
176 | var x_end = slider_bound.right - dx;
177 | var x_mid = (x_end - x_start) * random(5, 8) / 10 + x_start;
178 | var back_x = (x_end - x_start) * random(2, 3) / 10;
179 | var y_start = random(bound.top, bound.bottom);
180 | var y_end = random(bound.top, bound.bottom);
181 | x_start = random(x_start - 7, x_start);
182 | x_end = random(x_end, x_end + 10);
183 | gesture(random_time(0), [x_start, y_start], [x_mid, y_end], [x_mid - back_x, y_start], [x_end, y_end]);
184 | sleep(random_time(0));
185 | if (textContains("刷新").exists()) {
186 | click("刷新");
187 | continue;
188 | }
189 | if (textContains("网络开小差").exists()) {
190 | click("确定");
191 | continue;
192 | }
193 | // 执行脚本只需通过一次验证即可，防止占用资源
194 | // break;
195 | }
196 | });
197 | return thread_handling_access_exceptions;
198 | }
199 | // =====================通用函数====================
200 | function random_time(time) {
201 | return time + random(100, 1000);
202 | }
203 | function get_root_node(root_node_classname) {
204 | // 获取框架的根节点，假设根节点类名为FrameLayout
205 | obj = className(root_node_classname).findOne()
206 | while (true) {
207 | if (obj.parent() == null) {
208 | break
209 | } else {
210 | obj = obj.parent()
211 | }
212 | }
213 | return obj
214 | }
215 | function is_child_ui_existed(root_node, seq_str) {
216 | // 根据相对位置嵌套索引，判断目标子节点是否存在，同时obj变为目标子节点
217 | if (!root_node)
218 | return false
219 | obj = root_node
220 | try {
221 | for (var i = 0; i < seq_str.length; i++) {
222 | childUIs = obj.children()
223 | index = parseInt(seq_str[i])
224 | if (childUIs.length > index)
225 | obj = childUIs[index]
226 | else
227 | return false
228 | }
229 | }
230 | catch (err) {
231 | console.log(err.description)
232 | return false
233 | }
234 | return true
235 | }
236 |
237 | function getVersion(package_name) {
238 | // 该函数来源：https://blog.csdn.net/aa490791706/article/details/122863666
239 | let pkgs = context.getPackageManager().getInstalledPackages(0).toArray();
240 | for (let i in pkgs) {
241 | if (pkgs[i].packageName.toString() === package_name) {
242 | return pkgs[i].versionName;
243 | }
244 | }
245 | }
246 | function version1GreaterVersion2(version1, version2, equal) {
247 | // 该函数来源：https://blog.csdn.net/aa490791706/article/details/122863666
248 | if (equal && version1 === version2) {
249 | return true;
250 | }
251 | let versionArr1 = version1.split('.');
252 | let versionArr2 = version2.split('.');
253 | let result = false;
254 | for (var i = 0; i < versionArr1.length; i++) {
255 | if (versionArr1[i] > versionArr2[i]) {
256 | result = true;
257 | break;
258 | }
259 | }
260 | return result;
261 | }
262 |
263 | // =====================脚本函数====================
264 | function get_ui_obj_from_posstr(seq_str) {
265 | // 根据相对位置嵌套索引，从根节点向下寻找目标子节点
266 | obj = get_root_node("FrameLayout")
267 | if (!is_child_ui_existed(obj, seq_str))
268 | return null
269 | return obj
270 | }
271 |
272 | function get_ui_question_from_obj_node(obj_node) {
273 | // 从目标节点根据相对位置获取题目文本所在的节点
274 | return obj_node.child(0)
275 | }
276 |
277 | function get_ui_answsers_from_obj_node(obj_node) {
278 | // 从目标节点根据相对位置获取答案文本所在的节点
279 | a_parent_uis = obj_node.child(1).children()
280 | a_uis = new Array()
281 | for (var i = 0; i < a_parent_uis.length; i++) {
282 | a_uis.push(obj_node.child(1).child(i).child(0).child(1))
283 | }
284 | return a_uis
285 | }
286 |
287 | function find_true_answer_from_img(Nodes, region) {
288 | // 截图并从图片中根据答案的颜色寻找正确的答案选项，输出答案的文本
289 | var img = images.captureScreen();
290 | var point = images.findColor(img, image_color_when_true, {
291 | // 目的是防止找到倒计时的绿色进度条
292 | region: region,
293 | threshold: 4
294 | });
295 | if (point == null) {
296 | toastLog("Error:未找到正确答案！截屏失效(手动更改隐私模式参数)或颜色错误")
297 | throw "Error:未找到正确答案！截屏失效(手动更改隐私模式参数)或颜色错误"
298 | }
299 | var true_ans = null
300 | var x = point.x
301 | var y = point.y
302 | for (var i = 0; i < Nodes.length; i++) {
303 | var a = Nodes[i].bounds()
304 | if (y >= a.top && y <= a.bottom) {
305 | true_ans = Nodes[i].text();
306 | break;
307 | }
308 | }
309 | if (true_ans == null) {
310 | toastLog("Error:未找到答案！")
311 | throw "Error:未找到答案！"
312 | }
313 | return true_ans
314 | }
315 | function join_question_with_answer(question, answers) {
316 | question = question.replace(/ /g, "")
317 | var sort_answers = ([].concat(answers)).sort()
318 | var key = ([question].concat(sort_answers)).join("|")
319 | return key
320 | }
321 | // =====================题库函数====================
322 | /////////////////通过服务器获取答案
323 | function post_answer_to_server(question, answers, select_ans, isTrue) {
324 | // 发送请求到服务器更新答案
325 | var key = join_question_with_answer(question, answers)
326 | for (var i = 0; i < 3; i++) {
327 | try {
328 | if (isTrue) {
329 | res = http.post(host + "/submit/true", {
330 | "question": key,
331 | "answer": select_ans
332 | })
333 | } else {
334 | res = http.post(host + "/submit/false", {
335 | "question": key,
336 | "answer": select_ans
337 | })
338 | }
339 | if (res.statusCode == 200) {
340 | break
341 | }
342 | } catch (err) {
343 | console.log("服务器连接失败或超时，请检查网络主机地址或等待响应")
344 | sleep(1000)
345 | }
346 | }
347 | log(question + res.statusCode)
348 | }
349 |
350 | function get_answer_from_server(question, answers) {
351 | // 从服务器获取正确答案，本地检索正确答案的索引并输出
352 | var true_answer_index = -1
353 | var key = join_question_with_answer(question, answers)
354 | for (var i = 0; i < 3; i++) {
355 | try {
356 | res = http.post(host + "/query", { "question": key })
357 | if (res.statusCode == 200) {
358 | true_ans = res.body.string()
359 | for (var i = 0; i < answers.length; i++) {
360 | if (true_ans == answers[i]) {
361 | true_answer_index = i
362 | break
363 | }
364 | }
365 | }
366 | break
367 | } catch (err) {
368 | console.log("服务器连接失败或超时，请检查网络主机地址或等待响应")
369 | sleep(1000)
370 | }
371 | }
372 | return true_answer_index
373 | }
--------------------------------------------------------------------------------
/xxqg_tiku_server/README.md:
--------------------------------------------------------------------------------
1 | # 学习强国_挑战答题 服务端
2 |
3 |
4 | ### 1. 安装所需Python包
5 | ```
6 | pip install flask
7 | ```
8 |
9 | ### 2. 启动server程序
10 | 原始代码监听本机的5000端口，可自行前往脚本处设置
11 | ```
12 | python xxqg_tiku_server/simple_server.py
13 | ```
14 |
15 | ### 3. 测试是否运行(Python代码)
16 |
17 | 注意自己的端口设置，自行修改！
18 | ```
19 | import requests
20 | data = {"question": "扑救火灾最有利的阶段是 。|火灾初起阶段|火灾发展阶段|火灾猛烈燃烧阶段"}
21 | # 注意自己的端口设置，自行修改IP地址和端口
22 | url = "http://127.0.0.1:5000/query"
23 | response = requests.post(url, data)
24 | print(response.status_code, response.text)
25 | ```
--------------------------------------------------------------------------------
/xxqg_tiku_server/simple_server.py:
--------------------------------------------------------------------------------
1 | from flask import request, Flask
2 | import json
3 | import os
4 |
5 | app = Flask(__name__)
6 |
7 | # 参数设置
8 | tk_path_true = '题库_排序版.json' # 题库路径
9 | tk_path_false = '题库_错题缓存.json' # 题库路径
10 |
11 | # 内存题库
12 | tk_true = {}
13 | tk_false = {}
14 |
15 | if os.path.exists(tk_path_true):
16 | with open(tk_path_true, 'r', encoding="utf8") as f:
17 | tk_true = json.loads(f.read())
18 | if os.path.exists(tk_path_false):
19 | with open(tk_path_false, 'r', encoding="utf8") as f:
20 | tk_false = json.loads(f.read())
21 |
22 |
23 |
24 | class Qustion:
25 | @staticmethod
26 | def sort(recept_question):
27 | str_list = recept_question.split("|")
28 | q = str_list[0]
29 | a = sorted(str_list[1:])
30 | query_question = "|".join([q] + a)
31 | return query_question
32 |
33 |
34 | @app.route('/query', methods=['POST'])
35 | def query_question():
36 | recept_question = request.form['question']
37 | query_question = Qustion.sort(recept_question)
38 | print("查询:", query_question, end="---->")
39 | answers = query_question.split("|")[1:]
40 | if query_question in tk_true:
41 | print("正确答案：", tk_true[query_question])
42 | return tk_true[query_question]
43 | else:
44 | false_answers = tk_false.get(query_question, [])
45 | flag_exit_break = False
46 | for answer in answers:
47 | if answer in false_answers:
48 | continue
49 | else:
50 | flag_exit_break = True
51 | break
52 | print("挑选答案：", answer)
53 | if flag_exit_break:
54 | return answer
55 | else:
56 | print("删除问题：", query_question)
57 | tk_false.pop(query_question)
58 | return answer
59 |
60 |
61 | @app.route('/submit/true', methods=['POST'])
62 | def submit_question_true():
63 | recept_question = request.form['question']
64 | recept_answer = request.form['answer']
65 | query_question = Qustion.sort(recept_question)
66 | print("上传:", query_question, end="---->")
67 | if (query_question not in tk_true) or (tk_true[query_question] != recept_answer):
68 | tk_true[query_question] = recept_answer
69 | print("上传正确答案：", recept_answer)
70 | save()
71 | else:
72 | tk_true[query_question] = recept_answer
73 | print("上传正确答案：", recept_answer)
74 | if query_question in tk_false:
75 | tk_false.pop(query_question)
76 | return recept_answer
77 |
78 |
79 | @app.route('/submit/false', methods=['POST'])
80 | def submit_question_false():
81 | recept_question = request.form['question']
82 | recept_answer = request.form['answer']
83 | query_question = Qustion.sort(recept_question)
84 | print("上传:", query_question, end="---->")
85 | false_answers = tk_false.get(query_question, [])
86 | if recept_answer not in false_answers:
87 | false_answers.append(recept_answer)
88 | tk_false[query_question] = false_answers
89 | print("上传错误答案：", recept_answer)
90 | save()
91 | else:
92 | print("上传错误答案：", recept_answer)
93 | return recept_answer
94 |
95 |
96 | @app.route('/save', methods=['GET'])
97 | def save():
98 | with open(tk_path_true, 'w', encoding="utf8") as f:
99 | f.write(json.dumps(tk_true, ensure_ascii=False))
100 | with open(tk_path_false, 'w', encoding="utf8") as f:
101 | f.write(json.dumps(tk_false, ensure_ascii=False))
102 | print("****************保存题库成功****************")
103 | return 'ok'
104 |
105 |
106 | if __name__ == '__main__':
107 | app.run(host='0.0.0.0', port=5000, debug=False)
108 |
--------------------------------------------------------------------------------