├── .github
└── workflows
│ └── manual.yml
├── 20230623175053.png
├── 87CE36BC9B5823EF634C12F86B0DA2F0.jpg
├── README.md
├── backup
├── jd20221111.js
├── jd618.js
├── jd_choujiang.js
├── jd_nm.js
├── tb2211.js
├── tb618.js
├── tb_hc.js
└── zns_zs.js
├── jd618.js
├── qrcode_1666778378599.jpg
├── qrcode_for_gh_d76dde74fd07_344.jpg
├── tb618.js
├── tb_hc.js
├── tb_nl.js
├── version
└── wechart.png
/.github/workflows/manual.yml:
--------------------------------------------------------------------------------
1 | # This is a basic workflow that is manually triggered
2 |
3 | name: Manual workflow
4 |
5 | # Controls when the action will run. Workflow runs when manually triggered using the UI
6 | # or API.
7 | on:
8 | workflow_dispatch:
9 | # Inputs the workflow accepts.
10 | inputs:
11 | name:
12 | # Friendly description to be shown in the UI instead of 'name'
13 | description: 'Person to greet'
14 | # Default value if no value is explicitly provided
15 | default: 'World'
16 | # Input has to be provided for the workflow to run
17 | required: true
18 |
19 | # A workflow run is made up of one or more jobs that can run sequentially or in parallel
20 | jobs:
21 | # This workflow contains a single job called "greet"
22 | greet:
23 | # The type of runner that the job will run on
24 | runs-on: ubuntu-latest
25 |
26 | # Steps represent a sequence of tasks that will be executed as part of the job
27 | steps:
28 | # Runs a single command using the runners shell
29 | - name: Send greeting
30 | run: echo "Hello ${{ github.event.inputs.name }}"
31 |
--------------------------------------------------------------------------------
/20230623175053.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ljt0515/618/690c545eb359796e15910e51275d0a765f1d58d9/20230623175053.png
--------------------------------------------------------------------------------
/87CE36BC9B5823EF634C12F86B0DA2F0.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ljt0515/618/690c545eb359796e15910e51275d0a765f1d58d9/87CE36BC9B5823EF634C12F86B0DA2F0.jpg
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ## 脚本说明
2 | 已支持京东2023全民拆快递活动
3 |
4 |
5 | autojs脚本请使用jd618.js
6 |
7 | app下载路径 https://cxzdy.lanzoub.com/b0125rrzi 密码 jd11
8 |
9 | **京东羊毛党**
10 |
11 | 
12 |
13 | 京东618,你还在找组织吗?来这里,加群获取最新消息,互助,脚本,每天固定组队
14 |
15 | qq群
16 |
17 |
18 |
19 |
--------------------------------------------------------------------------------
/backup/jd20221111.js:
--------------------------------------------------------------------------------
1 | if (!auto.service) {
2 | toast('无障碍服务未启动!退出!')
3 | exit()
4 | }
5 | console.show()
6 |
7 | function getSetting() {
8 | let indices = []
9 | autoOpen && indices.push(0)
10 | autoMute && indices.push(1)
11 | autoJoin && indices.push(2)
12 | indices.push(3)
13 |
14 | let settings = dialogs.multiChoice('任务设置', ['自动打开京东进入活动。多开或任务列表无法自动打开时取消勾选', '自动调整媒体音量为0。以免直播任务发出声音,首次选择需要修改系统设置权限', '自动完成入会任务。京东将授权手机号给商家,日后可能会收到推广短信', '此选项用于保证选择的处理,勿动!'], indices)
15 |
16 | if (settings.length == 0) {
17 | toast('取消选择,任务停止')
18 | exit()
19 | }
20 |
21 | if (settings.indexOf(0) != -1) {
22 | storage.put('autoOpen', true)
23 | autoOpen = true
24 | } else {
25 | storage.put('autoOpen', false)
26 | autoOpen = false
27 | }
28 | if (settings.indexOf(1) != -1) {
29 | storage.put('autoMute', true)
30 | autoMute = true
31 | } else {
32 | storage.put('autoMute', false)
33 | autoMute = false
34 | }
35 | if (settings.indexOf(2) != -1) {
36 | storage.put('autoJoin', true)
37 | autoJoin = true
38 | } else {
39 | storage.put('autoJoin', false)
40 | autoJoin = false
41 | }
42 | }
43 |
44 |
45 | let storage = storages.create('jd_task')
46 | let autoOpen = storage.get('autoOpen', true)
47 | let autoMute = storage.get('autoMute', true)
48 | let autoJoin = storage.get('autoJoin', true)
49 | getSetting()
50 |
51 | if (autoMute) {
52 | try {
53 | device.setMusicVolume(0)
54 | toast('成功设置媒体音量为0')
55 | } catch (err) {
56 | alert('首先需要开启权限,请开启后再次运行脚本')
57 | exit()
58 | }
59 | }
60 |
61 | console.log('开始完成京东任务...')
62 | console.log('按音量下键停止')
63 |
64 | device.keepScreenDim(30 * 60 * 1000) // 防止息屏30分钟
65 |
66 | // 自定义取消亮屏的退出方法
67 | function quit() {
68 | device.cancelKeepingAwake()
69 | exit()
70 | }
71 |
72 | // 监听音量下键
73 | function registerKey() {
74 | try {
75 | events.observeKey()
76 | } catch (err) {
77 | console.log('监听音量键停止失败,应该是无障碍权限出错,请关闭软件后台任务重新运行。')
78 | console.log('如果还是不行可以重启手机尝试。')
79 | quit()
80 | }
81 | events.onKeyDown('volume_down', function (event) {
82 | console.log('京东任务脚本停止了')
83 | console.log('请手动切换回主页面')
84 | startCoin && console.log('本次任务开始时有' + startCoin + '金币')
85 | quit()
86 | })
87 | }
88 | threads.start(registerKey)
89 |
90 | // 自定义一个findTextDescMatchesTimeout
91 | function findTextDescMatchesTimeout(reg, timeout) {
92 | let c = 0
93 | while (c < timeout / 50) {
94 | let result = textMatches(reg).findOnce() || descMatches(reg).findOnce()
95 | if (result) return result
96 | sleep(50)
97 | c++
98 | }
99 | return null
100 | }
101 |
102 | // 打开京东进入活动
103 | function openAndInto() {
104 | console.log('正在打开京东App...')
105 | if (!launch('com.jingdong.app.mall')) {
106 | console.log('可能未安装京东App')
107 | }
108 |
109 | sleep(2000)
110 | console.log('进入活动页面')
111 |
112 | app.startActivity({
113 | action: 'VIEW',
114 | data: 'openApp.jdMobile://virtual?params={"category":"jump","action":"to","des":"m","sourceValue":"JSHOP_SOURCE_VALUE","sourceType":"JSHOP_SOURCE_TYPE","url":"https://u.jd.com/kIsEmAw","M_sourceFrom":"mxz","msf_type":"auto"}',
115 | })
116 | }
117 |
118 | // 获取金币数量
119 | function getCoin() {
120 | let anchor = text('消耗').findOne(5000)
121 | if (!anchor) {
122 | console.log('找不到消耗控件')
123 | return false
124 | }
125 | let coin = anchor.parent().parent().parent().parent().child(1).text()
126 | if (coin) {
127 | return parseInt(coin)
128 | } else {
129 | coin = anchor.parent().parent().parent().parent().child(2).text() // 有可能中间插了个控件
130 | if (coin) {
131 | return parseInt(coin)
132 | } else {
133 | return false
134 | }
135 | }
136 | }
137 |
138 | // 打开任务列表
139 | function openTaskList() {
140 | console.log('打开任务列表')
141 | let taskListButtons = text('消耗').findOne(20000)
142 | if (!taskListButtons) {
143 | console.log('未能打开任务列表,请关闭京东重新运行!')
144 | quit()
145 | }
146 | taskListButtons = taskListButtons.parent().parent().parent().parent().children()
147 |
148 | let taskListButton = taskListButtons.findOne(boundsInside(device.width/2, 0, device.width, device.height).clickable())
149 |
150 | if (!taskListButton || !taskListButton.clickable()) {
151 | console.log('无法找到任务列表控件')
152 | quit()
153 | }
154 | taskListButton.click()
155 | console.log('等待任务列表')
156 | if (!findTextDescMatchesTimeout(/累计任务奖励/, 5000)) {
157 | console.log('似乎没能打开任务列表,重试')
158 | taskListButton.click()
159 | }
160 |
161 | if (!findTextDescMatchesTimeout(/累计任务奖励/, 10000)) {
162 | console.log('似乎没能打开任务列表,退出!')
163 | console.log('如果已经打开而未检测到,请删除101版本及以上的webview或使用国内应用市场版京东尝试。')
164 | quit()
165 | }
166 | }
167 |
168 | // 关闭任务列表
169 | function closeTaskList() {
170 | console.log('关闭任务列表')
171 | let renwu = findTextDescMatchesTimeout(/.*做任务.*/, 5000)
172 | if (!renwu) {
173 | console.log('无法找到任务奖励标识')
174 | return false
175 | }
176 | let closeBtn = renwu.parent().parent().parent().child(0)
177 | return closeBtn.click()
178 | }
179 |
180 | // 重新打开任务列表
181 | function reopenTaskList() {
182 | closeTaskList()
183 | sleep(3000)
184 | openTaskList()
185 | sleep(5000)
186 | }
187 |
188 | // 获取未完成任务,根据数字标识,返回任务按钮、任务介绍、任务数量(数组)
189 | function getTaskByText() {
190 | let tButton = null,
191 | tText = null,
192 | tCount = 0,
193 | tTitle = null
194 | console.log('寻找未完成任务...')
195 | let taskButtons = textMatches(/^(去完成|去领取|去打卡)$/).find()
196 | if (!taskButtons.empty()) { // 如果找不到任务,直接返回
197 | for (let i = 0; i < taskButtons.length; i++) {
198 | let button = taskButtons[i]
199 | if (button.indexInParent() == 0) {
200 | console.log('跳过,如果找不到任务可能是累计任务奖励的去领取按钮造成冲突;将去领取都领了试试。出现此问题麻烦反馈!谢谢!')
201 | continue
202 | }
203 | // if (tButton.text() == '去领取') {
204 | // console.log('领取奖励')
205 | // tButton.click()
206 | // sleep(500)
207 | // continue
208 | // }
209 |
210 | let tmp = button.parent().child(button.indexInParent() - 1)
211 | tTitle = tmp.child(0).text()
212 | let r = tTitle.match(/(\d*)\/(\d*)/)
213 | if (!r) continue
214 |
215 | tCount = (r[2] - r[1])
216 |
217 | console.log(tTitle, tCount)
218 | if (tCount) { // 如果数字相减不为0,证明没完成
219 | tText = tmp.child(1).text()
220 | if (!autoJoin && tText.match(/成功入会/)) continue
221 | if (tTitle.match(/下单|小程序/)) continue
222 | tButton = button
223 | break
224 | }
225 | }
226 | } else {
227 | console.log('任务提示未找到')
228 | }
229 | return [tButton, tText, tCount, tTitle]
230 | }
231 |
232 | // 返回任务列表并检查是否成功,不成功重试一次,带有延时
233 | function backToList() {
234 | sleep(500)
235 | back()
236 | for (let i = 0; i < 3; i++) { // 尝试返回3次
237 | if (!findTextDescMatchesTimeout(/累计任务奖励/, 5000)) {
238 | console.log('返回失败,重试返回')
239 | sleep(2000)
240 | back()
241 | continue
242 | } else {
243 | break
244 | }
245 | }
246 | sleep(3000)
247 | }
248 |
249 | // 浏览n秒的任务
250 | function timeTask() {
251 | console.log('等待浏览任务完成...')
252 | let c = 0
253 | while (c < 40) { // 0.5 * 60 = 20 秒,防止死循环
254 | if ((textMatches(/获得.*?金币/).exists() || descMatches(/获得.*?金币/).exists())) // 等待已完成出现
255 | break
256 | if ((textMatches(/已浏览/).exists() || descMatches(/已浏览/).exists())) { // 失败
257 | console.log('上限,返回刷新任务列表')
258 | return false
259 | }
260 | if (textMatches(/.*滑动浏览.*[^可]得.*/).exists()) {
261 | console.log('进行模拟滑动')
262 | swipe_flag = 1
263 | swipe(device.width / 2, device.height - 200, device.width / 2 + 20, device.height - 500, 500)
264 | }
265 |
266 | // 弹窗处理
267 | let pop = text('升级开卡会员领好礼')
268 | if (pop.exists()) {
269 | pop.findOnce().parent().parent().child(2).click()
270 | console.log('关闭会员弹窗')
271 | }
272 |
273 | sleep(500)
274 | c++
275 | }
276 | if (c > 39) {
277 | console.log('未检测到任务完成标识。')
278 | return false
279 | }
280 | console.log('已完成,准备返回')
281 | return true
282 | }
283 |
284 | // 入会任务
285 | function joinTask() {
286 | let check = textMatches(/.*确认授权即同意.*|.*我的特权.*|.*立即开卡.*|.*解锁全部会员福利.*/).findOne(8000)
287 | if (!check) {
288 | console.log('无法找到入会按钮,判定为已经入会')
289 | return true
290 | } else if (check.text().match(/我的特权/)) {
291 | console.log('已经入会,返回')
292 | return true
293 | } else {
294 | sleep(2000)
295 | if (check.text().match(/.*立即开卡.*|.*解锁全部会员福利.*|授权解锁/)) {
296 | if (check.text() == '授权信息,解锁全部会员福利') {
297 | check = text('去升级').findOnce()
298 | if (!check) {
299 | console.log('此类型无法找到升级按钮,入会失败')
300 | return false
301 | }
302 | }
303 |
304 | let btn = check.bounds()
305 | console.log('即将点击开卡/解锁福利/升级,自动隐藏控制台')
306 | sleep(500)
307 | console.hide()
308 | sleep(500)
309 | click(btn.centerX(), btn.centerY())
310 | sleep(500)
311 | console.show()
312 | sleep(5000)
313 | check = textMatches(/.*确认授权即同意.*/).boundsInside(0, 0, device.width, device.height).findOne(8000)
314 | }
315 |
316 | if (!check) {
317 | console.log('无法找到入会按钮弹窗,加载失败')
318 | return false
319 | }
320 |
321 |
322 | if (check.indexInParent() == 2) {
323 | check = check.parent().child(1)
324 | } else {
325 | let anchor = textContains('*****').findOnce()
326 | check = anchor.parent().child(anchor.indexInParent() + 2)
327 | if (! check.bounds().top >= anchor.bounds().bottom) {
328 | console.log('使用第二种方法获取控件')
329 | let check1 = anchor.parent().children().findOne(filter(function (w) {
330 | if (w.className().match(/ImageView/) && w.bounds().top >= anchor.bounds().bottom) {
331 | return true
332 | } else {
333 | return false
334 | }
335 | }))
336 | if (!check1) {
337 | console.log('第二种方法也无法确认授权勾选框,失败。返回。')
338 | return false
339 | } else {
340 | check = check1
341 | console.log('成功,继续')
342 | }
343 | }
344 | }
345 |
346 | console.log("最终[确认授权]前面选项框坐标为:", check.bounds());
347 | let x = check.bounds().centerX()
348 | let y = check.bounds().centerY()
349 |
350 | console.log('检测是否有遮挡')
351 | let float = className('android.widget.ImageView')
352 | .filter(function (w) {
353 | let b = w.bounds()
354 | return b.left <= x && b.right >= x && b.top <= y && b.bottom >= y && b.centerX() != x && b.centerY() != y
355 | }).findOnce()
356 |
357 | if (float) {
358 | console.log('有浮窗遮挡,尝试移除')
359 | if (device.sdkInt >= 24) {
360 | gesture(1000, [float.bounds().centerX(), float.bounds().centerY()], [float.bounds().centerX(), y + float.bounds().height()])
361 | console.log('已经进行移开操作,如果失败请反馈')
362 | } else {
363 | console.log('安卓版本低,无法自动移开浮窗,入会任务失败。至少需要安卓7.0。')
364 | return false
365 | }
366 | } else {
367 | console.log('未发现遮挡的浮窗,继续勾选')
368 | }
369 |
370 | console.log('即将勾选授权,自动隐藏控制台')
371 | sleep(500)
372 | console.hide()
373 | sleep(1000)
374 | click(x, y)
375 | sleep(500)
376 | console.show()
377 |
378 | console.log('准备点击入会按钮')
379 | let j = textMatches(/^确认授权(并加入店铺会员)*$|.*立即开通.*/).findOne(5000)
380 | if (!j) {
381 | console.log('无法找到入会按钮,失败')
382 | return false
383 | }
384 | click(j.bounds().centerX(), j.bounds().centerY())
385 | sleep(1000)
386 | console.log('入会完成,返回')
387 | return true
388 | }
389 | }
390 |
391 | // 浏览商品和加购的任务,cart参数为是否加购的flag
392 | function itemTask(cart) {
393 | console.log('等待进入商品列表...')
394 | if (!textContains('当前页').findOne(20000)) {
395 | console.log('未能进入商品列表。')
396 | return false
397 | }
398 | sleep(2000)
399 | let items = textContains('.jpg!q70').find()
400 | for (let i = 0; i < items.length; i++) {
401 | if (cart) {
402 | console.log('加购并浏览')
403 | let tmp = items[i].parent().parent()
404 | tmp.child(tmp.childCount() - 1).click()
405 | } else {
406 | console.log('浏览商品页')
407 | items[i].parent().parent().child(4).click()
408 | }
409 | sleep(5000)
410 | console.log('返回')
411 | back()
412 | sleep(5000)
413 | let r = textContains('.jpg!q70').findOnce()
414 | if (!r) {
415 | back()
416 | sleep(5000)
417 | }
418 | if (i >= 4 - 1) {
419 | break
420 | }
421 | }
422 | return true
423 | }
424 |
425 | // 逛店任务
426 | function shopTask() {
427 | console.log('等待进入店铺列表...')
428 | let banner = textContains('喜欢').findOne(10000)
429 | if (!banner) {
430 | console.log('未能进入店铺列表。返回。')
431 | return false
432 | }
433 | let c = banner.text().match(/(\d)\/(\d*)/)
434 | if (!c) {
435 | c = 4 // 进行4次
436 | } else {
437 | c = c[2] - c[1]
438 | }
439 | sleep(2000)
440 | console.log('进行', c, '次')
441 | let like = textContains('喜欢').boundsInside(1, 0, device.width, device.height).findOnce()
442 | if (!like) {
443 | console.log('未能找到喜欢按钮。返回。')
444 | return false
445 | }
446 | let bound = [like.bounds().centerX(), like.bounds().centerY()]
447 | console.log('喜欢按钮位于', bound)
448 | for (let i = 0; i < c; i++) {
449 | click(bound[0], bound[1])
450 | console.log('浏览店铺页')
451 | sleep(8000)
452 | console.log('返回')
453 | back()
454 | sleep(5000)
455 | let r = textContains('喜欢').findOnce()
456 | if (!r) {
457 | back()
458 | sleep(5000)
459 | }
460 | }
461 | return true
462 | }
463 |
464 | // 参观任务
465 | function viewTask() {
466 | console.log('进行参观任务')
467 | sleep(5000)
468 | console.log('参观任务直接返回')
469 | return true
470 | }
471 |
472 | // 品牌墙任务
473 | function wallTask() {
474 | console.log('进行品牌墙任务')
475 | sleep(3000)
476 | for (let i of [2, 3, 4, 5, 6]) { // 选5个
477 | console.log('打开一个')
478 | textContains('!q70').boundsInside(100, 100, device.width, device.height).findOnce(i).click()
479 | sleep(5000)
480 | console.log('直接返回')
481 | back()
482 | let r = textContains('!q70').findOne(8000)
483 | if (!r) back()
484 | sleep(3000)
485 | }
486 | // console.log('返回顶部')
487 | // let root = textContains('到底了').findOnce().parent().parent()
488 | // root.child(root.childCount() - 2).click()
489 | console.log('品牌墙完成后重新打开任务列表')
490 | sleep(3000)
491 | openTaskList()
492 | return true
493 | }
494 |
495 | // 单个任务的function,自动进入任务、自动返回任务列表,返回boolean
496 | function doTask(tButton, tText, tTitle) {
497 | let clickFlag = tButton.click()
498 | let tFlag
499 |
500 | if (tButton.text() == '去领取') {
501 | tFlag = clickFlag // 打卡点击一次即可
502 | return tFlag
503 | }
504 |
505 | if (tText.match(/浏览并关注.*s|浏览.*s/)) {
506 | console.log('进行', tText)
507 | tFlag = timeTask()
508 | } else if (tText.match(/累计浏览/)) {
509 | console.log('进行累计浏览任务')
510 | if (tText.match(/加购/)) {
511 | tFlag = itemTask(true)
512 | } else {
513 | tFlag = itemTask(false)
514 | }
515 | } else if (tText.match(/入会/)) {
516 | console.log('进行入会任务')
517 | tFlag = joinTask()
518 | } else if (tText.match(/浏览可得|浏览并关注|晚会|参与/)) {
519 | if (tTitle.match(/种草城/)) {
520 | tFlag = shopTask()
521 | } else {
522 | tFlag = viewTask()
523 | }
524 | } else if (tText.match(/品牌墙/)) {
525 | if (tTitle.match(/浏览更多权益/)) {
526 | console.log('简单品牌墙任务,等待10s')
527 | sleep(10000)
528 | return true
529 | }
530 | tFlag = wallTask()
531 | return tFlag // 品牌墙无需backToList,提前返回
532 | } else if (tText.match(/打卡|首页/)) {
533 | tFlag = clickFlag // 打卡点击一次即可
534 | return tFlag
535 | } else if (tText.match(/组队/)) {
536 | console.log('等待组队任务')
537 | sleep(3000)
538 | if (findTextDescMatchesTimeout(/累计任务奖励/, 1000)) {
539 | console.log('当前仍在任务列表,说明已经完成任务且领取奖励,返回')
540 | return true
541 | } else {
542 | if (textContains('我的金币').findOne(10000)) {
543 | console.log('进入到组队页面,返回')
544 | backToList()
545 | console.log('等待领取奖励')
546 | sleep(2000)
547 | tFlag = tButton.click()
548 | sleep(2000)
549 | return tFlag
550 | } else {
551 | console.log('未能进入组队')
552 | if (findTextDescMatchesTimeout(/累计任务奖励/, 1000)) {
553 | console.log('当前仍在任务列表,返回')
554 | return true
555 | } else {
556 | console.log('组队任务未检测到页面标识,视为已完成')
557 | tFlag = false
558 | }
559 | }
560 | }
561 | } else {
562 | console.log('未知任务类型,默认为浏览任务', tText)
563 | tFlag = timeTask()
564 | }
565 | backToList()
566 | return tFlag
567 | }
568 |
569 | function signTask() {
570 | let anchor = className('android.view.View').filter(function (w) {
571 | return w.clickable() && (w.text() == '去使用奖励' || w.desc() == '去使用奖励')
572 | }).findOne(5000)
573 |
574 | if (!anchor) {
575 | console.log('未找到使用奖励按钮,签到失败')
576 | return false
577 | }
578 |
579 | let anchor_index = anchor.indexInParent()
580 | let sign = anchor.parent().child(anchor_index + 2) // 去使用的后两个
581 | sign.click()
582 | sleep(3000)
583 |
584 | sign = textMatches(/.*立即签到.*|.*明天继续来.*/).findOne(5000)
585 | if (!sign) {
586 | console.log('未找到签到按钮')
587 | return false
588 | }
589 |
590 | if (sign.text().match(/明天继续来/)) {
591 | console.log('已经签到')
592 | } else {
593 | sign.click()
594 | }
595 |
596 | return true
597 | }
598 |
599 | // 领取金币
600 | function havestCoin() {
601 | console.log('准备领取自动积累的金币')
602 | let h = descMatches(/.*领取金币.*|.*后满.*/).findOne(5000)
603 | if (h) {
604 | h.click()
605 | console.log('领取成功')
606 | } else { console.log('未找到金币控件,领取失败') }
607 | }
608 |
609 | let startCoin = null // 音量键需要
610 |
611 | // 全局try catch,应对无法显示报错
612 | try {
613 | if (autoOpen) {
614 | openAndInto()
615 | console.log('等待活动页面加载')
616 | if (!findTextDescMatchesTimeout(/.*我的记录.*/, 8000)) {
617 | console.log('未能进入活动,请重新运行!')
618 | quit()
619 | }
620 | console.log('成功进入活动,向下滑动一段以保证控件全部出现')
621 | sleep(2000)
622 | scrollDown();
623 |
624 | openTaskList();
625 | } else {
626 | alert('请关闭弹窗后立刻手动打开京东App进入活动页面,并打开任务列表', '限时30秒')
627 | console.log('请手动打开京东App进入活动页面,并打开任务列表')
628 | if (!findTextDescMatchesTimeout(/累计任务奖励|互动攻略/, 30000)) {
629 | console.log('未能进入活动,请重新运行!')
630 | quit()
631 | }
632 | console.log('成功进入活动')
633 | }
634 |
635 | sleep(5000)
636 |
637 | try {
638 | console.log('获取初始金币数量')
639 | startCoin = getCoin()
640 | console.log('当前共有' + startCoin + '金币')
641 | } catch (err) {
642 | console.log('获取金币失败,跳过', err)
643 | }
644 |
645 | sleep(1000)
646 | havestCoin()
647 | sleep(1000)
648 |
649 | // 完成所有任务的循环
650 | while (true) {
651 | let [taskButton, taskText, taskCount, taskTitle] = getTaskByText()
652 |
653 | if (!taskButton) {
654 | console.log('领取累计奖励')
655 | textContains('去领取').find().forEach(function (e, i) {
656 | console.log('领取第' + (i + 1) + '个累计奖励')
657 | e.click()
658 | sleep(2000)
659 | })
660 |
661 | sleep(1000)
662 | havestCoin()
663 | sleep(1000)
664 |
665 | console.log('最后进行签到任务')
666 | signTask()
667 |
668 | let endCoin = null
669 | try {
670 | console.log('获取结束金币数量')
671 | endCoin = getCoin()
672 | console.log('当前共有' + endCoin + '金币')
673 | } catch (err) {
674 | console.log('获取金币失败,跳过', err)
675 | }
676 |
677 | console.log('没有可自动完成的任务了,退出。')
678 | console.log('互动任务、下单任务需要手动完成。')
679 | if (startCoin && endCoin) {
680 | console.log('本次运行获得' + (endCoin - startCoin) + '金币')
681 | } else {
682 | console.log('本次运行获得金币无法计算,具体原因请翻阅日志。')
683 | }
684 |
685 | // alert('任务已完成', '别忘了在脚本主页领取年货节红包!')
686 | alert('任务已完成', '互动任务手动完成之后还会有新任务,建议做完互动二次运行脚本')
687 | quit()
688 | }
689 |
690 | if (taskText.match(/品牌墙/) || taskTitle.match(/种草城/)) { // 品牌墙0/3只需要一次完成
691 | taskCount = 1
692 | }
693 |
694 | // 根据taskCount进行任务,一类任务一起完成,完成后刷新任务列表
695 | console.log('进行' + taskCount + '次“' + taskText + '”类任务')
696 | for (let i = 0; i < taskCount; i++) {
697 | console.log('第' + (i + 1) + '次')
698 | let taskFlag = doTask(taskButton, taskText, taskTitle)
699 | if (taskFlag) {
700 | console.log('完成,进行下一个任务')
701 | } else {
702 | console.log('任务失败,尝试重新打开任务列表获取任务')
703 | break // 直接退出,无需在此调用reopen
704 | }
705 | }
706 | console.log('重新打开任务列表获取任务')
707 | reopenTaskList()
708 | }
709 | } catch (err) {
710 | device.cancelKeepingAwake()
711 | if (err.toString() != 'JavaException: com.stardust.autojs.runtime.exception.ScriptInterruptedException: null') {
712 | console.error(err)
713 | startCoin && console.log('本次任务开始时有' + startCoin + '金币')
714 | }
715 | }
716 |
--------------------------------------------------------------------------------
/backup/jd618.js:
--------------------------------------------------------------------------------
1 | if (!auto.service) {
2 | toast('无障碍服务未启动!退出!')
3 | exit()
4 | }
5 |
6 | console.show()
7 | function getSetting() {
8 | let indices = []
9 | autoOpen && indices.push(0)
10 | autoMute && indices.push(1)
11 | autoJoin && indices.push(2)
12 |
13 | let settings = dialogs.multiChoice(
14 | '任务设置',
15 | [
16 | '自动打开京东进入活动。多开或任务列表无法自动打开时取消勾选',
17 | '自动调整媒体音量为0。以免直播任务发出声音,首次选择需要修改系统设置权限',
18 | '自动完成入会任务。京东将授权手机号给商家,日后可能会收到推广短信',
19 | ],
20 | indices
21 | )
22 |
23 | if (settings.length == 0) {
24 | toast('取消选择,任务停止')
25 | exit()
26 | }
27 |
28 | if (settings.indexOf(0) != -1) {
29 | storage.put('autoOpen', true)
30 | autoOpen = true
31 | } else {
32 | storage.put('autoOpen', false)
33 | autoOpen = false
34 | }
35 | if (settings.indexOf(1) != -1) {
36 | storage.put('autoMute', true)
37 | autoMute = true
38 | } else {
39 | storage.put('autoMute', false)
40 | autoMute = false
41 | }
42 | if (settings.indexOf(2) != -1) {
43 | storage.put('autoJoin', true)
44 | autoJoin = true
45 | } else {
46 | storage.put('autoJoin', false)
47 | autoJoin = false
48 | }
49 | }
50 |
51 | let storage = storages.create('jd_task')
52 | let autoOpen = storage.get('autoOpen', true)
53 | let autoMute = storage.get('autoMute', true)
54 | let autoJoin = storage.get('autoJoin', true)
55 | getSetting()
56 |
57 | if (autoMute) {
58 | try {
59 | device.setMusicVolume(0)
60 | toast('成功设置媒体音量为0')
61 | } catch (err) {
62 | alert('首先需要开启权限,请开启后再次运行脚本')
63 | exit()
64 | }
65 | }
66 |
67 | console.log('开始完成京东任务...')
68 | console.log('按音量下键停止')
69 |
70 | device.keepScreenDim(30 * 60 * 1000) // 防止息屏30分钟
71 |
72 | // 自定义取消亮屏的退出方法
73 | function quit() {
74 | device.cancelKeepingAwake()
75 | exit()
76 | }
77 |
78 | // 监听音量下键
79 | function registerKey() {
80 | try {
81 | events.observeKey()
82 | } catch (err) {
83 | console.log(
84 | '监听音量键停止失败,应该是无障碍权限出错,请关闭软件后台任务重新运行。'
85 | )
86 | console.log('如果还是不行可以重启手机尝试。')
87 | quit()
88 | }
89 | events.onKeyDown('volume_down', function (event) {
90 | console.log('京东任务脚本停止了')
91 | console.log('请手动切换回主页面')
92 | startCoin && console.log('本次任务开始时有' + startCoin + '金币')
93 | quit()
94 | })
95 | }
96 | threads.start(registerKey)
97 |
98 | // 自定义一个findTextDescMatchesTimeout
99 | function findTextDescMatchesTimeout(reg, timeout) {
100 | let c = 0
101 | while (c < timeout / 50) {
102 | let result = textMatches(reg).findOnce() || descMatches(reg).findOnce()
103 | if (result) return result
104 | sleep(50)
105 | c++
106 | }
107 | return null
108 | }
109 |
110 | // 打开京东进入活动
111 | function openAndInto() {
112 | console.log('正在打开京东App...')
113 | if (!launch('com.jingdong.app.mall')) {
114 | console.log('可能未安装京东App')
115 | }
116 |
117 | sleep(2000)
118 | console.log('进入活动页面')
119 |
120 | app.startActivity({
121 | action: 'VIEW',
122 | data: 'openApp.jdMobile://virtual?params={"category":"jump","action":"to","des":"m","sourceValue":"JSHOP_SOURCE_VALUE","sourceType":"JSHOP_SOURCE_TYPE","url":"https://u.jd.com/lM6G0Zf","M_sourceFrom":"mxz","msf_type":"auto"}',
123 | })
124 | }
125 |
126 | // 获取金币数量
127 | function getCoin() {
128 | let anchor = className('android.view.View')
129 | .filter(function (w) {
130 | if (
131 | (w.desc() && w.desc().match(/分红:.*份/)) ||
132 | (w.text() && w.text().match(/分红:.*份/))
133 | ) {
134 | return true
135 | } else {
136 | return false
137 | }
138 | })
139 | .findOne(5000)
140 | if (!anchor) {
141 | console.log('找不到分红控件')
142 | return false
143 | }
144 | let coin = anchor.parent().child(2).text()
145 | if (coin) {
146 | return parseInt(coin)
147 | } else {
148 | coin = anchor.parent().child(3).text() // 有可能中间插了个控件
149 | if (coin) {
150 | return parseInt(coin)
151 | } else {
152 | return false
153 | }
154 | }
155 | }
156 |
157 | // 打开任务列表
158 | function openTaskList() {
159 | console.log('打开任务列表')
160 | let taskListButtons = findTextDescMatchesTimeout(/分红\+卡牌/, 20000)
161 | if (!taskListButtons) {
162 | console.log('未能打开任务列表,请关闭京东重新运行!')
163 | quit()
164 | }
165 | if (taskListButtons.indexInParent() == 0) {
166 | taskListButtons = taskListButtons.parent().parent().children()
167 | } else {
168 | taskListButtons = taskListButtons.parent().children()
169 | }
170 |
171 | let taskListButton = null
172 | let flag = 0
173 | for (let i = 3; i < taskListButtons.length; i++) {
174 | // 从第4(4-1)个开始
175 | if (taskListButtons[i].clickable()) {
176 | if (flag) {
177 | taskListButton = taskListButtons[i]
178 | break
179 | } else {
180 | flag = 1
181 | continue
182 | }
183 | }
184 | }
185 |
186 | if (!taskListButton || !taskListButton.clickable()) {
187 | console.log('无法找到任务列表控件')
188 | quit()
189 | }
190 | taskListButton.click()
191 | console.log('等待任务列表')
192 | if (!findTextDescMatchesTimeout(/累计任务奖励/, 10000)) {
193 | console.log('似乎没能打开任务列表,退出!')
194 | console.log(
195 | '如果已经打开而未检测到,请删除101版本及以上的webview或使用国内应用市场版京东尝试。'
196 | )
197 | quit()
198 | }
199 | }
200 |
201 | // 关闭任务列表
202 | function closeTaskList() {
203 | console.log('关闭任务列表')
204 | let jiangli = findTextDescMatchesTimeout(/累计任务奖励/, 5000)
205 | if (!jiangli) {
206 | console.log('无法找到任务奖励标识')
207 | return false
208 | }
209 | let closeBtn = jiangli.parent().child(1)
210 | return closeBtn.click()
211 | }
212 |
213 | // 重新打开任务列表
214 | function reopenTaskList() {
215 | closeTaskList()
216 | sleep(3000)
217 | openTaskList()
218 | sleep(5000)
219 | }
220 |
221 | // 获取未完成任务,根据数字标识,返回任务按钮、任务介绍、任务数量(数组)
222 | function getTaskByText() {
223 | let tButton = null,
224 | tText = null,
225 | tCount = 0,
226 | tTitle = null
227 | console.log('寻找未完成任务...')
228 | let taskButtons = textMatches(
229 | /.*浏览并关注.*|.*浏览.*s.*|.*累计浏览.*|.*浏览可得.*|.*逛晚会.*|.*品牌墙.*|.*打卡.*/
230 | ).find()
231 | if (!taskButtons.empty()) {
232 | // 如果找不到任务,直接返回
233 | for (let i = 0; i < taskButtons.length; i++) {
234 | let item = taskButtons[i]
235 | tTitle = item.parent().child(1).text()
236 | let r = tTitle.match(/(\d)\/(\d*)/)
237 | if (!r) continue
238 |
239 | tCount = r[2] - r[1]
240 |
241 | console.log(tTitle, tCount)
242 | if (tCount) {
243 | // 如果数字相减不为0,证明没完成
244 | tText = item.text()
245 | if (!autoJoin && tText.match(/成功入会/)) continue
246 | if (tText.match(/下单/)) continue
247 | tButton = item.parent().child(3)
248 | break
249 | }
250 | }
251 | }
252 | return [tButton, tText, tCount, tTitle]
253 | }
254 |
255 | // 返回任务列表并检查是否成功,不成功重试一次,带有延时
256 | function backToList() {
257 | sleep(500)
258 | back()
259 | for (let i = 0; i < 3; i++) {
260 | // 尝试返回3次
261 | if (!findTextDescMatchesTimeout(/累计任务奖励/, 5000)) {
262 | console.log('返回失败,重试返回')
263 | sleep(2000)
264 | back()
265 | continue
266 | } else {
267 | break
268 | }
269 | }
270 | sleep(3000)
271 | }
272 |
273 | // 浏览n秒的任务
274 | function timeTask() {
275 | console.log('等待浏览任务完成...')
276 | let c = 0
277 | while (c < 40) {
278 | // 0.5 * 40 = 20 秒,防止死循环
279 | if (
280 | textMatches(/获得.*?金币/).exists() ||
281 | descMatches(/获得.*?金币/).exists()
282 | )
283 | // 等待已完成出现
284 | break
285 | if (textMatches(/已浏览/).exists() || descMatches(/已浏览/).exists()) {
286 | // 失败
287 | console.log('上限,返回刷新任务列表')
288 | return false
289 | }
290 |
291 | // 弹窗处理
292 | let pop = text('升级开卡会员领好礼')
293 | if (pop.exists()) {
294 | pop.findOnce().parent().parent().child(2).click()
295 | console.log('关闭会员弹窗')
296 | }
297 |
298 | sleep(500)
299 | c++
300 | }
301 | if (c > 39) {
302 | console.log('未检测到任务完成标识。')
303 | return false
304 | }
305 | return true
306 | }
307 |
308 | // 入会任务
309 | function joinTask() {
310 | let check = textMatches(
311 | /.*确认授权即同意.*|.*我的特权.*|.*立即开卡.*|.*解锁全部会员福利.*/
312 | ).findOne(8000)
313 | if (!check) {
314 | console.log('无法找到入会按钮,判定为已经入会')
315 | return true
316 | } else if (check.text().match(/我的特权/)) {
317 | console.log('已经入会,返回')
318 | return true
319 | } else {
320 | sleep(2000)
321 | if (check.text().match(/.*立即开卡.*|.*解锁全部会员福利.*|授权解锁/)) {
322 | let btn = check.bounds()
323 | console.log('即将点击开卡/解锁福利,自动隐藏控制台')
324 | sleep(500)
325 | console.hide()
326 | sleep(500)
327 | click(btn.centerX(), btn.centerY())
328 | sleep(500)
329 | console.show()
330 | sleep(5000)
331 | check = textMatches(/.*确认授权即同意.*/)
332 | .boundsInside(0, 0, device.width, device.height)
333 | .findOne(8000)
334 | }
335 |
336 | if (!check) {
337 | console.log('无法找到入会按钮弹窗,加载失败')
338 | return false
339 | }
340 |
341 | // text("instruction_icon") 全局其实都只有一个, 保险起见, 使用两个parent来限定范围
342 | let checks = check.parent().parent().find(text('instruction_icon'))
343 | if (checks.size() > 0) {
344 | // 解决部分店铺(欧莱雅)开卡无法勾选 [确认授权] 的问题
345 | check = checks.get(0)
346 | } else {
347 | if (check.indexInParent() == 6) {
348 | check = check.parent().child(5)
349 | } else if (check.text() == '确认授权即同意') {
350 | check = check.parent().child(0)
351 | } else {
352 | check = check.parent().parent().child(5)
353 | }
354 | }
355 |
356 | check = check.bounds()
357 | log('最终[确认授权]前面选项框坐标为:', check)
358 | let x = check.centerX()
359 | let y = check.centerY()
360 |
361 | console.log('检测是否有遮挡')
362 | let float = className('android.widget.ImageView')
363 | .filter(function (w) {
364 | let b = w.bounds()
365 | return b.left <= x && b.right >= x && b.top <= y && b.bottom >= y
366 | })
367 | .find()
368 |
369 | if (float.length > 1) {
370 | console.log('有浮窗遮挡,尝试移除')
371 | if (device.sdkInt >= 24) {
372 | gesture(1000, [x, y], [x, y + 300])
373 | console.log('已经进行移开操作,如果失败请反馈')
374 | } else {
375 | console.log(
376 | '安卓版本低,无法自动移开浮窗,入会任务失败。至少需要安卓7.0。'
377 | )
378 | return false
379 | }
380 | } else {
381 | console.log('未发现遮挡的浮窗,继续勾选')
382 | }
383 |
384 | console.log('即将勾选授权,自动隐藏控制台')
385 | sleep(500)
386 | console.hide()
387 | sleep(1000)
388 | click(x, y)
389 | sleep(500)
390 | console.show()
391 |
392 | console.log('准备点击入会按钮')
393 | let j = textMatches(/^确认授权(并加入店铺会员)*$/).findOne(5000)
394 | if (!j) {
395 | console.log('无法找到入会按钮,失败')
396 | return false
397 | }
398 | click(j.bounds().centerX(), j.bounds().centerY())
399 | sleep(1000)
400 | console.log('入会完成,返回')
401 | return true
402 | }
403 | }
404 |
405 | // 浏览商品和加购的任务,cart参数为是否加购的flag
406 | function itemTask(cart) {
407 | console.log('等待进入商品列表...')
408 | if (!textContains('当前页').findOne(10000)) {
409 | console.log('未能进入商品列表。')
410 | return false
411 | }
412 | sleep(2000)
413 | let items = textContains('.jpg!q70').find()
414 | for (let i = 0; i < items.length; i++) {
415 | if (cart) {
416 | console.log('加购并浏览')
417 | let tmp = items[i].parent().parent()
418 | tmp.child(tmp.childCount() - 1).click()
419 | } else {
420 | console.log('浏览商品页')
421 | items[i].parent().parent().child(4).click()
422 | }
423 | sleep(5000)
424 | console.log('返回')
425 | back()
426 | sleep(5000)
427 | let r = textContains('.jpg!q70').findOnce()
428 | if (!r) {
429 | back()
430 | sleep(5000)
431 | }
432 | if (i >= 4 - 1) {
433 | break
434 | }
435 | }
436 | return true
437 | }
438 |
439 | // 逛店任务
440 | function shopTask() {
441 | console.log('等待进入店铺列表...')
442 | let banner = textContains('喜欢').findOne(10000)
443 | if (!banner) {
444 | console.log('未能进入店铺列表。返回。')
445 | return false
446 | }
447 | let c = banner.text().match(/(\d)\/(\d*)/)
448 | if (!c) {
449 | c = 4 // 进行4次
450 | } else {
451 | c = c[2] - c[1]
452 | }
453 | sleep(2000)
454 | console.log('进行', c, '次')
455 | let like = textContains('喜欢')
456 | .boundsInside(1, 0, device.width, device.height)
457 | .findOnce()
458 | if (!like) {
459 | console.log('未能找到喜欢按钮。返回。')
460 | return false
461 | }
462 | let bound = [like.bounds().centerX(), like.bounds().centerY()]
463 | console.log('喜欢按钮位于', bound)
464 | for (let i = 0; i < c; i++) {
465 | click(bound[0], bound[1])
466 | console.log('浏览店铺页')
467 | sleep(8000)
468 | console.log('返回')
469 | back()
470 | sleep(5000)
471 | let r = textContains('喜欢').findOnce()
472 | if (!r) {
473 | back()
474 | sleep(5000)
475 | }
476 | }
477 | return true
478 | }
479 |
480 | // 参观任务
481 | function viewTask() {
482 | console.log('进行参观任务')
483 | sleep(5000)
484 | console.log('参观任务直接返回')
485 | return true
486 | }
487 |
488 | // 品牌墙任务
489 | function wallTask() {
490 | console.log('进行品牌墙任务')
491 | sleep(3000)
492 | for (let i of [2, 3, 4, 5, 6]) {
493 | // 选5个
494 | console.log('打开一个')
495 | textContains('!q70')
496 | .boundsInside(0, 0, device.width, device.height)
497 | .findOnce(i)
498 | .click()
499 | sleep(5000)
500 | console.log('直接返回')
501 | back()
502 | let r = textContains('!q70').findOne(8000)
503 | if (!r) back()
504 | sleep(3000)
505 | }
506 | console.log('返回顶部')
507 | let root = textContains('到底了').findOnce().parent().parent()
508 | root.child(root.childCount() - 2).click()
509 | console.log('品牌墙完成后重新打开任务列表')
510 | sleep(3000)
511 | openTaskList()
512 | return true
513 | }
514 |
515 | // 单个任务的function,自动进入任务、自动返回任务列表,返回boolean
516 | function doTask(tButton, tText, tTitle) {
517 | let clickFlag = tButton.click()
518 | let tFlag
519 | if (tText.match(/浏览并关注.*s|浏览.*s/)) {
520 | console.log('进行', tText)
521 | tFlag = timeTask()
522 | } else if (tText.match(/累计浏览/)) {
523 | console.log('进行累计浏览任务')
524 | if (tText.match(/加购/)) {
525 | tFlag = itemTask(true)
526 | } else {
527 | tFlag = itemTask(false)
528 | }
529 | } else if (tText.match(/入会/)) {
530 | console.log('进行入会任务')
531 | tFlag = joinTask()
532 | } else if (tText.match(/浏览可得|浏览并关注|晚会/)) {
533 | let tTitle = tButton.parent().child(1).text()
534 | if (tTitle.match(/种草城/)) {
535 | tFlag = shopTask()
536 | } else {
537 | tFlag = viewTask()
538 | }
539 | } else if (tText.match(/品牌墙/)) {
540 | tFlag = wallTask()
541 | return tFlag // 品牌墙无需backToList,提前返回
542 | } else if (tText.match(/打卡/)) {
543 | tFlag = clickFlag // 打卡点击一次即可
544 | return tFlag
545 | } else {
546 | console.log('未知任务类型,默认为浏览任务', tText)
547 | tFlag = timeTask()
548 | }
549 | backToList()
550 | return tFlag
551 | }
552 |
553 | function signTask() {
554 | let anchor = className('android.view.View')
555 | .filter(function (w) {
556 | return (
557 | w.clickable() && (w.text() == '去使用奖励' || w.desc() == '去使用奖励')
558 | )
559 | })
560 | .findOne(5000)
561 |
562 | if (!anchor) {
563 | console.log('未找到使用奖励按钮,签到失败')
564 | return false
565 | }
566 |
567 | let anchor_index = anchor.indexInParent()
568 | let sign = anchor.parent().child(anchor_index + 2) // 去使用的后两个
569 | sign.click()
570 | sleep(3000)
571 |
572 | sign = textMatches(/.*点我签到.*|.*明天再来.*/).findOne(5000)
573 | if (!sign) {
574 | console.log('未找到签到按钮')
575 | return false
576 | }
577 |
578 | if (sign.text().match(/明天再来/)) {
579 | console.log('已经签到')
580 | } else {
581 | click(sign.bounds().centerX(), sign.bounds().centerY())
582 | sleep(1000)
583 | console.log('签到完成')
584 |
585 | // let next = textContains('下一个红包').findOne(5000)
586 | // if (!next) {
587 | // console.log('找不到下一个红包提示语,未能自动关闭弹窗')
588 | // } else {
589 | // console.log('关闭签到弹窗')
590 | // next.parent().child(0).click()
591 | // sleep(1000)
592 | // }
593 | }
594 |
595 | // let title = text('每天签到领大额红包').findOne(5000)
596 | // if (!title) {
597 | // console.log('未找到标题,未能自动关闭签到页。')
598 | // return false
599 | // }
600 | // console.log('关闭签到页')
601 | // title.parent().child(0).click()
602 | // sleep(1000)
603 |
604 | console.log('检测是否有通知权限弹窗')
605 | if (textContains('通知权限').findOne(3000)) {
606 | console.log('出现弹窗,关闭')
607 | text('取消').click()
608 | sleep(1000)
609 | console.log('二次检测')
610 | if (textContains('通知权限').findOne(3000)) {
611 | console.log('出现弹窗,关闭')
612 | text('取消').click()
613 | sleep(1000)
614 | console.log('完成')
615 | } else {
616 | console.log('没有弹窗,继续。')
617 | }
618 | } else {
619 | console.log('没有弹窗,继续。')
620 | }
621 |
622 | return true
623 | }
624 |
625 | // 领取金币
626 | function havestCoin() {
627 | console.log('准备领取自动积累的金币')
628 | let h = descMatches(/.*领取金币.*|.*后满.*/).findOne(5000)
629 | if (h) {
630 | h.click()
631 | console.log('领取成功')
632 | } else {
633 | console.log('未找到金币控件,领取失败')
634 | }
635 | }
636 |
637 | let startCoin = null // 音量键需要
638 |
639 | // 全局try catch,应对无法显示报错
640 | try {
641 | if (autoOpen) {
642 | openAndInto()
643 | console.log('等待活动页面加载')
644 | if (!findTextDescMatchesTimeout(/.*去使用奖励.*/, 8000)) {
645 | console.log('未能进入活动,请重新运行!')
646 | quit()
647 | }
648 | console.log('成功进入活动')
649 | sleep(2000)
650 |
651 | openTaskList()
652 | } else {
653 | alert(
654 | '请关闭弹窗后立刻手动打开京东App进入活动页面,并打开任务列表',
655 | '限时30秒'
656 | )
657 | console.log('请手动打开京东App进入活动页面,并打开任务列表')
658 | if (!findTextDescMatchesTimeout(/累计任务奖励/, 30000)) {
659 | console.log('未能进入活动,请重新运行!')
660 | quit()
661 | }
662 | console.log('成功进入活动')
663 | }
664 |
665 | sleep(5000)
666 |
667 | try {
668 | console.log('获取初始金币数量')
669 | startCoin = getCoin()
670 | console.log('当前共有' + startCoin + '金币')
671 | } catch (err) {
672 | console.log('获取金币失败,跳过', err)
673 | }
674 |
675 | sleep(1000)
676 | havestCoin()
677 | sleep(1000)
678 |
679 | // 完成所有任务的循环
680 | while (true) {
681 | let [taskButton, taskText, taskCount, taskTitle] = getTaskByText()
682 |
683 | if (!taskButton) {
684 | console.log('领取累计奖励')
685 | textContains('去领取')
686 | .find()
687 | .forEach(function (e, i) {
688 | console.log('领取第' + (i + 1) + '个累计奖励')
689 | e.click()
690 | sleep(2000)
691 | })
692 |
693 | console.log('最后进行签到任务')
694 | signTask()
695 |
696 | sleep(1000)
697 | havestCoin()
698 | sleep(1000)
699 |
700 | let endCoin = null
701 | try {
702 | console.log('获取结束金币数量')
703 | endCoin = getCoin()
704 | console.log('当前共有' + endCoin + '金币')
705 | } catch (err) {
706 | console.log('获取金币失败,跳过', err)
707 | }
708 |
709 | console.log('没有可自动完成的任务了,退出。')
710 | console.log('互动任务、下单任务需要手动完成。')
711 | if (startCoin && endCoin) {
712 | console.log('本次运行获得' + (endCoin - startCoin) + '金币')
713 | } else {
714 | console.log('本次运行获得金币无法计算,具体原因请翻阅日志。')
715 | }
716 |
717 | // alert('任务已完成', '别忘了在脚本主页领取年货节红包!')
718 | alert(
719 | '任务已完成',
720 | '互动任务手动完成之后还会有新任务,建议做完互动二次运行脚本'
721 | )
722 | quit()
723 | }
724 |
725 | if (taskText.match(/品牌墙/)) {
726 | // 品牌墙0/3只需要一次完成
727 | taskCount = 1
728 | }
729 |
730 | // 根据taskCount进行任务,一类任务一起完成,完成后刷新任务列表
731 | console.log('进行' + taskCount + '次“' + taskText + '”类任务')
732 | for (let i = 0; i < taskCount; i++) {
733 | console.log('第' + (i + 1) + '次')
734 | let taskFlag = doTask(taskButton, taskText, taskTitle)
735 | if (taskFlag) {
736 | console.log('完成,进行下一个任务')
737 | } else {
738 | console.log('任务失败,尝试重新打开任务列表获取任务')
739 | break // 直接退出,无需在此调用reopen
740 | }
741 | }
742 | console.log('重新打开任务列表获取任务')
743 | reopenTaskList()
744 | }
745 | } catch (err) {
746 | device.cancelKeepingAwake()
747 | if (
748 | err.toString() !=
749 | 'JavaException: com.stardust.autojs.runtime.exception.ScriptInterruptedException: null'
750 | ) {
751 | console.error(new Error().stack, err)
752 | startCoin && console.log('本次任务开始时有' + startCoin + '金币')
753 | }
754 | }
755 |
--------------------------------------------------------------------------------
/backup/jd_choujiang.js:
--------------------------------------------------------------------------------
1 | if (!auto.service) {
2 | toast('无障碍服务未启动!退出!')
3 | exit()
4 | }
5 |
6 | console.show()
7 |
8 | function getSetting() {
9 | let indices = []
10 | autoOpen && indices.push(0)
11 | autoMute && indices.push(1)
12 | autoJoin && indices.push(2)
13 |
14 | let settings = dialogs.multiChoice(
15 | '任务设置',
16 | [
17 | '自动打开京东进入活动。多开或任务列表无法自动打开时取消勾选',
18 | '自动调整媒体音量为0。以免直播任务发出声音,首次选择需要修改系统设置权限',
19 | '自动完成入会任务。京东将授权手机号给商家,日后可能会收到推广短信',
20 | ],
21 | indices
22 | )
23 |
24 | if (settings.length == 0) {
25 | toast('取消选择,任务停止')
26 | exit()
27 | }
28 |
29 | if (settings.indexOf(0) != -1) {
30 | storage.put('autoOpen', true)
31 | autoOpen = true
32 | } else {
33 | storage.put('autoOpen', false)
34 | autoOpen = false
35 | }
36 | if (settings.indexOf(1) != -1) {
37 | storage.put('autoMute', true)
38 | autoMute = true
39 | } else {
40 | storage.put('autoMute', false)
41 | autoMute = false
42 | }
43 | if (settings.indexOf(2) != -1) {
44 | storage.put('autoJoin', true)
45 | autoJoin = true
46 | } else {
47 | storage.put('autoJoin', false)
48 | autoJoin = false
49 | }
50 | }
51 |
52 | let storage = storages.create('jd_task')
53 | let autoOpen = storage.get('autoOpen', true)
54 | let autoMute = storage.get('autoMute', true)
55 | let autoJoin = storage.get('autoJoin', true)
56 | getSetting()
57 |
58 | // 自定义取消亮屏的退出方法
59 | function quit() {
60 | device.cancelKeepingAwake()
61 | exit()
62 | }
63 |
64 | // 监听音量下键
65 | function registerKey() {
66 | try {
67 | events.observeKey()
68 | } catch (err) {
69 | console.log(
70 | '监听音量键(用于停止脚本)失败,应该是无障碍权限出错,请关闭软件后台任务重新运行。'
71 | )
72 | console.log('如果还是不行可以重启手机尝试。')
73 | quit()
74 | }
75 | events.onKeyDown('volume_down', function (event) {
76 | console.log('京东任务脚本停止了')
77 | console.log('请手动切换回主页面')
78 | quit()
79 | })
80 | }
81 | threads.start(registerKey)
82 |
83 | // 自定义一个findTextDescMatchesTimeout
84 | function findTextDescMatchesTimeout(reg, timeout) {
85 | let c = 0
86 | while (c < timeout / 50) {
87 | let result = textMatches(reg).findOnce() || descMatches(reg).findOnce()
88 | if (result) return result
89 | sleep(50)
90 | c++
91 | }
92 | return null
93 | }
94 |
95 | // 打开京东进入活动
96 | function openAndInto() {
97 | console.log('正在打开京东App...')
98 | if (!launch('com.jingdong.app.mall')) {
99 | console.log('可能未安装京东App')
100 | }
101 |
102 | sleep(2000)
103 | console.log('进入活动页面')
104 |
105 | app.startActivity({
106 | action: 'VIEW',
107 | data: 'openApp.jdMobile://virtual?params={"category":"jump","action":"to","des":"m","sourceValue":"JSHOP_SOURCE_VALUE","sourceType":"JSHOP_SOURCE_TYPE","url":"https://u.jd.com/lM6Qy1U","M_sourceFrom":"mxz","msf_type":"auto"}',
108 | })
109 | }
110 |
111 | // 获取金币数量
112 | function getCoin() {
113 | let anchor = className('android.view.View')
114 | .filter(function (w) {
115 | if (
116 | (w.desc() && w.desc().match(/分红:.*份/)) ||
117 | (w.text() && w.text().match(/分红:.*份/))
118 | ) {
119 | return true
120 | } else {
121 | return false
122 | }
123 | })
124 | .findOne(5000)
125 | if (!anchor) {
126 | console.log('找不到分红控件')
127 | return false
128 | }
129 | let coin = anchor.parent().child(2).text()
130 | if (coin) {
131 | return parseInt(coin)
132 | } else {
133 | coin = anchor.parent().child(3).text() // 有可能中间插了个控件
134 | if (coin) {
135 | return parseInt(coin)
136 | } else {
137 | return false
138 | }
139 | }
140 | }
141 |
142 | // 打开抽奖页
143 | function openPage() {
144 | button = findTextDescMatchesTimeout(/分红:.*份/, 20000)
145 | button = button.parent().children()
146 | button[0].click()
147 |
148 | return text('累计获得').findOne(8000)
149 | }
150 |
151 | // 查找任务,返回所有任务
152 | function findTasks() {
153 | let anchor = findTextDescMatchesTimeout('剩余抽奖次数', 20000)
154 | if (!anchor) {
155 | console.log('无法找到抽奖次数控件')
156 | return false
157 | }
158 | console.log('打开任务列表')
159 | anchor = anchor.parent().parent().parent().parent()
160 |
161 | if (anchor.childCount() == 8) {
162 | // 关闭弹窗
163 | if (anchor.child(7).childCount() > 0) {
164 | console.log('关闭弹窗')
165 | anchor.child(7).child(0).child(0).child(0).child(3).click()
166 | sleep(1000)
167 | }
168 | }
169 |
170 | anchor.child(1).click()
171 | sleep(5000)
172 | let go = findTextDescMatchesTimeout('去完成', 2000)
173 | if (!go) {
174 | console.log('似乎未能打开任务列表')
175 | return false
176 | }
177 | console.log('任务列表已打开')
178 | let tasks = []
179 | let taskList = go.parent().children()
180 | let task = []
181 | for (let i = 0; i < taskList.length; i++) {
182 | let e = taskList[i]
183 | if (e.text()) {
184 | task.push(e.text())
185 | if (e.text() == '去完成') {
186 | if (!task[0].match(/邀/)) {
187 | // 如果有邀请好友就不完成
188 | tasks.push([task[0], e])
189 | }
190 | task = []
191 | } else if (e.text() == '已完成') {
192 | task = []
193 | }
194 | }
195 | }
196 | console.log('任务寻找结束')
197 | return tasks
198 | }
199 |
200 | function backToPage() {
201 | back()
202 | if (!text('剩余抽奖次数').findOne(8000)) {
203 | console.log('返回失败,重试')
204 | back()
205 | if (!text('剩余抽奖次数').findOne(8000)) {
206 | console.log('似乎未能返回')
207 | return false
208 | }
209 | }
210 | return true
211 | }
212 |
213 | // 入会任务
214 | function joinTask() {
215 | let check = textMatches(
216 | /.*确认授权即同意.*|.*我的特权.*|.*立即开卡.*|.*解锁全部会员福利.*/
217 | ).findOne(8000)
218 | if (!check) {
219 | console.log('无法找到入会按钮,判定为已经入会')
220 | return true
221 | } else if (check.text().match(/我的特权/)) {
222 | console.log('已经入会,返回')
223 | return true
224 | } else {
225 | sleep(2000)
226 | if (check.text().match(/.*立即开卡.*|.*解锁全部会员福利.*/)) {
227 | let btn = check.bounds()
228 | console.log('即将点击开卡/解锁福利,自动隐藏控制台')
229 | sleep(500)
230 | console.hide()
231 | sleep(500)
232 | click(btn.centerX(), btn.centerY())
233 | sleep(500)
234 | console.show()
235 | check = textMatches(/.*确认授权即同意.*/)
236 | .boundsInside(0, 0, device.width, device.height)
237 | .findOne(8000)
238 | sleep(2000)
239 | }
240 |
241 | if (!check) {
242 | console.log('无法找到入会按钮弹窗,加载失败')
243 | return false
244 | }
245 |
246 | if (check.indexInParent() == 6) {
247 | check = check.parent().child(5)
248 | } else if (check.text() == '确认授权即同意') {
249 | check = check.parent().child(0)
250 | } else {
251 | check = check.parent().parent().child(5)
252 | }
253 |
254 | check = check.bounds()
255 |
256 | let x = check.centerX()
257 | let y = check.centerY()
258 |
259 | console.log('检测是否有遮挡')
260 | let float = className('android.widget.ImageView')
261 | .filter(function (w) {
262 | let b = w.bounds()
263 | return b.left <= x && b.right >= x && b.top <= y && b.bottom >= y
264 | })
265 | .find()
266 |
267 | if (float.length > 1) {
268 | console.log('有浮窗遮挡,尝试移除')
269 | if (device.sdkInt >= 24) {
270 | gesture(1000, [x, y], [x, y + 200])
271 | console.log('已经进行移开操作,如果失败请反馈')
272 | } else {
273 | console.log(
274 | '安卓版本低,无法自动移开浮窗,入会任务失败。至少需要安卓7.0。'
275 | )
276 | return false
277 | }
278 | } else {
279 | console.log('未发现遮挡的浮窗,继续勾选')
280 | }
281 |
282 | console.log('即将勾选授权,自动隐藏控制台')
283 | sleep(500)
284 | console.hide()
285 | sleep(500)
286 | click(x, y)
287 | sleep(500)
288 | console.show()
289 |
290 | console.log('准备点击入会按钮')
291 | let j = textMatches(/^确认授权(并加入店铺会员)*$/).findOne(5000)
292 | if (!j) {
293 | console.log('无法找到入会按钮,失败')
294 | return false
295 | }
296 | click(j.bounds().centerX(), j.bounds().centerY())
297 | sleep(1000)
298 | console.log('入会完成,返回')
299 | return true
300 | }
301 | }
302 |
303 | // 进行抽奖活动
304 | function doTask(task) {
305 | let tTitle = task[0]
306 | let tButton = task[1]
307 | console.log('进行', tTitle)
308 | tButton.click()
309 | if (tTitle.match(/签到/)) {
310 | console.log('签到完成')
311 | return true
312 | } else if (tTitle.match(/加购/)) {
313 | let itemFilter = textContains('!q70').filter(function (w) {
314 | // return w.bounds().width() == w.bounds().height() // 等宽高
315 | // return w.depth() >= 15
316 | let rect = w.bounds()
317 | return rect.left > 0 && rect.top <= device.height
318 | })
319 |
320 | console.log('查找商品,等待至多20秒')
321 | if (!itemFilter.findOne(20000)) {
322 | console.log('未能找到加购商品')
323 | return false
324 | }
325 |
326 | let items = itemFilter.find()
327 | if (items.empty() || items.length < 2) {
328 | console.log('查找商品失败')
329 | return false
330 | }
331 | for (let i = 0; i < 2; i++) {
332 | console.log('加购第' + (i + 1) + '个商品')
333 | items[i].parent().parent().parent().child(1).child(2).click()
334 | sleep(2000)
335 | }
336 | console.log('加购完成')
337 | let t = items[0].parent().parent().parent().parent().parent()
338 | t.child(t.childCount() - 2).click() // 关闭
339 | return true
340 | } else if (tTitle.match(/会员|品牌页/)) {
341 | console.log('进行入会任务')
342 | return joinTask() && backToPage()
343 | } else {
344 | console.log('浏览任务,稍后返回')
345 | sleep(3000)
346 | return true && backToPage()
347 | }
348 | }
349 |
350 | // 抽奖
351 | function openBox() {
352 | let anchor = text('剩余抽奖次数').findOne(8000)
353 | if (!anchor) {
354 | console.log('未能找到抽奖提示')
355 | return false
356 | }
357 |
358 | let count = anchor.parent().child(1).text()
359 | if (!parseInt(count)) {
360 | console.log('没有抽奖次数,返回')
361 | return true
362 | }
363 | console.log('进行抽奖,由于无法判断是否已经开盒,所以每个盒子都点一遍')
364 | let box = anchor.parent().parent().children()
365 | for (let i = 0; i < 6; i++) {
366 | console.log('打开第' + (i + 1) + '个盒子')
367 | box[i].click()
368 | console.log('检测弹窗')
369 | let title = textContains('恭喜您').findOne(5000)
370 | if (title) {
371 | title = title.parent()
372 | title.child(title.childCount() - 2).click()
373 | sleep(1000)
374 | }
375 | }
376 | return true
377 | }
378 |
379 | let startCoin = null
380 | let endCoin = null
381 |
382 | // 全局try catch,应对无法显示报错
383 | try {
384 | if (autoOpen) {
385 | openAndInto()
386 | console.log('等待活动页面加载')
387 | if (!findTextDescMatchesTimeout(/.*去使用奖励.*/, 8000)) {
388 | console.log('未能进入活动,请重新运行!')
389 | quit()
390 | }
391 | } else {
392 | alert('请关闭弹窗后立刻手动打开京东App进入活动页面', '限时30秒')
393 | console.log('请手动打开京东App进入活动')
394 | if (!findTextDescMatchesTimeout(/.*去使用奖励.*/, 30000)) {
395 | console.log('未能进入活动,请重新运行!')
396 | quit()
397 | }
398 | }
399 |
400 | console.log('成功进入活动,准备进行任务')
401 | sleep(5000)
402 |
403 | try {
404 | console.log('获取初始金币数量')
405 | startCoin = getCoin()
406 | console.log('当前共有' + startCoin + '金币')
407 | } catch (err) {
408 | console.log('获取金币失败,跳过', err)
409 | }
410 | if (openPage()) {
411 | // 完成所有任务的循环
412 | let taskListButton = className('android.view.View')
413 | .text('去抽奖 赢1分购品牌大礼')
414 | .findOne()
415 | .parent()
416 | .child(1)
417 | .children()
418 | for (let index = 0; index < taskListButton.length; index++) {
419 | taskListButton[index].click()
420 | console.log('打开抽奖页面')
421 |
422 | let tasks = findTasks()
423 | for (let i = 0; i < tasks.length; i++) {
424 | if (!autoJoin && tasks[i][0].match(/会员/)) {
425 | continue
426 | }
427 | if (!doTask(tasks[i])) {
428 | // console.log('任务失败,退出')
429 | // quit()
430 | console.log('任务出现失败,换一个抽奖进行')
431 | break
432 | }
433 | sleep(5000)
434 | }
435 | back()
436 | sleep(1000)
437 | taskListButton[index].click()
438 | sleep(5000)
439 | console.log('准备抽奖')
440 | if (!openBox()) {
441 | console.log('抽奖失败,退出')
442 | quit()
443 | }
444 | console.log('准备重新打开获取任务')
445 | sleep(2000)
446 | back()
447 | console.log('返回上一级')
448 | if (!findTextDescMatchesTimeout(/.*累计获得.*/, 8000)) {
449 | console.log('未能返回到活动主页,重试')
450 | back()
451 | if (!findTextDescMatchesTimeout(/.*去使用奖励.*/, 8000)) {
452 | console.log('未能返回到活动主页,退出')
453 | quit()
454 | }
455 | }
456 | console.log('任务完成,准备抽奖')
457 | console.log('准备进行下一次任务')
458 | sleep(2000)
459 | }
460 | } else {
461 | console.log('打开抽奖页失败,退出')
462 | quit()
463 | }
464 | back()
465 | try {
466 | console.log('获取当前金币数量')
467 | endCoin = getCoin()
468 | console.log('当前共有' + endCoin + '金币')
469 | console.log('本次任务共获得' + (endCoin - startCoin) + '金币')
470 | } catch (err) {
471 | console.log('获取金币失败,跳过', err)
472 | }
473 | } catch (err) {
474 | device.cancelKeepingAwake()
475 | if (
476 | err.toString() !=
477 | 'JavaException: com.stardust.autojs.runtime.exception.ScriptInterruptedException: null'
478 | ) {
479 | console.error(new Error().stack, err)
480 | startCoin && console.log('本次任务开始时有' + startCoin + '金币')
481 | }
482 | }
483 |
--------------------------------------------------------------------------------
/backup/tb2211.js:
--------------------------------------------------------------------------------
1 | if (!auto.service) {
2 | toast('无障碍服务未启动!退出!')
3 | exit()
4 | }
5 |
6 |
7 | // alert('请把手机放稳,不要摇晃!', '不然有时候会跳出合伙赢喵果,导致任务阻塞')
8 | function getSetting() {
9 | let indices = []
10 | autoOpen && indices.push(0)
11 | autoMute && indices.push(1)
12 | indices.push(2)
13 |
14 | let settings = dialogs.multiChoice('任务设置', ['自动打开淘宝进入活动。多开或任务列表无法自动打开时取消勾选(注意,分身运行淘宝大概率导致任务收益变为100)', '自动调整媒体音量为0。以免直播任务发出声音,首次选择需要修改系统设置权限', '此选项用于保证选择的处理,勿动!'], indices)
15 |
16 | if (settings.length == 0) {
17 | toast('取消选择,任务停止')
18 | exit()
19 | }
20 |
21 | if (settings.indexOf(0) != -1) {
22 | storage.put('autoOpen', true)
23 | autoOpen = true
24 | } else {
25 | storage.put('autoOpen', false)
26 | autoOpen = false
27 | }
28 | if (settings.indexOf(1) != -1) {
29 | storage.put('autoMute', true)
30 | autoMute = true
31 | } else {
32 | storage.put('autoMute', false)
33 | autoMute = false
34 | }
35 | }
36 | let storage = storages.create("tb_task");
37 | let autoOpen = storage.get('autoOpen', true)
38 | let autoMute = storage.get('autoMute', true)
39 | getSetting()
40 |
41 |
42 |
43 | if (autoMute) {
44 | try {
45 | device.setMusicVolume(0)
46 | toast('成功设置媒体音量为0')
47 | } catch (err) {
48 | alert('首先需要开启权限,请开启后再次运行脚本')
49 | exit()
50 | }
51 | }
52 |
53 | console.show()
54 | console.log('开始完成喵果任务...')
55 | console.log('按音量下键停止')
56 |
57 | device.keepScreenDim(60 * 60 * 1000)
58 |
59 | let startCoin;
60 |
61 | function registerKey() {
62 | try {
63 | events.observeKey()
64 | } catch (err) {
65 | console.log('监听音量键停止失败,应该是无障碍权限出错,请关闭软件后台任务重新运行。')
66 | console.log('如果还是不行可以重启手机尝试。')
67 | quit()
68 | }
69 | events.onKeyDown('volume_down', function (event) {
70 | console.log('喵果任务脚本停止了')
71 | console.log('请手动切换回主页面')
72 | if (startCoin) {
73 | console.log('本次任务开始时有', startCoin, '喵果')
74 | }
75 | device.cancelKeepingAwake()
76 | exit()
77 | })
78 | }
79 | threads.start(registerKey)
80 |
81 | // 全局try catch,应对无法显示报错
82 | try {
83 |
84 | // 自定义去取消亮屏的退出方法
85 | function quit() {
86 | device.cancelKeepingAwake()
87 | exit()
88 | }
89 |
90 | // 自定义一个findTimeout,find_f是原本的查询器 text('sss').find()
91 | function findTimeout(findF, timeout) {
92 | let c = 0
93 | while (c < timeout / 50) {
94 | let result = findF.find()
95 | if (result.nonEmpty()) return result
96 | sleep(50)
97 | c++
98 | }
99 | return null
100 | }
101 |
102 | // 自定义一个findTextDescMatchesTimeout
103 | function findTextDescMatchesTimeout(reg, timeout) {
104 | let c = 0
105 | while (c < timeout / 50) {
106 | let result = textMatches(reg).findOnce() || descMatches(reg).findOnce()
107 | if (result) return result
108 | sleep(50)
109 | c++
110 | }
111 | return null
112 | }
113 |
114 | // 查找任务按钮
115 | function findTask() {
116 | var jumpButtonFind = textMatches(/去浏览|去搜索|去完成|去签到|逛一逛|去逛逛|去观看|去参赛/) // 找进入任务的按钮,10秒
117 | var jumpButtons = findTimeout(jumpButtonFind, 10000)
118 |
119 | if (!jumpButtons) {
120 | return null
121 | }
122 |
123 | for (var i = 0; i < jumpButtons.length; i++) {
124 | var taskName, content
125 | try {
126 | taskName = jumpButtons[i].parent().child(0).child(0).text()
127 | content = jumpButtons[i].parent().child(0).child(1).child(0).text()
128 | } catch (err) {
129 | console.log(err)
130 | console.log('使用第二种方法尝试')
131 | try {
132 | content = jumpButtons[i].parent().child(0).child(1).text()
133 | console.log('成功,继续任务')
134 | }
135 | catch (err) {
136 | continue
137 | }
138 | }
139 | if (taskName) {
140 | if (taskName.match(/签到/)) {
141 | console.log('进行签到任务')
142 | sleep(1000)
143 | jumpButtons[i].click()
144 | sleep(8000)
145 | return findTask()
146 | }
147 | if (!(taskName.match(/淘金币|提醒|开通|续费|乐园|话费|斗地主|消消乐|流浪猫|开88|扔喵果|占领|邀请|登录|组队|参与|施肥|浇水|特价版|小鸡|消除|穿搭|森林|点淘|人生|我的淘宝|庄园|支付宝|点击人物/) || content.match(/小互动/))) {
148 | return [taskName, jumpButtons[i]]
149 | }
150 | }
151 | }
152 | return null
153 | }
154 |
155 | function liulan() {
156 | // if (textMatches(/.*浏览.*/).findOne(10000)) { // 等待浏览出现
157 | // let v = className('android.support.v7.widget.RecyclerView').findOnce() // 滑动
158 | // if (v) {
159 | // sleep(1000)
160 | // v.scrollForward()
161 | // }
162 | // }
163 |
164 | // textMatches(/.*浏览得奖励.*/).findOne(15000) // 等待开始
165 | let finish_c = 0
166 | let countdown = 0
167 | console.log('开始检测任务完成,部分控件无法检测,会在30秒后自动返回,请耐心等待。')
168 | while (finish_c < 250) { // 0.1 * 250 = 25 秒,防止死循环
169 | if (textMatches(/.*下拉浏览.*/).exists()) {
170 | console.log('进行模拟滑动')
171 | swipe(device.width / 2, device.height - 200, device.width / 2 + 20, device.height - 500, 2000)
172 | finish_c = finish_c + 10
173 | }
174 | let finish_reg = /.*任务.*?完成[\s\S]*?|.*失败.*|.*上限.*|.*开小差.*|.*喵果已发放[\s\S]*|.*下单可获得[\s\S]*/
175 | if (textMatches(finish_reg).exists() || descMatches(finish_reg).exists()) { // 等待已完成出现,有可能失败
176 | break
177 | }
178 | if (countdown == 0 && idContains('countdown').exists()) {
179 | countdown = 1
180 | break
181 | }
182 | if (textMatches(/.*休息会呗.*/).exists()) {
183 | alert('触发淘宝验证', '请手动验证后返回淘宝首页,重新执行任务')
184 | console.log('异常退出。')
185 | quit()
186 | }
187 | if (textContains('互动奖励').exists() ||
188 | descContains('互动奖励').exists()) {
189 | console.log('跳过互动任务')
190 | break
191 | }
192 | if (text('宝贝口袋').exists()) {
193 | let cart = text('购物车').findOnce()
194 | let x = cart.bounds().right
195 | let y = cart.bounds().top
196 | console.log('关闭直播购物车')
197 | click(x, y - 100)
198 | }
199 | if (finish_c > 100 && finish_c % 10 == 0) {
200 | console.log('滑动防止页面卡顿')
201 | swipe(device.width / 2, device.height - 200, device.width / 2 + 20, device.height - 500, 500)
202 | finish_c = finish_c + 5
203 | }
204 | sleep(100)
205 | finish_c++
206 | }
207 |
208 | if (countdown) {
209 | console.log('出现图片类型标识,使用新方法完成,18秒后视为任务完成,自动返回')
210 | sleep(18000)
211 | }
212 |
213 | if (finish_c > 249) {
214 | console.log('未检测到任务完成标识。返回。')
215 | // console.log('如果你认为这是一个bug请截图反馈。')
216 | // console.log('一般情况下,二次运行脚本即可。')
217 | // console.log('请手动切换回主页面')
218 | // device.cancelKeepingAwake()
219 | // quit()
220 | if (textContains('果仓等级').exists()) {
221 | console.log('店铺已主动返回,继续任务')
222 | return
223 | }
224 | back()
225 | sleep(1000)
226 | // TODO: 返回检测
227 | if (!textContains('果仓等级').findOne(8000)) {
228 | console.log('似乎没有返回,二次尝试')
229 | back()
230 | }
231 | return
232 | }
233 |
234 | console.log('任务结束,返回')
235 |
236 | back()
237 | sleep(1000)
238 | if (!textContains('果仓等级').findOne(5000)) {
239 | if (currentActivity() == 'com.taobao.tao.TBMainActivity') {
240 | console.log('返回到了主页,尝试重新进入任务')
241 | id('com.taobao.taobao:id/rv_main_container').findOnce().child(3).child(0).click()
242 | } else {
243 | console.log('似乎没有返回,二次尝试')
244 | back()
245 | }
246 | }
247 | }
248 |
249 | // 喵果数量
250 | function getCoin() {
251 | console.log('获取喵果数量')
252 | try {
253 | let e = textContains('当前喵果').findOnce()
254 | let num = e.text().match(/当前喵果(\d*)/)[1]
255 | console.log('当前共有', num, '喵果')
256 | return num
257 | } catch (err) {
258 | console.log(err)
259 | console.log('获取喵果数量错误,不影响脚本运行')
260 | return null
261 | }
262 | }
263 |
264 | try {
265 | if (autoOpen) {
266 | // 打开淘宝活动页面
267 | console.log('正在打开淘宝...')
268 | var url = 'pages.tmall.com/wow/z/hdwk/2022d11/singlegame?disableNav=YES'
269 |
270 | app.startActivity({
271 | action: "VIEW",
272 | data: "taobao://" + url
273 | })
274 | sleep(2000)
275 |
276 | console.log('等待页面加载...')
277 | textContains('去赚能量').findOne(20000)
278 | console.log('准备打开任务列表,第一次启动页面等待10秒加载')
279 | sleep(10000)
280 |
281 | let c = textContains('去赚能量').findOne(1000)
282 | if (c) {
283 | console.log('使用默认方法尝试打开任务列表')
284 | c.click()
285 | sleep(1000)
286 | c.click()
287 | console.log('已点击,未能打开建议手动点击一下任务列表。此问题并非bug,和网络以及设备性能有关。')
288 | console.log('检测任务列表,准备进行二次尝试')
289 | } else {
290 | throw '无法找到任务列表入口'
291 | }
292 | if (!textContains('果仓等级').findOne(8000)) {
293 | console.log('默认方式打开失败,二次尝试')
294 | console.log('首先检测弹窗')
295 | for (let i = 0; i < 2 && text('关闭').findOne(2000); i++) { // 关闭弹窗
296 | console.log('检测到弹窗,关闭')
297 | click('关闭')
298 | sleep(2000)
299 | }
300 | console.log('已试图自动关闭弹窗。有未能自动关闭的弹窗请手动关闭')
301 | sleep(5000)
302 | // let right = c.bounds().right
303 | // let left = c.bounds().left
304 | // let top = c.bounds().top
305 | // let bottom = c.bounds().bottom
306 | // click(random(right,left), random(top, bottom))
307 | click(c.bounds().centerX(), c.bounds().centerY())
308 | console.log('已点击,等待任务列表出现')
309 | if (!textContains('果仓等级').findOne(8000)) {
310 | throw '无法打开任务列表'
311 | }
312 | }
313 | } else {
314 | console.log('请在30秒内打开淘宝活动页,并打开任务列表')
315 | if (textContains('果仓等级').findOne(30000)) {
316 | console.log('已打开,继续任务')
317 | } else {
318 | console.log('未能检测到任务列表,退出')
319 | quit()
320 | }
321 | }
322 | console.log('准备搜索任务')
323 | sleep(2000)
324 | } catch (err) {
325 | console.log(err)
326 | console.log('无法进入任务列表,如果你认为这是bug,请截图反馈。注意!1级没法做任务,请先升到2级!')
327 | quit()
328 | }
329 |
330 | startCoin = getCoin()
331 |
332 | while (true) {
333 | console.log('寻找任务入口...')
334 | var jumpButton = findTask()
335 |
336 | if (jumpButton == null) {
337 | // 没有任务之后领取奖励
338 | var awardButtonFind = textMatches(/立即领取|领取奖励/)
339 | var awardButtons = findTimeout(awardButtonFind, 10000)
340 |
341 | if (awardButtons) {
342 | for (var i = 0; i < awardButtons.length; i++) {
343 | console.log('领取累计任务奖励')
344 | awardButtons[i].click()
345 | console.log('等待5秒再次领取...')
346 | sleep(5000)
347 | }
348 | }
349 |
350 | const endCoin = getCoin()
351 |
352 | console.log('没找到合适的任务。也许任务已经全部做完了。退出。互动任务不会自动完成。')
353 | console.log('请手动切换回主页面')
354 | if (startCoin && endCoin) {
355 | console.log('本次任务共获得', (endCoin - startCoin), '喵果')
356 | }
357 | alert('任务已完成', '别忘了在脚本主页领取双十一红包!互动任务需要手动完成。')
358 | quit()
359 | }
360 |
361 | if (jumpButton[0].match('去浏览店铺领能量')) {
362 | console.log('进行浏览店铺任务')
363 | jumpButton[1].click()
364 | while (!textContains('任务完成').exists()) {
365 | console.log('进入店铺浏览')
366 | text('逛店最多').findOne(15000).parent().click()
367 | liulan()
368 | sleep(2000)
369 | }
370 | back()
371 | } else if (jumpButton[0].match(/.*玩游戏.*|.*浏览餐饮卡券.*|.*加油赛.*|.*赚星星.*/)) {
372 | console.log('进行' + jumpButton[0] + '任务,10秒后返回')
373 | jumpButton[1].click()
374 | sleep(10000)
375 | back()
376 | } else if (jumpButton[0].match(/领现金/)) {
377 | console.log('进行' + jumpButton[0] + '任务')
378 | jumpButton[1].click()
379 | let into = text('打开链接').findOne(10000)
380 | if (!into) {
381 | console.log('无法找到进入领现金的按钮!')
382 | quit()
383 | }
384 | into.click()
385 | liulan()
386 | } else {
387 | console.log('进行' + jumpButton[0] + '任务')
388 | jumpButton[1].click()
389 | liulan()
390 | }
391 |
392 | console.log('等待页面刷新...')
393 | sleep(2000)
394 | }
395 | } catch (err) {
396 | device.cancelKeepingAwake()
397 | if (err.toString() != 'JavaException: com.stardust.autojs.runtime.exception.ScriptInterruptedException: null') {
398 | console.error(err)
399 | }
400 | }
401 |
--------------------------------------------------------------------------------
/backup/tb618.js:
--------------------------------------------------------------------------------
1 | function getSetting() {
2 | let indices = []
3 | autoOpen && indices.push(0)
4 | autoMute && indices.push(1)
5 |
6 | let settings = dialogs.multiChoice(
7 | '任务设置',
8 | [
9 | '自动打开淘宝进入活动。多开或任务列表无法自动打开时取消勾选(注意,分身运行淘宝大概率导致任务收益变为100)',
10 | '自动调整媒体音量为0。以免直播任务发出声音,首次选择需要修改系统设置权限',
11 | ],
12 | indices
13 | )
14 |
15 | if (settings.length == 0) {
16 | toast('取消选择,任务停止')
17 | exit()
18 | }
19 |
20 | if (settings.indexOf(0) != -1) {
21 | storage.put('autoOpen', true)
22 | autoOpen = true
23 | } else {
24 | storage.put('autoOpen', false)
25 | autoOpen = false
26 | }
27 | if (settings.indexOf(1) != -1) {
28 | storage.put('autoMute', true)
29 | autoMute = true
30 | } else {
31 | storage.put('autoMute', false)
32 | autoMute = false
33 | }
34 | }
35 |
36 | let storage = storages.create('tb_task')
37 | let autoOpen = storage.get('autoOpen', true)
38 | let autoMute = storage.get('autoMute', true)
39 | getSetting()
40 |
41 | if (autoMute) {
42 | try {
43 | device.setMusicVolume(0)
44 | toast('成功设置媒体音量为0')
45 | } catch (err) {
46 | alert('首先需要开启权限,请开启后再次运行脚本')
47 | exit()
48 | }
49 | }
50 |
51 | console.show()
52 | console.log('开始完成喵糖任务...')
53 | console.log('按音量下键停止')
54 |
55 | device.keepScreenDim(60 * 60 * 1000)
56 |
57 | function registerKey() {
58 | try {
59 | events.observeKey()
60 | } catch (err) {
61 | console.log(
62 | '监听音量键停止失败,应该是无障碍权限出错,请关闭软件后台任务重新运行。'
63 | )
64 | console.log('如果还是不行可以重启手机尝试。')
65 | quit()
66 | }
67 | events.onKeyDown('volume_down', function (event) {
68 | console.log('喵币任务脚本停止了')
69 | console.log('请手动切换回主页面')
70 | device.cancelKeepingAwake()
71 | exit()
72 | })
73 | }
74 | threads.start(registerKey)
75 |
76 | // 全局try catch,应对无法显示报错
77 | try {
78 | // 自定义去取消亮屏的退出方法
79 | function quit() {
80 | device.cancelKeepingAwake()
81 | exit()
82 | }
83 |
84 | // 自定义一个findTimeout,find_f是原本的查询器 text('sss').find()
85 | function findTimeout(findF, timeout) {
86 | let c = 0
87 | while (c < timeout / 50) {
88 | let result = findF.find()
89 | if (result.nonEmpty()) return result
90 | sleep(50)
91 | c++
92 | }
93 | return null
94 | }
95 |
96 | // 自定义一个findTextDescMatchesTimeout
97 | function findTextDescMatchesTimeout(reg, timeout) {
98 | let c = 0
99 | while (c < timeout / 50) {
100 | let result = textMatches(reg).findOnce() || descMatches(reg).findOnce()
101 | if (result) return result
102 | sleep(50)
103 | c++
104 | }
105 | return null
106 | }
107 |
108 | // 查找任务按钮
109 | function findTask() {
110 | var jumpButtonFind = textMatches(
111 | /去浏览|去搜索|去完成|去签到|逛一逛|去逛逛|去观看|去参赛/
112 | ) // 找进入任务的按钮,10秒
113 | var jumpButtons = findTimeout(jumpButtonFind, 10000)
114 |
115 | if (!jumpButtons) {
116 | return null
117 | }
118 |
119 | for (var i = 0; i < jumpButtons.length; i++) {
120 | var taskName, content
121 | try {
122 | taskName = jumpButtons[i].parent().child(0).child(0).text()
123 | content = jumpButtons[i].parent().child(0).child(1).child(0).text()
124 | } catch (err) {
125 | console.log(err)
126 | continue
127 | }
128 | if (taskName) {
129 | if (taskName.match(/签到领/)) {
130 | console.log('进行签到任务')
131 | sleep(1000)
132 | jumpButtons[i].click()
133 | sleep(8000)
134 | return findTask()
135 | }
136 | if (
137 | !(
138 | taskName.match(
139 | /淘金币|提醒|话费|斗地主|消消乐|流浪猫|开88|扔喵糖|占领|邀请|登录|组队|参与|施肥|浇水|特价版|小鸡|消除|穿搭|森林|点淘|人生|我的淘宝|庄园/
140 | ) || content.match(/小互动/)
141 | )
142 | ) {
143 | return [taskName, jumpButtons[i]]
144 | }
145 | }
146 | }
147 | return null
148 | }
149 |
150 | function liulan() {
151 | // if (textMatches(/.*浏览.*/).findOne(10000)) { // 等待浏览出现
152 | // let v = className('android.support.v7.widget.RecyclerView').findOnce() // 滑动
153 | // if (v) {
154 | // sleep(1000)
155 | // v.scrollForward()
156 | // }
157 | // }
158 |
159 | // textMatches(/.*浏览得奖励.*/).findOne(15000) // 等待开始
160 | sleep(5000)
161 | let finish_c = 0
162 | while (finish_c < 50) {
163 | // 0.5 * 50 = 25 秒,防止死循环
164 | let finish_reg =
165 | /.*任务已完成[\s\S]*|.*失败.*|.*上限.*|.*开小差.*|.*喵币已发放[\s\S]*/
166 | if (
167 | textMatches(finish_reg).exists() ||
168 | descMatches(finish_reg).exists()
169 | ) {
170 | // 等待已完成出现,有可能失败
171 | break
172 | }
173 | if (textMatches(/.*休息会呗.*/).exists()) {
174 | alert('触发淘宝验证', '请手动验证后返回淘宝首页,重新执行任务')
175 | console.log('异常退出。')
176 | quit()
177 | }
178 | if (
179 | textContains('互动奖励').exists() ||
180 | descContains('互动奖励').exists()
181 | ) {
182 | console.log('跳过互动任务')
183 | break
184 | }
185 | sleep(500)
186 | finish_c++
187 | }
188 |
189 | if (finish_c > 49) {
190 | console.log('未检测到任务完成标识。返回。')
191 | // console.log('如果你认为这是一个bug请截图反馈。')
192 | // console.log('一般情况下,二次运行脚本即可。')
193 | // console.log('请手动切换回主页面')
194 | // device.cancelKeepingAwake()
195 | // quit()
196 | back()
197 | sleep(1000)
198 | // TODO: 返回检测
199 | if (!textContains('当前进度').findOne(5000)) {
200 | console.log('似乎没有返回,二次尝试')
201 | back()
202 | }
203 | return
204 | }
205 |
206 | console.log('任务完成,返回')
207 |
208 | back()
209 | sleep(1000)
210 | if (!textContains('当前进度').findOne(5000)) {
211 | if (currentActivity() == 'com.taobao.tao.TBMainActivity') {
212 | console.log('返回到了主页,尝试重新进入任务')
213 | id('com.taobao.taobao:id/rv_main_container')
214 | .findOnce()
215 | .child(3)
216 | .child(0)
217 | .click()
218 | } else {
219 | console.log('似乎没有返回,二次尝试')
220 | back()
221 | }
222 | }
223 | }
224 |
225 | // 打开淘宝活动页面
226 | console.log('正在打开淘宝...')
227 | var url = 'pages.tmall.com/wow/z/hdwk/20220618/gamehome?disableNav=YES'
228 |
229 | app.startActivity({
230 | action: 'VIEW',
231 | data: 'taobao://' + url,
232 | })
233 | sleep(2000)
234 |
235 | console.log('等待页面加载...')
236 |
237 | try {
238 | textMatches(/领喵币/).findOne(20000)
239 | console.log('准备打开任务列表')
240 | sleep(2000)
241 | let c = findTextDescMatchesTimeout(/领喵币/, 1000)
242 | if (c) {
243 | console.log('使用默认方法尝试打开任务列表')
244 | c.click()
245 | } else {
246 | throw '无法找到任务列表入口'
247 | }
248 | if (!textContains('当前进度').findOne(8000)) {
249 | console.log('默认方式打开失败,二次尝试')
250 | console.log('首先检测弹窗')
251 | for (let i = 0; i < 2 && text('关闭').findOne(2000); i++) {
252 | // 关闭弹窗
253 | console.log('检测到弹窗,关闭')
254 | click('关闭')
255 | sleep(2000)
256 | }
257 | console.log('出现未能自动关闭的弹窗请手动关闭')
258 | sleep(2000)
259 | // let right = c.bounds().right
260 | // let left = c.bounds().left
261 | // let top = c.bounds().top
262 | // let bottom = c.bounds().bottom
263 | // click(random(right,left), random(top, bottom))
264 | click(c.bounds().centerX(), c.bounds().centerY())
265 | console.log('已点击,等待任务列表出现')
266 | if (!textContains('当前进度').findOne(8000)) {
267 | throw '无法打开任务列表'
268 | }
269 | }
270 | console.log('准备搜索任务')
271 | sleep(2000)
272 | } catch (err) {
273 | console.log(err)
274 | console.log('无法进入任务列表,如果你认为这是bug,请截图反馈')
275 | quit()
276 | }
277 |
278 | while (true) {
279 | console.log('寻找任务入口...')
280 | var jumpButton = findTask()
281 |
282 | if (jumpButton == null) {
283 | // 没有任务之后领取奖励
284 | var awardButtonFind = textMatches(/立即领取|领取奖励/)
285 | var awardButtons = findTimeout(awardButtonFind, 10000)
286 |
287 | if (awardButtons) {
288 | for (var i = 0; i < awardButtons.length; i++) {
289 | console.log('领取累计任务奖励')
290 | awardButtons[i].click()
291 | console.log('等待5秒再次领取...')
292 | sleep(5000)
293 | }
294 | }
295 |
296 | console.log(
297 | '没找到合适的任务。也许任务已经全部做完了。退出。互动任务不会自动完成。'
298 | )
299 | console.log('请手动切换回主页面')
300 | alert('任务已完成', '别忘了在脚本主页领取618红包!互动任务需要手动完成。')
301 | quit()
302 | }
303 |
304 | if (jumpButton[0].match('去浏览店铺领能量')) {
305 | console.log('进行浏览店铺任务')
306 | jumpButton[1].click()
307 | while (!textContains('任务完成').exists()) {
308 | console.log('进入店铺浏览')
309 | text('逛店最多').findOne(15000).parent().click()
310 | liulan()
311 | sleep(2000)
312 | }
313 | back()
314 | } else if (
315 | jumpButton[0].match(/.*玩游戏.*|.*浏览餐饮卡券.*|.*加油赛.*|.*赚星星.*/)
316 | ) {
317 | console.log('进行' + jumpButton[0] + '任务,10秒后返回')
318 | jumpButton[1].click()
319 | sleep(10000)
320 | back()
321 | } else if (jumpButton[0].match(/领现金/)) {
322 | console.log('进行' + jumpButton[0] + '任务')
323 | jumpButton[1].click()
324 | let into = text('打开链接').findOne(10000)
325 | if (!into) {
326 | console.log('无法找到进入领现金的按钮!')
327 | quit()
328 | }
329 | into.click()
330 | liulan()
331 | } else {
332 | console.log('进行' + jumpButton[0] + '任务')
333 | jumpButton[1].click()
334 | liulan()
335 | }
336 |
337 | console.log('等待页面刷新...')
338 | sleep(2000)
339 | }
340 | } catch (err) {
341 | device.cancelKeepingAwake()
342 | if (
343 | err.toString() !=
344 | 'JavaException: com.stardust.autojs.runtime.exception.ScriptInterruptedException: null'
345 | ) {
346 | console.error(err)
347 | }
348 | }
349 |
--------------------------------------------------------------------------------
/backup/tb_hc.js:
--------------------------------------------------------------------------------
1 | const VERSION = 'V7'
2 |
3 | if (!auto.service) {
4 | toast('无障碍服务未启动!退出!')
5 | exit()
6 | }
7 | function getSetting() {
8 | let indices = []
9 | autoOpen && indices.push(0)
10 | autoMute && indices.push(1)
11 | indices.push(2)
12 |
13 | let settings = dialogs.multiChoice('任务设置', ['自动打开淘宝进入活动。多开或任务列表无法自动打开时取消勾选(注意,分身运行淘宝大概率导致任务收益变为100)', '自动调整媒体音量为0。以免直播任务发出声音,首次选择需要修改系统设置权限', '此选项用于保证选择的处理,勿动!'], indices)
14 |
15 | if (settings.length == 0) {
16 | toast('取消选择,任务停止')
17 | exit()
18 | }
19 |
20 | if (settings.indexOf(0) != -1) {
21 | storage.put('autoOpen', true)
22 | autoOpen = true
23 | } else {
24 | storage.put('autoOpen', false)
25 | autoOpen = false
26 | }
27 | if (settings.indexOf(1) != -1) {
28 | storage.put('autoMute', true)
29 | autoMute = true
30 | } else {
31 | storage.put('autoMute', false)
32 | autoMute = false
33 | }
34 | }
35 |
36 | let storage = storages.create("tb_task");
37 | let autoOpen = storage.get('autoOpen', true)
38 | let autoMute = storage.get('autoMute', true)
39 | getSetting()
40 |
41 | if (autoMute) {
42 | try {
43 | device.setMusicVolume(0)
44 | toast('成功设置媒体音量为0')
45 | } catch (err) {
46 | alert('首先需要开启权限,请开启后再次运行脚本')
47 | exit()
48 | }
49 | }
50 |
51 | console.show()
52 | console.log('开始完成能量任务...')
53 | console.log('按音量下键停止')
54 |
55 | device.keepScreenDim(60 * 60 * 1000)
56 |
57 | function registerKey() {
58 | try {
59 | events.observeKey()
60 | } catch (err) {
61 | console.log('监听音量键停止失败,应该是无障碍权限出错,请关闭软件后台任务重新运行。')
62 | console.log('如果还是不行可以重启手机尝试。')
63 | quit()
64 | }
65 | events.onKeyDown('volume_down', function (event) {
66 | console.log('喵币任务脚本停止了')
67 | console.log('请手动切换回主页面')
68 | device.cancelKeepingAwake()
69 | exit()
70 | })
71 | }
72 | threads.start(registerKey)
73 |
74 | // 全局try catch,应对无法显示报错
75 | try {
76 |
77 | // 自定义去取消亮屏的退出方法
78 | function quit() {
79 | device.cancelKeepingAwake()
80 | exit()
81 | }
82 |
83 | // 自定义一个findTimeout,find_f是原本的查询器 text('sss').find()
84 | function findTimeout(findF, timeout) {
85 | let c = 0
86 | while (c < timeout / 50) {
87 | let result = findF.find()
88 | if (result.nonEmpty()) return result
89 | sleep(50)
90 | c++
91 | }
92 | return null
93 | }
94 |
95 | // 自定义一个findTextDescMatchesTimeout
96 | function findTextDescMatchesTimeout(reg, timeout) {
97 | let c = 0
98 | while (c < timeout / 50) {
99 | let result = textMatches(reg).findOnce() || descMatches(reg).findOnce()
100 | if (result) return result
101 | sleep(50)
102 | c++
103 | }
104 | return null
105 | }
106 |
107 | // 打开任务列表
108 | function openTaskList() {
109 | let c = idContains('node_2_icon').findOne(5000)
110 | if (c) {
111 | console.log('使用默认方法尝试打开任务列表')
112 | c.click()
113 | } else {
114 | throw '无法找到任务列表入口'
115 | }
116 | if (!textContains('task_detail').findOne(8000)) {
117 | console.log('默认方式打开失败,二次尝试')
118 | console.log('首先检测弹窗')
119 | try {
120 | idContains('J_wfdlgwrap_5').findOnce().child(0).click()
121 | sleep(1000)
122 | } catch (err) {
123 | console.log(err)
124 | console.log('领红包弹窗关闭失败。此问题不影响运行')
125 | }
126 | try {
127 | idContains('CLOSE').findOnce().click()
128 | sleep(1000)
129 | } catch (err) {
130 | console.log(err)
131 | console.log('其他弹窗关闭失败。此问题不影响运行')
132 | }
133 | console.log('出现未能自动关闭的弹窗请手动关闭')
134 | sleep(2000)
135 | // let right = c.bounds().right
136 | // let left = c.bounds().left
137 | // let top = c.bounds().top
138 | // let bottom = c.bounds().bottom
139 | // click(random(right,left), random(top, bottom))
140 | click(c.bounds().centerX(), c.bounds().centerY())
141 | console.log('已点击,等待任务列表出现')
142 | if (!idContains('node_2_icon').findOne(8000)) {
143 | throw '无法打开任务列表'
144 | }
145 | }
146 | }
147 |
148 | // 查找任务按钮
149 | function findTask() {
150 | var jumpButtonFind = textMatches(/去浏览|去完成/) // 找进入任务的按钮,10秒
151 | var jumpButtons = findTimeout(jumpButtonFind, 10000)
152 |
153 | if (!jumpButtons) {
154 | return null
155 | }
156 |
157 | for (var i = 0; i < jumpButtons.length; i++) {
158 | var taskName, content
159 | try {
160 | taskName = jumpButtons[i].parent().child(1).text()
161 | content = jumpButtons[i].parent().child(2).child(0).text()
162 | } catch (err) {
163 | console.log(err)
164 | continue
165 | }
166 | if (taskName) {
167 | // if (taskName.match(/签到领/)) {
168 | // console.log('进行签到任务')
169 | // sleep(1000)
170 | // jumpButtons[i].click()
171 | // sleep(8000)
172 | // return findTask()
173 | // }
174 | // if (!(taskName.match(/淘金币|提醒|话费|斗地主|消消乐|流浪猫|开88|扔喵糖|占领|邀请|登录|组队|参与|施肥|浇水|特价版|小鸡|消除|穿搭|森林|点淘|人生|我的淘宝|庄园/) || content.match(/小互动/))) {
175 | // return [taskName, jumpButtons[i]]
176 | // }
177 | return [taskName, jumpButtons[i]]
178 | }
179 | }
180 | return null
181 | }
182 |
183 | function liulan() {
184 | // if (textMatches(/.*浏览.*/).findOne(10000)) { // 等待浏览出现
185 | // let v = className('android.support.v7.widget.RecyclerView').findOnce() // 滑动
186 | // if (v) {
187 | // sleep(1000)
188 | // v.scrollForward()
189 | // }
190 | // }
191 |
192 | // textMatches(/.*浏览得奖励.*/).findOne(15000) // 等待开始
193 | let finish_c = 0
194 | while (finish_c < 50) { // 0.5 * 50 = 25 秒,防止死循环
195 | if (textMatches(/.*下拉浏览.*/).exists() || textContains('下滑').exists()) {
196 | console.log('进行模拟滑动')
197 | swipe(device.width / 2, device.height - 200, device.width / 2 + 20, device.height - 500, 2000)
198 | }
199 | let finish_reg = /.*任务已完成[\s\S]*|.*失败.*|.*上限.*|.*开小差.*/
200 | if (textMatches(finish_reg).exists() || descMatches(finish_reg).exists()) { // 等待已完成出现,有可能失败
201 | break
202 | }
203 | if (textMatches(/.*休息会呗.*/).exists()) {
204 | alert('触发淘宝验证', '请手动验证后返回淘宝首页,重新执行任务')
205 | console.log('异常退出。')
206 | quit()
207 | }
208 | if (textContains('互动奖励').exists() ||
209 | descContains('互动奖励').exists()) {
210 | console.log('跳过互动任务')
211 | break
212 | }
213 | sleep(500)
214 | finish_c++
215 | }
216 |
217 | if (finish_c > 49) {
218 | console.log('未检测到任务完成标识。返回。')
219 | return false
220 | }
221 |
222 | console.log('任务完成')
223 | return true
224 | }
225 |
226 | function backToList() {
227 | console.log('返回上级')
228 | back()
229 | sleep(1000)
230 | if (!idContains('node_2_icon').findOne(5000)) {
231 | console.log('似乎没有返回,二次尝试')
232 | back()
233 | }
234 | sleep(1000)
235 | }
236 |
237 | if (autoOpen) {
238 | // 打开淘宝活动页面
239 | console.log('正在打开淘宝...')
240 | var url = 'm.tb.cn/h.U9Wkkoc'
241 |
242 | app.startActivity({
243 | action: "VIEW",
244 | data: "taobao://" + url
245 | })
246 | sleep(2000)
247 |
248 | console.log('等待页面加载...')
249 | } else {
250 | console.log('请在30秒内打开淘宝做任务赢红包活动页 08¥ CZ0001 rqkPd4bbrVA¥ https://m.tb.cn/h.U9Wkkoc')
251 | }
252 | if (!idContains('node_2_icon').findOne(30000)) {
253 | console.log('未能检测到任务页,退出')
254 | quit()
255 | }
256 |
257 | console.log('已打开活动,准备搜索任务')
258 | sleep(2000)
259 |
260 | console.log('首先关闭弹窗')
261 | try {
262 | idContains('J_wfdlgwrap_5').findOnce().child(0).click()
263 | sleep(5000)
264 | console.log('领红包弹窗已关闭')
265 | } catch (err) {
266 | console.log(err)
267 | console.log('领红包弹窗关闭失败。此问题不影响运行')
268 | }
269 | try {
270 | idContains('CLOSE').findOnce().click()
271 | sleep(2000)
272 | console.log('其他弹窗已关闭')
273 | } catch (err) {
274 | console.log(err)
275 | console.log('其他弹窗关闭失败。此问题不影响运行')
276 | }
277 | console.log('检测任务列表是否打开')
278 | if (textContains('task_detail').findOne(5000)) {
279 | console.log('先关闭列表')
280 | idContains('close_btn').findOnce().click()
281 | sleep(2000)
282 | }
283 |
284 | while (true) {
285 | console.log('准备打开任务列表')
286 | sleep(2000)
287 | openTaskList()
288 | console.log('寻找任务入口...')
289 | var jumpButton = findTask()
290 |
291 | if (jumpButton == null) {
292 | console.log('没找到合适的任务。也许任务已经全部做完了。退出。互动任务不会自动完成。')
293 | console.log('请手动切换回主页面')
294 | alert('任务已完成', '别忘了在脚本主页领取双11红包!互动任务需要手动完成。')
295 | quit()
296 | }
297 |
298 | console.log('进行' + jumpButton[0] + '任务')
299 | sleep(2000)
300 |
301 | if (jumpButton[0].match(/商品/)) {
302 | jumpButton[1].click()
303 | sleep(2000)
304 | let count = jumpButton[0].match(/浏览(\d*)个/)[1]
305 | console.log('等待页面')
306 | if (!textContains('超红精选热卖').findOne(8000)) {
307 | throw '商品页面未加载'
308 | }
309 | try {
310 | count -= idContains('J_wf_node_2_time').findOne(5000).text()
311 | } catch(err) {
312 | console.log('获取数量失败,使用默认值', err)
313 | }
314 | console.log('点击', count, '个商品')
315 | let buttons = textContains('q75').find()
316 | if (!buttons) {
317 | throw '无法找到商品,任务失败'
318 | }
319 | for (let i = 0; i < 10 && count > buttons.length; i++) {
320 | console.log('商品数量不足,向下翻页', buttons.length)
321 | scrollDown()
322 | sleep(2000)
323 | scrollDown()
324 | sleep(2000)
325 | buttons = textContains('q75').find()
326 | console.log(buttons.length)
327 | }
328 | if (count > buttons.length) {
329 | console.log('商品数量不足,分次完成')
330 | count = buttons.length
331 | }
332 |
333 | for (let i = 0; i < count; i++) {
334 | console.log('点击第', i + 1, '个')
335 | sleep(2000)
336 | buttons[i].click()
337 | console.log('等待加载')
338 | if (findTextDescMatchesTimeout(/加入购物车.*|粉丝福利购/,10000) || currentActivity() == 'com.taobao.android.detail.wrapper.activity.DetailActivity') {
339 | console.log('商品打开成功,返回')
340 | back()
341 | if (!textContains('超红精选热卖').findOne(10000)) {
342 | console.log('似乎没有返回,二次尝试')
343 | back()
344 | }
345 | } else {
346 | throw '商品页未能加载'
347 | }
348 | }
349 | // sleep(1000)
350 | backToList()
351 | } else if (jumpButton[0].match(/搜索/)) {
352 | jumpButton[1].click()
353 | let listView = className('android.widget.ListView').findOne(8000).child(0)
354 | if (listView.childCount() == 1) {
355 | listView.child(0).click()
356 | } else {
357 | listView.child(1).click()
358 | }
359 | liulan()
360 | sleep(1000)
361 | back()
362 | backToList()
363 | } else if (jumpButton[0].match(/为你推荐|主会场/)) {
364 | jumpButton[1].click()
365 | liulan()
366 | } else {
367 | jumpButton[1].click()
368 | liulan()
369 | // sleep(1000)
370 | // back()
371 | backToList()
372 | }
373 |
374 | console.log('等待页面刷新...')
375 | sleep(2000)
376 | }
377 | } catch (err) {
378 | device.cancelKeepingAwake()
379 | if (err.toString() != 'JavaException: com.stardust.autojs.runtime.exception.ScriptInterruptedException: null') {
380 | console.error(err)
381 | }
382 | }
--------------------------------------------------------------------------------
/backup/zns_zs.js:
--------------------------------------------------------------------------------
1 | if (!auto.service) {
2 | toast('无障碍服务未启动!退出!')
3 | exit()
4 | }
5 | console.show()
6 |
7 | function getSetting() {
8 | let indices = []
9 | autoOpen && indices.push(0)
10 | autoMute && indices.push(1)
11 | autoJoin && indices.push(2)
12 | indices.push(3)
13 |
14 | let settings = dialogs.multiChoice('任务设置', ['自动打开京东进入活动。多开或任务列表无法自动打开时取消勾选', '自动调整媒体音量为0。以免直播任务发出声音,首次选择需要修改系统设置权限', '自动完成入会任务。京东将授权手机号给商家,日后可能会收到推广短信', '此选项用于保证选择的处理,勿动!'], indices)
15 |
16 | if (settings.length == 0) {
17 | toast('取消选择,任务停止')
18 | exit()
19 | }
20 |
21 | if (settings.indexOf(0) != -1) {
22 | storage.put('autoOpen', true)
23 | autoOpen = true
24 | } else {
25 | storage.put('autoOpen', false)
26 | autoOpen = false
27 | }
28 | if (settings.indexOf(1) != -1) {
29 | storage.put('autoMute', true)
30 | autoMute = true
31 | } else {
32 | storage.put('autoMute', false)
33 | autoMute = false
34 | }
35 | if (settings.indexOf(2) != -1) {
36 | storage.put('autoJoin', true)
37 | autoJoin = true
38 | } else {
39 | storage.put('autoJoin', false)
40 | autoJoin = false
41 | }
42 | }
43 |
44 |
45 | let storage = storages.create('jd_task')
46 | let autoOpen = storage.get('autoOpen', true)
47 | let autoMute = storage.get('autoMute', true)
48 | let autoJoin = storage.get('autoJoin', true)
49 | getSetting()
50 |
51 | if (autoMute) {
52 | try {
53 | device.setMusicVolume(0)
54 | toast('成功设置媒体音量为0')
55 | } catch (err) {
56 | alert('首先需要开启修复音量权限,请开启后再次运行脚本')
57 | exit()
58 | }
59 | }
60 |
61 | console.log('开始完成京东任务...')
62 | console.log('按音量下键停止')
63 |
64 | device.keepScreenDim(30 * 60 * 1000) // 防止息屏30分钟
65 |
66 | // 自定义取消亮屏的退出方法
67 | function quit() {
68 | device.cancelKeepingAwake()
69 | exit()
70 | }
71 |
72 | // 监听音量下键
73 | function registerKey() {
74 | try {
75 | events.observeKey()
76 | } catch (err) {
77 | console.log('监听音量键停止失败,应该是无障碍权限出错,请关闭软件后台任务重新运行。')
78 | console.log('如果还是不行可以重启手机尝试。')
79 | quit()
80 | }
81 | events.onKeyDown('volume_down', function (event) {
82 | console.log('京东任务脚本停止了')
83 | console.log('请手动切换回主页面')
84 | startCoin && console.log('本次任务开始时有' + startCoin + '金币')
85 | quit()
86 | })
87 | }
88 | threads.start(registerKey)
89 |
90 | // 自定义一个findTextDescMatchesTimeout
91 | function findTextDescMatchesTimeout(reg, timeout) {
92 | let c = 0
93 | while (c < timeout / 50) {
94 | let result = textMatches(reg).findOnce() || descMatches(reg).findOnce()
95 | if (result) return result
96 | sleep(50)
97 | c++
98 | }
99 | return null
100 | }
101 |
102 | // 打开京东进入活动
103 | function openAndInto() {
104 | console.log('正在打开京东App...')
105 | if (!launch('com.jingdong.app.mall')) {
106 | console.log('可能未安装京东App')
107 | }
108 |
109 | sleep(2000)
110 | console.log('进入活动页面')
111 |
112 | app.startActivity({
113 | action: "VIEW",
114 | data: 'openApp.jdMobile://virtual?params={"category":"jump","action":"to","des":"m","sourceValue":"JSHOP_SOURCE_VALUE","sourceType":"JSHOP_SOURCE_TYPE","url":"https://u.jd.com/mMr3ipV","M_sourceFrom":"mxz","msf_type":"auto"}'
115 | })
116 | }
117 |
118 | // 获取金币数量
119 | function getCoin() {
120 | let anchor = textMatches(/\d*个/).findOne(5000)
121 | if (!anchor) {
122 | console.log('找不到消耗控件')
123 | return false
124 | }
125 | let coin = anchor.text()
126 | if (coin) {
127 | return parseInt(coin)
128 | } else {
129 | return false
130 | }
131 | }
132 |
133 | // 打开任务列表
134 | function openTaskList() {
135 | console.log('打开任务列表')
136 | let anchor = text('记录').findOne(20000)
137 | if (!anchor) {
138 | console.log('未能定位任务列表,请关闭京东重新运行!')
139 | quit()
140 | }
141 | if (anchor.indexInParent() < 3) {
142 | anchor = anchor.parent()
143 | }
144 |
145 | let taskListButton
146 | let tmp = anchor.parent().children()
147 | for (let i = 0; i < tmp.length; i++) {
148 | if (tmp[i].bounds().centerX() == anchor.bounds().centerX() && tmp[i].bounds().centerY() == anchor.bounds().centerY()) {
149 | console.log(1)
150 | taskListButton = tmp[i + 1].child(1)
151 | if (!taskListButton.clickable()) {
152 | try {
153 | taskListButton = taskListButton.child(0)
154 | } catch (err) {
155 | console.log('不可点击')
156 | taskListButton = null
157 | }
158 | }
159 | break
160 | }
161 | }
162 |
163 | if (!taskListButton || !taskListButton.clickable()) {
164 | console.log('无法找到任务列表控件,请参照软件内的说明更换web内核。')
165 | quit()
166 | }
167 | taskListButton.click()
168 | console.log('等待任务列表')
169 | if (!findTextDescMatchesTimeout(/累计任务奖励/, 5000)) {
170 | console.log('似乎没能打开任务列表,重试')
171 | taskListButton.click()
172 | }
173 |
174 | if (!findTextDescMatchesTimeout(/累计任务奖励/, 10000)) {
175 | console.log('似乎没能打开任务列表,退出!')
176 | console.log('如果已经打开而未检测到,请参照软件内的说明更换web内核。')
177 | quit()
178 | }
179 | }
180 |
181 | // 关闭任务列表
182 | function closeTaskList() {
183 | console.log('关闭任务列表')
184 | let anchor = text('累计任务奖励').findOne(5000)
185 | if (!anchor) {
186 | console.log('无法找到任务奖励标识')
187 | return false
188 | }
189 |
190 | anchor = anchor.parent()
191 |
192 | let closeBtn = anchor.child(anchor.childCount() - 2) // tbs
193 | if (!closeBtn.clickable()) {
194 | closeBtn = anchor.child(anchor.childCount() - 1) // webview
195 | }
196 |
197 | return closeBtn.click()
198 | }
199 |
200 | // 重新打开任务列表
201 | function reopenTaskList() {
202 | sleep(3000)
203 | closeTaskList()
204 | sleep(3000)
205 | openTaskList()
206 | sleep(5000)
207 | }
208 |
209 | // 获取未完成任务,根据数字标识,返回任务按钮、任务介绍、任务数量(数组)
210 | function getTaskByText() {
211 | let tButton = null,
212 | tText = null,
213 | tCount = 0,
214 | tTitle = null
215 | console.log('寻找未完成任务...')
216 | let anchor = textMatches(/^(去完成|去打卡)$/).findOnce()
217 | if (anchor) { // 如果找不到任务,直接返回
218 | let tasks = anchor.parent().parent().parent().children()
219 | tasks.pop()
220 |
221 | for (let i = 0; i < tasks.length; i += 5) {
222 | let task = tasks.slice(i, i + 5)
223 | try {
224 | tTitle = task[1].text()
225 |
226 | let r = task[2].text().match(/(\d*)\/(\d*)/)
227 | if (!r) continue
228 | tCount = (r[2] - r[1])
229 |
230 | console.log(tTitle, tCount)
231 |
232 | button = task[4]
233 | if (!button.child(0).child(0).text().match(/去完成|去领取|去打卡/)) continue
234 | // log(tasks)
235 |
236 | if (tCount) { // 如果数字相减不为0,证明没完成
237 | tText = task[3].text()
238 | if (!autoJoin && tText.match(/成功入会/)) continue
239 | if (tTitle.match(/下单|小程序|裂变/)) continue
240 | tButton = button
241 | break
242 | }
243 | } catch (err) {
244 | console.log(err)
245 | }
246 | }
247 | } else {
248 | console.log('任务提示未找到')
249 | }
250 | return [tButton, tText, tCount, tTitle]
251 | }
252 |
253 | // 返回任务列表并检查是否成功,不成功重试一次,带有延时
254 | function backToList() {
255 | sleep(500)
256 | back()
257 | for (let i = 0; i < 5; i++) { // 尝试返回3次
258 | if (!findTextDescMatchesTimeout(/累计任务奖励/, 5000)) {
259 | console.log('返回失败,重试返回')
260 | sleep(2000)
261 | back()
262 | continue
263 | } else {
264 | break
265 | }
266 | }
267 | sleep(3000)
268 | }
269 |
270 | // 浏览n秒的任务
271 | function timeTask() {
272 | console.log('等待浏览任务完成...')
273 | let c = 0
274 | while (c < 40) { // 0.5 * 40 = 20 秒,防止死循环
275 | if ((textMatches(/获得.*?爆竹/).exists() || descMatches(/获得.*?爆竹/).exists())) // 等待已完成出现
276 | break
277 | if ((textMatches(/已浏览/).exists() || descMatches(/已浏览/).exists())) { // 失败
278 | console.log('上限,返回刷新任务列表')
279 | return false
280 | }
281 | if (textMatches(/.*滑动浏览.*[^可]得.*/).exists()) {
282 | console.log('进行模拟滑动')
283 | swipe_flag = 1
284 | swipe(device.width / 2, device.height - 200, device.width / 2 + 20, device.height - 500, 500)
285 | c++
286 | }
287 |
288 | // 弹窗处理
289 | let pop = text('升级开卡会员领好礼')
290 | if (pop.exists()) {
291 | pop.findOnce().parent().parent().child(2).click()
292 | console.log('关闭会员弹窗')
293 | }
294 |
295 | sleep(500)
296 | c++
297 | }
298 | if (c > 39) {
299 | console.log('未检测到任务完成标识。')
300 | return false
301 | }
302 | console.log('已完成,准备返回')
303 | return true
304 | }
305 |
306 | // 入会任务
307 | function joinTask() {
308 | let check = textMatches(/.*确认授权即同意.*|.*我的特权.*|.*立即开卡.*|.*解锁全部会员福利.*/).findOne(8000)
309 | if (!check) {
310 | console.log('无法找到入会按钮,判定为已经入会')
311 | return true
312 | } else if (check.text().match(/我的特权/)) {
313 | console.log('已经入会,返回')
314 | return true
315 | } else {
316 | sleep(2000)
317 | if (check.text().match(/.*立即开卡.*|.*解锁全部会员福利.*|授权解锁/)) {
318 | if (check.text() == '授权信息,解锁全部会员福利') {
319 | check = text('去升级').findOnce()
320 | if (!check) {
321 | console.log('此类型无法找到升级按钮,入会失败')
322 | return false
323 | }
324 | }
325 |
326 | let btn = check.bounds()
327 | console.log('即将点击开卡/解锁福利/升级,自动隐藏控制台')
328 | sleep(500)
329 | console.hide()
330 | sleep(500)
331 | click(btn.centerX(), btn.centerY())
332 | sleep(500)
333 | console.show()
334 | sleep(5000)
335 | check = textMatches(/.*确认授权即同意.*/).boundsInside(0, 0, device.width, device.height).findOne(8000)
336 | }
337 |
338 | if (!check) {
339 | console.log('无法找到入会按钮弹窗,加载失败')
340 | return false
341 | }
342 |
343 |
344 | if (check.indexInParent() == 2) {
345 | check = check.parent().child(1)
346 | } else {
347 | let anchor = textContains('*****').findOnce()
348 | check = anchor.parent().child(anchor.indexInParent() + 2)
349 | if (!check.bounds().top >= anchor.bounds().bottom) {
350 | console.log('使用第二种方法获取控件')
351 | let check1 = anchor.parent().children().findOne(filter(function (w) {
352 | if (w.className().match(/ImageView/) && w.bounds().top >= anchor.bounds().bottom) {
353 | return true
354 | } else {
355 | return false
356 | }
357 | }))
358 | if (!check1) {
359 | console.log('第二种方法也无法确认授权勾选框,失败。返回。')
360 | return false
361 | } else {
362 | check = check1
363 | console.log('成功,继续')
364 | }
365 | }
366 | }
367 |
368 | console.log("最终[确认授权]前面选项框坐标为:", check.bounds());
369 | let x = check.bounds().centerX()
370 | let y = check.bounds().centerY()
371 |
372 | console.log('检测是否有遮挡')
373 | let float = className('android.widget.ImageView')
374 | .filter(function (w) {
375 | let b = w.bounds()
376 | return b.left <= x && b.right >= x && b.top <= y && b.bottom >= y && b.centerX() != x && b.centerY() != y
377 | }).findOnce()
378 |
379 | if (float) {
380 | console.log('有浮窗遮挡,尝试移除')
381 | if (device.sdkInt >= 24) {
382 | gesture(1000, [float.bounds().centerX(), float.bounds().centerY()], [float.bounds().centerX(), y + float.bounds().height()])
383 | console.log('已经进行移开操作,如果失败请反馈')
384 | } else {
385 | console.log('安卓版本低,无法自动移开浮窗,入会任务失败。至少需要安卓7.0。')
386 | return false
387 | }
388 | } else {
389 | console.log('未发现遮挡的浮窗,继续勾选')
390 | }
391 |
392 | console.log('即将勾选授权,自动隐藏控制台')
393 | sleep(500)
394 | console.hide()
395 | sleep(1000)
396 | click(x, y)
397 | sleep(500)
398 | console.show()
399 |
400 | console.log('准备点击入会按钮')
401 | let j = textMatches(/^确认授权(并加入店铺会员)*$|.*立即开通.*/).findOne(5000)
402 | if (!j) {
403 | console.log('无法找到入会按钮,失败')
404 | return false
405 | }
406 | click(j.bounds().centerX(), j.bounds().centerY())
407 | sleep(1000)
408 | console.log('入会完成,返回')
409 | return true
410 | }
411 | }
412 |
413 | // 浏览商品和加购的任务,cart参数为是否加购的flag
414 | function itemTask(cart) {
415 | console.log('等待进入商品列表...')
416 | if (!textContains('当前页').findOne(20000)) {
417 | console.log('未能进入商品列表。')
418 | return false
419 | }
420 | sleep(2000)
421 | let items = textContains('.jpg!q70').find()
422 | for (let i = 0; i < items.length; i++) {
423 | console.log('浏览')
424 | let tmp = items[i].parent().parent()
425 | tmp.child(tmp.childCount() - 1).click()
426 |
427 | sleep(5000)
428 | console.log('返回')
429 | back()
430 | sleep(5000)
431 | let r = textContains('当前页').findOnce()
432 | if (!r) {
433 | back()
434 | sleep(5000)
435 | }
436 | if (i >= 4 - 1) {
437 | break
438 | }
439 | }
440 | return true
441 | }
442 |
443 | // 逛店任务 TODO: 年货节版本
444 | function shopTask() {
445 | console.log('等待进入店铺列表...')
446 | let banner = textContains('喜欢').findOne(10000)
447 | if (!banner) {
448 | console.log('未能进入店铺列表。返回。')
449 | return false
450 | }
451 | let c = banner.text().match(/(\d)\/(\d*)/)
452 | if (!c) {
453 | c = 4 // 进行4次
454 | } else {
455 | c = c[2] - c[1]
456 | }
457 | sleep(2000)
458 | console.log('进行', c, '次')
459 | let like = textContains('喜欢').boundsInside(1, 0, device.width, device.height).findOnce()
460 | if (!like) {
461 | console.log('未能找到喜欢按钮。返回。')
462 | return false
463 | }
464 | let bound = [like.bounds().centerX(), like.bounds().centerY()]
465 | console.log('喜欢按钮位于', bound)
466 | for (let i = 0; i < c; i++) {
467 | click(bound[0], bound[1])
468 | console.log('浏览店铺页')
469 | sleep(8000)
470 | console.log('返回')
471 | back()
472 | sleep(5000)
473 | let r = textContains('喜欢').findOnce()
474 | if (!r) {
475 | back()
476 | sleep(5000)
477 | }
478 | }
479 | return true
480 | }
481 |
482 | // 参观任务
483 | function viewTask() {
484 | console.log('进行参观任务')
485 | sleep(5000)
486 | console.log('参观任务直接返回')
487 | return true
488 | }
489 |
490 | // 品牌墙任务 TODO: 年货节版本
491 | function wallTask() {
492 | console.log('进行品牌墙任务')
493 | sleep(3000)
494 | for (let i of [2, 3, 4, 5, 6]) { // 选5个
495 | console.log('打开一个')
496 | textContains('!q70').boundsInside(100, 100, device.width, device.height).findOnce(i).click()
497 | sleep(5000)
498 | console.log('直接返回')
499 | back()
500 | let r = textContains('!q70').findOne(8000)
501 | if (!r) back()
502 | sleep(3000)
503 | }
504 | // console.log('返回顶部')
505 | // let root = textContains('到底了').findOnce().parent().parent()
506 | // root.child(root.childCount() - 2).click()
507 | console.log('品牌墙完成后重新打开任务列表')
508 | sleep(3000)
509 | openTaskList()
510 | return true
511 | }
512 |
513 | // 单个任务的function,自动进入任务、自动返回任务列表,返回boolean
514 | // TODO: 年货节
515 | function doTask(tButton, tText, tTitle) {
516 | let clickFlag = tButton.click()
517 | let tFlag
518 |
519 | if (tButton.text() == '去领取') {
520 | tFlag = clickFlag // 打卡点击一次即可
521 | return tFlag
522 | }
523 |
524 | if (tText.match(/品牌墙/) || tTitle.match(/品牌墙/)) {
525 | if (tTitle.match(/浏览更多权益/)) {
526 | console.log('简单品牌墙任务,等待10s')
527 | sleep(10000)
528 | return true
529 | }
530 | tFlag = wallTask()
531 | return tFlag // 品牌墙无需backToList,提前返回
532 | } else if (tText.match(/浏览并关注.*s|浏览.*s/)) {
533 | console.log('进行', tText)
534 | tFlag = timeTask()
535 | } else if (tText.match(/累计浏览/)) {
536 | console.log('进行累计浏览任务')
537 | if (tText.match(/加购/)) {
538 | tFlag = itemTask(true)
539 | } else {
540 | tFlag = itemTask(false)
541 | }
542 | } else if (tText.match(/入会/)) {
543 | console.log('进行入会任务')
544 | tFlag = joinTask()
545 | } else if (tText.match(/浏览可得|浏览并关注|晚会|参与/)) {
546 | if (tTitle.match(/种草城/)) {
547 | tFlag = shopTask()
548 | } else {
549 | tFlag = viewTask()
550 | }
551 | } else if (tText.match(/打卡|首页/)) {
552 | tFlag = clickFlag // 打卡点击一次即可
553 | return tFlag
554 | } else if (tText.match(/组队/)) {
555 | console.log('等待组队任务')
556 | sleep(3000)
557 | if (findTextDescMatchesTimeout(/累计任务奖励/, 1000)) {
558 | console.log('当前仍在任务列表,说明已经完成任务且领取奖励,返回')
559 | return true
560 | } else {
561 | if (textContains('队伍爆竹').findOne(10000)) {
562 | console.log('进入到组队页面,返回')
563 | backToList()
564 | console.log('等待领取奖励')
565 | sleep(2000)
566 | tFlag = tButton.click()
567 | sleep(2000)
568 | return tFlag
569 | } else {
570 | console.log('未能进入组队')
571 | if (findTextDescMatchesTimeout(/累计任务奖励/, 1000)) {
572 | console.log('当前仍在任务列表,返回')
573 | return true
574 | } else {
575 | console.log('组队任务未检测到页面标识,视为已完成')
576 | tFlag = false
577 | }
578 | }
579 | }
580 | } else {
581 | console.log('未知任务类型,默认为浏览任务', tText)
582 | tFlag = timeTask()
583 | }
584 | backToList()
585 | return tFlag
586 | }
587 |
588 | function signTask() {
589 | console.log('尝试关闭弹窗')
590 |
591 | let anchor = textMatches(/\+\d*爆竹/).findOnce();
592 |
593 | for (let i = 0; i < 5 && anchor; i++) {
594 | try {
595 | let tmp = anchor.parent().parent().child(0)
596 | if (!tmp.clickable()) {
597 | tmp = anchor.parent().parent().parent().child(0)
598 | }
599 | tmp.click()
600 | console.log('关闭')
601 | sleep(1000)
602 | anchor = textMatches(/\+\d*爆竹/).findOnce()
603 | } catch (err) {
604 | pass
605 | }
606 | }
607 |
608 | anchor = text('记录').findOne(5000)
609 | if (!anchor) {
610 | console.log('未能定位,签到失败')
611 | quit()
612 | }
613 | let sign
614 | if (anchor.indexInParent() < 3) {
615 | anchor = anchor.parent()
616 | }
617 |
618 | sign = anchor.parent().child(10)
619 |
620 | if (!sign.clickable()) {
621 | sign = anchor.parent().child(11)
622 | }
623 |
624 | sign.click()
625 | sleep(3000)
626 |
627 | anchor = text('提醒我每天签到').findOne(5000)
628 |
629 | if (!anchor) {
630 | console.log('未找到签到按钮')
631 | return false
632 | }
633 |
634 | anchor = anchor.parent().parent()
635 |
636 | sign = anchor.child(anchor.childCount() - 2)
637 |
638 | console.log('点击签到')
639 | return sign.click()
640 | }
641 |
642 | // 领取金币
643 | function havestCoin() {
644 | console.log('准备领取自动积累的金币')
645 | let h = textMatches(/.*点击领取.*|.*后存满.*/).findOne(5000)
646 | if (h) {
647 | h.click()
648 | console.log('领取成功')
649 | sleep(8000)
650 | } else { console.log('未找到金币控件,领取失败') }
651 | }
652 |
653 | let startCoin = null // 音量键需要
654 |
655 | // 全局try catch,应对无法显示报错
656 | try {
657 | if (autoOpen) {
658 | openAndInto()
659 | console.log('等待活动页面加载')
660 | if (!findTextDescMatchesTimeout(/.*爆竹.*/, 8000)) {
661 | console.log('未能进入活动,请重新运行!')
662 | quit()
663 | }
664 | console.log('成功进入活动,向下滑动一段以保证控件全部出现')
665 | sleep(2000)
666 | scrollDown();
667 |
668 | openTaskList();
669 | } else {
670 | alert('请关闭弹窗后立刻手动打开京东App进入活动页面,并打开任务列表', '限时30秒')
671 | console.log('请手动打开京东App进入活动页面,并打开任务列表')
672 | if (!findTextDescMatchesTimeout(/累计任务奖励|互动攻略/, 30000)) {
673 | console.log('未能进入活动,请重新运行!')
674 | quit()
675 | }
676 | console.log('成功进入活动')
677 | }
678 |
679 | sleep(5000)
680 |
681 | try {
682 | console.log('获取初始金币数量')
683 | startCoin = getCoin()
684 | console.log('当前共有' + startCoin + '金币')
685 | } catch (err) {
686 | console.log('获取金币失败,跳过', err)
687 | }
688 |
689 | havestCoin()
690 |
691 | // 完成所有任务的循环
692 | while (true) {
693 | let [taskButton, taskText, taskCount, taskTitle] = getTaskByText()
694 |
695 | if (!taskButton) {
696 | console.log('领取累计奖励')
697 | textContains('去领取').find().forEach(function (e, i) {
698 | console.log('领取第' + (i + 1) + '个累计奖励')
699 | e.click()
700 | sleep(2000)
701 | })
702 |
703 | havestCoin()
704 |
705 | console.log('最后进行签到任务')
706 | let signT = signTask()
707 |
708 | let endCoin = null
709 | try {
710 | console.log('获取结束金币数量')
711 | endCoin = getCoin()
712 | console.log('当前共有' + endCoin + '金币')
713 | } catch (err) {
714 | console.log('获取金币失败,跳过', err)
715 | }
716 |
717 | console.log('没有可自动完成的任务了,退出。')
718 | console.log('互动任务、下单任务需要手动完成。')
719 | if (startCoin && endCoin) {
720 | console.log('本次运行获得' + (endCoin - startCoin) + '金币')
721 | } else {
722 | console.log('本次运行获得金币无法计算,具体原因请翻阅日志。')
723 | }
724 |
725 | alert('任务已完成', '别忘了在脚本主页领取年货节红包!')
726 |
727 | if (!signT) {
728 | alert('本次签到失败', '请手动签到避免漏签(活动页右上角)')
729 | }
730 |
731 | // alert('任务已完成', '互动任务手动完成之后还会有新任务,建议做完互动二次运行脚本')
732 | quit()
733 | }
734 |
735 | if (taskText.match(/品牌墙/) || taskTitle.match(/种草城/)) { // 品牌墙0/3只需要一次完成
736 | taskCount = 1
737 | }
738 |
739 | // 根据taskCount进行任务,一类任务一起完成,完成后刷新任务列表
740 | console.log('进行' + taskCount + '次“' + taskText + '”类任务')
741 | for (let i = 0; i < taskCount; i++) {
742 | console.log('第' + (i + 1) + '次')
743 | let taskFlag = doTask(taskButton, taskText, taskTitle)
744 | if (taskFlag) {
745 | console.log('完成,进行下一个任务')
746 | } else {
747 | console.log('任务失败,尝试重新打开任务列表获取任务')
748 | break // 直接退出,无需在此调用reopen
749 | }
750 | }
751 | console.log('重新打开任务列表获取任务')
752 | reopenTaskList()
753 | }
754 | } catch (err) {
755 | device.cancelKeepingAwake()
756 | if (err.toString() != 'JavaException: com.stardust.autojs.runtime.exception.ScriptInterruptedException: null') {
757 | console.error(err)
758 | startCoin && console.log('本次任务开始时有' + startCoin + '金币')
759 | }
760 | }
761 |
--------------------------------------------------------------------------------
/jd618.js:
--------------------------------------------------------------------------------
1 | if (!auto.service) {
2 | toast('无障碍服务未启动!退出!')
3 | exit()
4 | }
5 | console.show()
6 |
7 | function getSetting() {
8 | let indices = []
9 | autoOpen && indices.push(0)
10 | autoMute && indices.push(1)
11 | autoJoin && indices.push(2)
12 | indices.push(3)
13 |
14 | let settings = dialogs.multiChoice('任务设置', ['自动打开京东进入活动。多开或任务列表无法自动打开时取消勾选', '自动调整媒体音量为0。以免直播任务发出声音,首次选择需要修改系统设置权限', '自动完成入会任务。京东将授权手机号给商家,日后可能会收到推广短信', '此选项用于保证选择的处理,勿动!'], indices)
15 |
16 | if (settings.length == 0) {
17 | toast('取消选择,任务停止')
18 | exit()
19 | }
20 |
21 | if (settings.indexOf(0) != -1) {
22 | storage.put('autoOpen', true)
23 | autoOpen = true
24 | } else {
25 | storage.put('autoOpen', false)
26 | autoOpen = false
27 | }
28 | if (settings.indexOf(1) != -1) {
29 | storage.put('autoMute', true)
30 | autoMute = true
31 | } else {
32 | storage.put('autoMute', false)
33 | autoMute = false
34 | }
35 | if (settings.indexOf(2) != -1) {
36 | storage.put('autoJoin', true)
37 | autoJoin = true
38 | } else {
39 | storage.put('autoJoin', false)
40 | autoJoin = false
41 | }
42 | }
43 |
44 |
45 | let storage = storages.create('jd_task')
46 | let autoOpen = storage.get('autoOpen', true)
47 | let autoMute = storage.get('autoMute', true)
48 | let autoJoin = storage.get('autoJoin', true)
49 | getSetting()
50 |
51 | if (autoMute) {
52 | try {
53 | device.setMusicVolume(0)
54 | toast('成功设置媒体音量为0')
55 | } catch (err) {
56 | alert('首先需要开启修复音量权限,请开启后再次运行脚本')
57 | exit()
58 | }
59 | }
60 |
61 | console.log('开始完成京东任务...')
62 | console.log('按音量下键停止')
63 |
64 | device.keepScreenDim(30 * 60 * 1000) // 防止息屏30分钟
65 |
66 | // 自定义取消亮屏的退出方法
67 | function quit() {
68 | device.cancelKeepingAwake()
69 | exit()
70 | }
71 |
72 | // 监听音量下键
73 | function registerKey() {
74 | try {
75 | events.observeKey()
76 | } catch (err) {
77 | console.log('监听音量键停止失败,应该是无障碍权限出错,请关闭软件后台任务重新运行。')
78 | console.log('如果还是不行可以重启手机尝试。')
79 | quit()
80 | }
81 | events.onKeyDown('volume_down', function (event) {
82 | console.log('京东任务脚本停止了')
83 | console.log('请手动切换回主页面')
84 | startCoin && console.log('本次任务开始时有' + startCoin + '快递箱')
85 | quit()
86 | })
87 | }
88 | threads.start(registerKey)
89 |
90 | // 自定义一个findTextDescMatchesTimeout
91 | function findTextDescMatchesTimeout(reg, timeout) {
92 | let c = 0
93 | while (c < timeout / 50) {
94 | let result = textMatches(reg).findOnce() || descMatches(reg).findOnce()
95 | if (result) return result
96 | sleep(50)
97 | c++
98 | }
99 | return null
100 | }
101 |
102 | // 打开京东进入活动
103 | function openAndInto() {
104 | console.log('正在打开京东App...')
105 | if (!launch('com.jingdong.app.mall')) {
106 | console.log('可能未安装京东App')
107 | } else {
108 | console.log('等待京东打开')
109 | for (let i = 0; i < 20; i++) {
110 | if (currentPackage() == 'com.jingdong.app.mall') break
111 | sleep(400)
112 | }
113 | if (currentPackage() != 'com.jingdong.app.mall') {
114 | console.log('程序检测京东app打开失败,请注意')
115 | }
116 | }
117 |
118 | sleep(2000)
119 | console.log('进入活动页面')
120 |
121 | app.startActivity({
122 | action: "VIEW",
123 | data: 'openApp.jdMobile://virtual?params={"category":"jump","action":"to","des":"m","sourceValue":"JSHOP_SOURCE_VALUE","sourceType":"JSHOP_SOURCE_TYPE","url":"https://u.jd.com/6qkqN2X","M_sourceFrom":"mxz","msf_type":"auto"}'
124 | })
125 | }
126 |
127 | // 获取快递箱数量
128 | function getCoin() {
129 | let anchor = text('累计已拆').findOne(5000)
130 | if (!anchor) {
131 | console.log('找不到控件')
132 | return false
133 | }
134 | let coin = anchor.parent().child(1).text()
135 | if (coin) {
136 | return parseInt(coin)
137 | } else {
138 | return false
139 | }
140 | }
141 |
142 | // 打开任务列表
143 | function openTaskList() {
144 | console.log('打开任务列表')
145 | let anchor = text('拆快递').findOne(20000)
146 | if (!anchor) {
147 | console.log('未能定位任务列表,请关闭京东重新运行!')
148 | quit()
149 | }
150 | if (anchor.indexInParent() < 3) {
151 | anchor = anchor.parent()
152 | }
153 |
154 | // let taskListButton
155 | let taskListButton = anchor.parent()
156 | // console.log(tmp)
157 | // for (let i = 0; i < tmp.length; i++) {
158 | // if (tmp[i].bounds().centerX() == anchor.bounds().centerX() && tmp[i].bounds().centerY() == anchor.bounds().centerY()) {
159 | // console.log(1)
160 | // taskListButton = tmp[i + 1].child(1)
161 | // if (!taskListButton.clickable()) {
162 | // try {
163 | // taskListButton = taskListButton.child(0)
164 | // } catch (err) {
165 | // console.log('不可点击')
166 | // taskListButton = null
167 | // }
168 | // }
169 | // break
170 | // }
171 | // }
172 |
173 | if (!taskListButton || !taskListButton.clickable()) {
174 | console.log('无法找到任务列表控件,请参照软件内的说明更换web内核。')
175 | quit()
176 | }
177 | taskListButton.click()
178 | console.log('等待任务列表')
179 | if (!findTextDescMatchesTimeout(/每做一次任务就可以拆一个快递箱哦~/, 5000)) {
180 | console.log('似乎没能打开任务列表,重试')
181 | taskListButton.click()
182 | }
183 |
184 | if (!findTextDescMatchesTimeout(/每做一次任务就可以拆一个快递箱哦~/, 10000)) {
185 | console.log('似乎没能打开任务列表,退出!')
186 | console.log('如果已经打开而未检测到,请参照软件内的说明更换web内核。')
187 | quit()
188 | }
189 | }
190 |
191 | // 关闭任务列表
192 | function closeTaskList() {
193 | console.log('关闭任务列表')
194 | let anchor = text('每做一次任务就可以拆一个快递箱哦~').findOne(5000)
195 | if (!anchor) {
196 | console.log('无法找到任务奖励标识')
197 | return false
198 | }
199 |
200 | anchor = anchor.parent()
201 |
202 | let closeBtn = anchor.child(anchor.childCount() - 2) // tbs
203 | if (!closeBtn.clickable()) {
204 | closeBtn = anchor.child(anchor.childCount() - 1) // webview
205 | }
206 |
207 | return closeBtn.click()
208 | }
209 |
210 | // 重新打开任务列表
211 | function reopenTaskList() {
212 | sleep(3000)
213 | closeTaskList()
214 | sleep(3000)
215 | openTaskList()
216 | sleep(5000)
217 | }
218 |
219 | // 获取未完成任务,根据数字标识,返回任务按钮、任务介绍、任务数量(数组)
220 | function getTaskByText() {
221 | let tButton = null,
222 | tText = null,
223 | tCount = 0,
224 | tTitle = null
225 | console.log('寻找未完成任务...')
226 | let anchor = textMatches(/^(去完成|去打卡)$/).findOnce()
227 | if (anchor) { // 如果找不到任务,直接返回
228 | let tasks = anchor.parent().parent().parent().children()
229 | tasks.pop()
230 |
231 | for (let i = 0; i < tasks.length; i += 5) {
232 | let task = tasks.slice(i, i + 5)
233 | try {
234 | tTitle = task[1].text()
235 |
236 | let r = task[2].text().match(/(\d*)\/(\d*)/)
237 | if (!r) continue
238 | tCount = (r[2] - r[1])
239 |
240 | console.log(tTitle, tCount)
241 |
242 | button = task[4]
243 | if (!button.child(0).child(0).text().match(/去完成|去领取|去打卡/)) continue
244 | // log(tasks)
245 |
246 | if (tCount) { // 如果数字相减不为0,证明没完成
247 | tText = task[3].text()
248 | if (!autoJoin && tText.match(/成功入会/)) continue
249 | if (tTitle.match(/下单|小程序|裂变|白条|金融|小游戏/) || tText.match(/绑卡/)) continue
250 | tButton = button
251 | break
252 | }
253 | } catch (err) {
254 | console.log(err)
255 | }
256 | }
257 | } else {
258 | console.log('任务提示未找到')
259 | }
260 | return [tButton, tText, tCount, tTitle]
261 | }
262 |
263 | // 返回任务列表并检查是否成功,不成功重试一次,带有延时
264 | function backToList() {
265 | sleep(500)
266 | back()
267 | for (let i = 0; i < 5; i++) { // 尝试返回3次
268 | if (!findTextDescMatchesTimeout(/每做一次任务就可以拆一个快递箱哦~/, 5000)) {
269 | console.log('返回失败,重试返回')
270 | sleep(2000)
271 | back()
272 | continue
273 | } else {
274 | break
275 | }
276 | }
277 | sleep(3000)
278 | }
279 |
280 | // 浏览n秒的任务
281 | function timeTask() {
282 | console.log('等待浏览任务完成...')
283 | let c = 0
284 | while (c < 40) { // 0.5 * 40 = 20 秒,防止死循环
285 | if ((textMatches(/获得.*?快递箱/).exists() || descMatches(/获得.*?快递箱/).exists())) // 等待已完成出现
286 | break
287 | if ((textMatches(/已.*?浏.*?览/).exists() || descMatches(/已.*?浏.*?览/).exists())) { // 失败
288 | console.log('上限,返回刷新任务列表')
289 | return false
290 | }
291 | if ((textMatches(/出.*?错.*?了/).exists() || descMatches(/出.*?错.*?了/).exists())) {
292 | console.log('任务出错,返回刷新任务列表')
293 | return false
294 | }
295 | if (textMatches(/.*滑动浏览.*[^可]得.*/).exists()) {
296 | console.log('进行模拟滑动')
297 | swipe_flag = 1
298 | swipe(device.width / 2, device.height - 200, device.width / 2 + 20, device.height - 500, 500)
299 | c++
300 | }
301 |
302 | // 弹窗处理
303 | let pop = text('升级开卡会员领好礼')
304 | if (pop.exists()) {
305 | pop.findOnce().parent().parent().child(2).click()
306 | console.log('关闭会员弹窗')
307 | }
308 |
309 | sleep(500)
310 | c++
311 | }
312 | if (c > 39) {
313 | console.log('未检测到任务完成标识。')
314 | return false
315 | }
316 | console.log('已完成,准备返回')
317 | return true
318 | }
319 |
320 | // 入会任务
321 | function joinTask() {
322 | let check = textMatches(/.*确认授权即同意.*|.*我的特权.*|.*立即开卡.*|.*解锁全部会员福利.*/).findOne(8000)
323 | if (!check) {
324 | console.log('无法找到入会按钮,判定为已经入会')
325 | return true
326 | } else if (check.text().match(/我的特权/)) {
327 | console.log('已经入会,返回')
328 | return true
329 | } else {
330 | sleep(2000)
331 | if (check.text().match(/.*立即开卡.*|.*解锁全部会员福利.*|授权解锁/)) {
332 | if (check.text() == '授权信息,解锁全部会员福利') {
333 | check = text('去升级').findOnce()
334 | if (!check) {
335 | console.log('此类型无法找到升级按钮,入会失败')
336 | return false
337 | }
338 | }
339 |
340 | let btn = check.bounds()
341 | console.log('即将点击开卡/解锁福利/升级,自动隐藏控制台')
342 | sleep(500)
343 | console.hide()
344 | sleep(500)
345 | click(btn.centerX(), btn.centerY())
346 | sleep(500)
347 | console.show()
348 | sleep(5000)
349 | check = textMatches(/.*确认授权即同意.*/).boundsInside(0, 0, device.width, device.height).findOne(8000)
350 | }
351 |
352 | if (!check) {
353 | console.log('无法找到入会按钮弹窗,加载失败')
354 | return false
355 | }
356 |
357 |
358 | if (check.indexInParent() == 2) {
359 | check = check.parent().child(1)
360 | } else {
361 | let anchor = textContains('*****').findOnce()
362 | check = anchor.parent().child(anchor.indexInParent() + 2)
363 | if (!check.bounds().top >= anchor.bounds().bottom) {
364 | console.log('使用第二种方法获取控件')
365 | let check1 = anchor.parent().children().findOne(filter(function (w) {
366 | if (w.className().match(/ImageView/) && w.bounds().top >= anchor.bounds().bottom) {
367 | return true
368 | } else {
369 | return false
370 | }
371 | }))
372 | if (!check1) {
373 | console.log('第二种方法也无法确认授权勾选框,失败。返回。')
374 | return false
375 | } else {
376 | check = check1
377 | console.log('成功,继续')
378 | }
379 | }
380 | }
381 |
382 | console.log("最终[确认授权]前面选项框坐标为:", check.bounds());
383 | let x = check.bounds().centerX()
384 | let y = check.bounds().centerY()
385 |
386 | console.log('检测是否有遮挡')
387 | let float = className('android.widget.ImageView')
388 | .filter(function (w) {
389 | let b = w.bounds()
390 | return b.left <= x && b.right >= x && b.top <= y && b.bottom >= y && b.centerX() != x && b.centerY() != y
391 | }).findOnce()
392 |
393 | if (float) {
394 | console.log('有浮窗遮挡,尝试移除')
395 | if (device.sdkInt >= 24) {
396 | gesture(1000, [float.bounds().centerX(), float.bounds().centerY()], [float.bounds().centerX(), y + float.bounds().height()])
397 | console.log('已经进行移开操作,如果失败请反馈')
398 | } else {
399 | console.log('安卓版本低,无法自动移开浮窗,入会任务失败。至少需要安卓7.0。')
400 | return false
401 | }
402 | } else {
403 | console.log('未发现遮挡的浮窗,继续勾选')
404 | }
405 |
406 | console.log('即将勾选授权,自动隐藏控制台')
407 | sleep(500)
408 | console.hide()
409 | sleep(1000)
410 | click(x, y)
411 | sleep(500)
412 | console.show()
413 |
414 | console.log('准备点击入会按钮')
415 | let j = textMatches(/^确认授权(并加入店铺会员)*$|.*立即开通.*/).findOne(5000)
416 | if (!j) {
417 | console.log('无法找到入会按钮,失败')
418 | return false
419 | }
420 | click(j.bounds().centerX(), j.bounds().centerY())
421 | sleep(1000)
422 | console.log('入会完成,返回')
423 | return true
424 | }
425 | }
426 |
427 | // 浏览商品和加购的任务,cart参数为是否加购的flag
428 | function itemTask(cart) {
429 | console.log('等待进入商品列表...')
430 | let anchor = textContains('当前页').findOne(20000)
431 | if (!anchor) {
432 | console.log('未能进入商品列表。')
433 | return false
434 | }
435 | sleep(2000)
436 |
437 | if (anchor.parent().childCount()==4) {
438 | console.log('任务重复完成,返回')
439 | return false
440 | }
441 |
442 | let items = textContains('.jpg!q70').find()
443 | for (let i = 0; i < items.length; i++) {
444 | console.log('浏览')
445 | let tmp = items[i].parent().parent()
446 | tmp.child(tmp.childCount() - 1).click()
447 |
448 | sleep(5000)
449 | console.log('返回')
450 | back()
451 | sleep(5000)
452 | let r = textContains('当前页').findOnce()
453 | if (!r) {
454 | back()
455 | sleep(5000)
456 | }
457 | if (i >= 4 - 1) {
458 | break
459 | }
460 | }
461 | return true
462 | }
463 |
464 | // 逛店任务 TODO: 618版本
465 | function shopTask() {
466 | console.log('等待进入店铺列表...')
467 | let banner = textContains('喜欢').findOne(10000)
468 | if (!banner) {
469 | console.log('未能进入店铺列表。返回。')
470 | return false
471 | }
472 | let c = banner.text().match(/(\d)\/(\d*)/)
473 | if (!c) {
474 | c = 4 // 进行4次
475 | } else {
476 | c = c[2] - c[1]
477 | }
478 | sleep(2000)
479 | console.log('进行', c, '次')
480 | let like = text('喜欢').boundsInside(1, 0, device.width, device.height).findOnce()
481 | if (!like) {
482 | console.log('未能找到喜欢按钮。返回。')
483 | return false
484 | }
485 | let bound = [like.bounds().centerX(), like.bounds().centerY()]
486 | console.log('喜欢按钮位于', bound)
487 | for (let i = 0; i < c; i++) {
488 | click(bound[0], bound[1])
489 | console.log('浏览店铺页')
490 | sleep(8000)
491 | console.log('返回')
492 | back()
493 | sleep(5000)
494 | let r = textContains('喜欢').findOnce()
495 | if (!r) {
496 | back()
497 | sleep(5000)
498 | }
499 | }
500 | return true
501 | }
502 |
503 | // 参观任务
504 | function viewTask() {
505 | console.log('进行参观任务')
506 | sleep(5000)
507 | console.log('参观任务直接返回')
508 | return true
509 | }
510 |
511 | // 品牌墙任务 TODO: 618版本
512 | function wallTask() {
513 | console.log('进行品牌墙任务')
514 | sleep(3000)
515 | for (let i of [2, 3, 4, 5, 6]) { // 选5个
516 | console.log('打开一个')
517 | textContains('!q70').boundsInside(100, 100, device.width, device.height).findOnce(i).click()
518 | sleep(5000)
519 | console.log('直接返回')
520 | back()
521 | let r = textContains('!q70').findOne(8000)
522 | if (!r) back()
523 | sleep(3000)
524 | }
525 | console.log('品牌墙完成后重新打开任务列表')
526 | sleep(3000)
527 | openTaskList()
528 | return true
529 | }
530 |
531 | // 单个任务的function,自动进入任务、自动返回任务列表,返回boolean
532 | // TODO: 618
533 | function doTask(tButton, tText, tTitle) {
534 | let clickFlag = tButton.click()
535 | let tFlag
536 |
537 | if (tButton.text() == '去领取') {
538 | tFlag = clickFlag // 打卡点击一次即可
539 | return tFlag
540 | }
541 |
542 | if (tText.match(/品牌墙/) || tTitle.match(/品牌墙/)) {
543 | if (tTitle.match(/浏览更多权益/)) {
544 | console.log('简单品牌墙任务,等待10s')
545 | sleep(10000)
546 | return true
547 | }
548 | tFlag = wallTask()
549 | return tFlag // 品牌墙无需backToList,提前返回
550 | } else if (tText.match(/浏览并关注.*s|浏览.*s/)) {
551 | console.log('进行', tText)
552 | tFlag = timeTask()
553 | } else if (tText.match(/累计浏览/)) {
554 | console.log('进行累计浏览任务')
555 | if (tText.match(/加购/)) {
556 | tFlag = itemTask(true)
557 | } else {
558 | tFlag = itemTask(false)
559 | }
560 | } else if (tText.match(/入会/)) {
561 | console.log('进行入会任务')
562 | tFlag = joinTask()
563 | } else if (tText.match(/浏览可得|浏览可获得|浏览并关注|晚会|参与/)) {
564 | if (tTitle.match(/种草城/)) {
565 | tFlag = shopTask()
566 | } else {
567 | tFlag = viewTask()
568 | }
569 | } else if (tText.match(/打卡|首页/)) {
570 | tFlag = clickFlag // 打卡点击一次即可
571 | return tFlag
572 | } else if (tText.match(/组队/)) {
573 | console.log('等待组队任务')
574 | sleep(3000)
575 | if (findTextDescMatchesTimeout(/.*每做一次任务.*/, 1000)) {
576 | console.log('当前仍在任务列表,说明已经完成任务且领取奖励,返回')
577 | return true
578 | } else {
579 | if (textContains('队伍快递箱').findOne(10000)) {
580 | console.log('进入到组队页面,返回')
581 | backToList()
582 | console.log('等待领取奖励')
583 | sleep(2000)
584 | tFlag = tButton.click()
585 | sleep(2000)
586 | return tFlag
587 | } else {
588 | console.log('未能进入组队')
589 | if (findTextDescMatchesTimeout(/.*每做一次任务.*/, 1000)) {
590 | console.log('当前仍在任务列表,返回')
591 | return true
592 | } else {
593 | console.log('组队任务未检测到页面标识,视为已完成')
594 | tFlag = false
595 | }
596 | }
597 | }
598 | } else {
599 | console.log('未知任务类型,默认为浏览任务', tText)
600 | tFlag = timeTask()
601 | }
602 | backToList()
603 | return tFlag
604 | }
605 | function closePop(){
606 | let anchor = text('已放入首页>记录').findOne(5000);
607 | if(anchor){
608 | anchor = anchor.parent()
609 | let closeBtn = anchor.child(anchor.childCount() - 2) // tbs
610 | if (!closeBtn.clickable()) {
611 | closeBtn = anchor.child(anchor.childCount() - 1) // webview
612 | }
613 | return closeBtn.click()
614 | }
615 | console.log('未查询到弹窗按钮')
616 | return false
617 | }
618 | function signTask() {
619 | console.log('尝试关闭弹窗')
620 |
621 | let anchor = textMatches(/\+\d*快递箱/).findOnce();
622 |
623 | for (let i = 0; i < 5 && anchor; i++) {
624 | try {
625 | let tmp = anchor.parent().parent().child(0)
626 | if (!tmp.clickable()) {
627 | tmp = anchor.parent().parent().parent().child(0)
628 | }
629 | tmp.click()
630 | console.log('关闭')
631 | sleep(1000)
632 | anchor = textMatches(/\+\d*快递箱/).findOnce()
633 | } catch (err) {
634 | pass
635 | }
636 | }
637 |
638 | anchor = text('记录').findOne(5000)
639 | if (!anchor) {
640 | console.log('未能定位,签到失败')
641 | quit()
642 | }
643 | let sign
644 | if (anchor.indexInParent() < 3) {
645 | anchor = anchor.parent()
646 | }
647 |
648 | sign = anchor.parent().child(10)
649 |
650 | if (!sign.clickable()) {
651 | sign = anchor.parent().child(11)
652 | }
653 |
654 | sign.click()
655 | sleep(3000)
656 |
657 | anchor = text('提醒我每天签到').findOne(5000)
658 |
659 | if (!anchor) {
660 | console.log('未找到签到按钮')
661 | return false
662 | }
663 |
664 | anchor = anchor.parent().parent()
665 |
666 | sign = anchor.child(anchor.childCount() - 2)
667 |
668 | console.log('点击签到')
669 | return sign.click()
670 | }
671 |
672 | // 领取快递箱
673 | function havestCoin() {
674 | console.log('准备领取自动积累的快递箱')
675 | let h = textMatches(/.*点击领取.*|.*后存满.*/).findOne(5000)
676 | if (h) {
677 | h.click()
678 | console.log('领取成功')
679 | sleep(8000)
680 | } else { console.log('未找到快递箱控件,领取失败') }
681 | }
682 |
683 | let startCoin = null
684 | // 全局try catch,应对无法显示报错
685 | try {
686 | if (autoOpen) {
687 | openAndInto()
688 | console.log('等待活动页面加载')
689 | if (!findTextDescMatchesTimeout(/.*拆快递.*/, 8000)) {
690 | console.log('未能进入活动,请重新运行!')
691 | quit()
692 | }
693 | console.log('成功进入活动,向下滑动一段以保证控件全部出现')
694 | sleep(2000)
695 | scrollDown();
696 |
697 | openTaskList();
698 | } else {
699 | alert('请关闭弹窗后立刻手动打开京东App进入活动页面,并打开任务列表', '限时30秒')
700 | console.log('请手动打开京东App进入活动页面,并打开任务列表')
701 | if (!findTextDescMatchesTimeout(/每做一次任务.*|攻略/, 8000)) {
702 | console.log('未能进入活动,请重新运行!')
703 | quit()
704 | }
705 | console.log('成功进入活动')
706 | }
707 |
708 | sleep(5000)
709 | try {
710 | console.log('获取初始快递箱数量')
711 | startCoin = getCoin()
712 | console.log('当前共有' + startCoin + '快递箱')
713 | } catch (err) {
714 | console.log('获取快递箱失败,跳过', err)
715 | }
716 | // 完成所有任务的循环
717 | while (true) {
718 | let [taskButton, taskText, taskCount, taskTitle] = getTaskByText()
719 |
720 | if (!taskButton) {
721 | console.log('领取红包奖励')
722 | let anchor = textContains('/再拆.*个快递有机会得红包/').findOnce()
723 | textContains('去领取').find().forEach(function (e, i) {
724 | console.log('领取第' + (i + 1) + '个累计奖励')
725 | e.click()
726 | sleep(2000)
727 | })
728 |
729 | let endCoin = null
730 | try {
731 | console.log('获取结束快递箱数量')
732 | endCoin = getCoin()
733 | console.log('当前共有' + endCoin + '快递箱')
734 | } catch (err) {
735 | console.log('获取快递箱失败,跳过', err)
736 | }
737 |
738 | console.log('没有可自动完成的任务了,退出。')
739 | console.log('互动任务、下单任务需要手动完成。')
740 | if (startCoin && endCoin) {
741 | console.log('本次运行获得' + (endCoin - startCoin) + '快递箱')
742 | } else {
743 | console.log('本次运行获得快递箱无法计算,具体原因请翻阅日志。')
744 | }
745 | alert('任务已完成', '别忘了在脚本主页领取红包!')
746 |
747 | quit()
748 | }
749 |
750 | if (taskText.match(/品牌墙/) || taskTitle.match(/种草城/)) { // 品牌墙0/3只需要一次完成
751 | taskCount = 1
752 | }
753 |
754 | // 根据taskCount进行任务,一类任务一起完成,完成后刷新任务列表
755 | console.log('进行' + taskCount + '次“' + taskText + '”类任务')
756 | for (let i = 0; i < taskCount; i++) {
757 | console.log('第' + (i + 1) + '次')
758 | let taskFlag = doTask(taskButton, taskText, taskTitle)
759 | if (text('已放入首页>记录').exists()) {
760 | console.log('关闭弹窗')
761 | closePop()
762 | sleep(3000)
763 | }
764 | if (taskFlag) {
765 | console.log('完成,进行下一个任务')
766 | } else {
767 | console.log('任务失败,尝试重新打开任务列表获取任务')
768 | break // 直接退出,无需在此调用reopen
769 | }
770 | }
771 | console.log('重新打开任务列表获取任务')
772 | reopenTaskList()
773 | }
774 | } catch (err) {
775 | device.cancelKeepingAwake()
776 | if (err.toString() != 'JavaException: com.stardust.autojs.runtime.exception.ScriptInterruptedException: null') {
777 | console.error(err)
778 | startCoin && console.log('本次任务开始时有' + startCoin + '快递箱')
779 | }
780 | }
781 |
--------------------------------------------------------------------------------
/qrcode_1666778378599.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ljt0515/618/690c545eb359796e15910e51275d0a765f1d58d9/qrcode_1666778378599.jpg
--------------------------------------------------------------------------------
/qrcode_for_gh_d76dde74fd07_344.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ljt0515/618/690c545eb359796e15910e51275d0a765f1d58d9/qrcode_for_gh_d76dde74fd07_344.jpg
--------------------------------------------------------------------------------
/tb618.js:
--------------------------------------------------------------------------------
1 | if (!auto.service) {
2 | toast('无障碍服务未启动!退出!')
3 | exit()
4 | }
5 |
6 |
7 | // alert('请把手机放稳,不要摇晃!', '不然有时候会跳出合伙赢喵币,导致任务阻塞')
8 |
9 | console.show()
10 |
11 | function getSetting() {
12 | let indices = []
13 | autoOpen && indices.push(0)
14 | autoMute && indices.push(1)
15 | indices.push(2)
16 |
17 | let settings = dialogs.multiChoice('任务设置', ['自动打开淘宝进入活动。多开或任务列表无法自动打开时取消勾选(注意,分身运行淘宝大概率导致任务收益变为100)', '自动调整媒体音量为0。以免直播任务发出声音,首次选择需要修改系统设置权限', '此选项用于保证选择的处理,勿动!'], indices)
18 |
19 | if (settings.length == 0) {
20 | toast('取消选择,任务停止')
21 | exit()
22 | }
23 |
24 | if (settings.indexOf(0) != -1) {
25 | storage.put('autoOpen', true)
26 | autoOpen = true
27 | } else {
28 | storage.put('autoOpen', false)
29 | autoOpen = false
30 | }
31 | if (settings.indexOf(1) != -1) {
32 | storage.put('autoMute', true)
33 | autoMute = true
34 | } else {
35 | storage.put('autoMute', false)
36 | autoMute = false
37 | }
38 | }
39 |
40 | let storage = storages.create("tb_task");
41 | let autoOpen = storage.get('autoOpen', true)
42 | let autoMute = storage.get('autoMute', true)
43 | getSetting()
44 |
45 | if (autoMute) {
46 | try {
47 | device.setMusicVolume(0)
48 | toast('成功设置媒体音量为0')
49 | } catch (err) {
50 | alert('首先需要开启权限,请开启后再次运行脚本')
51 | exit()
52 | }
53 | }
54 |
55 | console.show()
56 | console.log('开始完成喵币任务...')
57 | console.log('按音量下键停止')
58 |
59 | device.keepScreenDim(60 * 60 * 1000)
60 |
61 | let startCoin;
62 |
63 | function registerKey() {
64 | try {
65 | events.observeKey()
66 | } catch (err) {
67 | console.log('监听音量键停止失败,应该是无障碍权限出错,请关闭软件后台任务重新运行。')
68 | console.log('如果还是不行可以重启手机尝试。')
69 | quit()
70 | }
71 | events.onKeyDown('volume_down', function (event) {
72 | console.log('喵币任务脚本停止了')
73 | console.log('请手动切换回主页面')
74 | if (startCoin) {
75 | console.log('本次任务开始时有', startCoin, '喵币')
76 | }
77 | device.cancelKeepingAwake()
78 | exit()
79 | })
80 | }
81 | threads.start(registerKey)
82 |
83 | // 全局try catch,应对无法显示报错
84 | try {
85 |
86 | // 自定义去取消亮屏的退出方法
87 | function quit() {
88 | device.cancelKeepingAwake()
89 | exit()
90 | }
91 |
92 | // 自定义一个findTimeout,find_f是原本的查询器 text('sss').find()
93 | function findTimeout(findF, timeout) {
94 | let c = 0
95 | while (c < timeout / 50) {
96 | let result = findF.find()
97 | if (result.nonEmpty()) return result
98 | sleep(50)
99 | c++
100 | }
101 | return null
102 | }
103 |
104 | // 自定义一个findTextDescMatchesTimeout
105 | function findTextDescMatchesTimeout(reg, timeout) {
106 | let c = 0
107 | while (c < timeout / 50) {
108 | let result = textMatches(reg).findOnce() || descMatches(reg).findOnce()
109 | if (result) return result
110 | sleep(50)
111 | c++
112 | }
113 | return null
114 | }
115 |
116 | // 查找任务按钮
117 | function findTask() {
118 | var jumpButtonFind = textMatches(/.*(去浏览|去搜索|去完成|去签到|去逛逛|去观看|去参赛).*/) // 找进入任务的按钮,10秒
119 | var jumpButtons = findTimeout(jumpButtonFind, 10000)
120 |
121 | if (!jumpButtons) {
122 | return null
123 | }
124 |
125 | for (var i = 0; i < jumpButtons.length; i++) {
126 | var taskName, content
127 | try {
128 | taskName = jumpButtons[i].parent().child(0).child(0).text()
129 | content = jumpButtons[i].parent().child(0).child(1).child(0).text()
130 | } catch (err) {
131 | console.log(err)
132 | console.log('使用第二种方法尝试')
133 | try {
134 | content = jumpButtons[i].parent().child(0).child(1).text()
135 | console.log('成功,继续任务')
136 | }
137 | catch (err) {
138 | continue
139 | }
140 | }
141 | if (taskName) {
142 | if (taskName.match(/签到/)) {
143 | console.log('进行签到任务')
144 | sleep(1000)
145 | jumpButtons[i].click()
146 | sleep(8000)
147 | return findTask()
148 | }
149 | if (!(taskName.match(/淘金币|提醒|开通|续费|乐园|话费|斗地主|消消乐|流浪猫|开88|扔喵币|占领|邀请|登录|组队|参与|施肥|浇水|特价版|小鸡|消除|穿搭|森林|点淘|人生|我的淘宝|庄园|支付宝|点击人物|省钱卡|年卡|积分/) || content.match(/小互动|开通/))) {
150 | return [taskName, jumpButtons[i]]
151 | }
152 | }
153 | }
154 | return null
155 | }
156 |
157 | function liulan() {
158 | // if (textMatches(/.*浏览.*/).findOne(10000)) { // 等待浏览出现
159 | // let v = className('android.support.v7.widget.RecyclerView').findOnce() // 滑动
160 | // if (v) {
161 | // sleep(1000)
162 | // v.scrollForward()
163 | // }
164 | // }
165 |
166 | // textMatches(/.*浏览得奖励.*/).findOne(15000) // 等待开始
167 | let finish_c = 0
168 | let countdown = 0
169 | console.log('开始检测任务完成,部分控件无法检测,会在30秒后自动返回,请耐心等待。')
170 | while (finish_c < 250) { // 0.1 * 250 = 25 秒,防止死循环
171 | if (textMatches(/.*下拉浏览.*|.*浏览最高得.*/).exists()) {
172 | console.log('进行模拟滑动')
173 | swipe(device.width / 2, device.height - 200, device.width / 2 + 20, device.height - 500, 2000)
174 | finish_c = finish_c + 10
175 | }
176 | let finish_reg = /.*任务.*?完成[\s\S]*?|.*失败.*|.*上限.*|.*开小差.*|.*喵币已发放[\s\S]*|.*下单可获得[\s\S]*|任务已经/
177 | if (textMatches(finish_reg).exists() || descMatches(finish_reg).exists()) { // 等待已完成出现,有可能失败
178 | break
179 | }
180 | if (countdown == 0 && idContains('countdown').exists()) {
181 | countdown = 1
182 | break
183 | }
184 | if (textMatches(/.*休息会呗.*/).exists()) {
185 | alert('触发淘宝验证', '请手动验证后返回淘宝首页,重新执行任务')
186 | console.log('异常退出。')
187 | quit()
188 | }
189 | if (textContains('互动奖励').exists() ||
190 | descContains('互动奖励').exists()) {
191 | console.log('跳过互动任务')
192 | break
193 | }
194 | if (text('手机淘宝触屏版').exists()) {
195 | console.log('页面未加载,返回')
196 | break
197 | }
198 | if (text('宝贝口袋').exists()) {
199 | let cart = text('购物车').findOnce()
200 | let x = cart.bounds().right
201 | let y = cart.bounds().top
202 | console.log('关闭直播购物车')
203 | click(x, y - 100)
204 | }
205 | if (text('立即关注得喵币').exists()) {
206 | console.log('关注直播间任务,点击关注按钮')
207 | text('立即关注得喵币').click()
208 | sleep(1000)
209 | break
210 | }
211 | if (finish_c > 100 && finish_c % 50 == 0) {
212 | console.log('滑动防止页面卡顿')
213 | swipe( device.width / 2, device.height - 400, device.width / 2 + 20, device.height - 500, 500)
214 | finish_c = finish_c + 5
215 | }
216 | sleep(100)
217 | finish_c++
218 | }
219 |
220 | if (countdown) {
221 | console.log('出现图片类型标识,使用新方法完成,18秒后视为任务完成,自动返回')
222 | sleep(18000)
223 | }
224 |
225 | if (finish_c > 249) {
226 | console.log('未检测到任务完成标识。返回。')
227 | // console.log('如果你认为这是一个bug请截图反馈。')
228 | // console.log('一般情况下,二次运行脚本即可。')
229 | // console.log('请手动切换回主页面')
230 | // device.cancelKeepingAwake()
231 | // quit()
232 | if (textContains('累计任务奖励').exists()) {
233 | console.log('店铺已主动返回,继续任务')
234 | return
235 | }
236 | back()
237 | sleep(1000)
238 | // TODO: 返回检测
239 | if (!textContains('累计任务奖励').findOne(8000)) {
240 | console.log('似乎没有返回,二次尝试')
241 | back()
242 | }
243 | return
244 | }
245 |
246 | console.log('任务结束,返回')
247 |
248 | back()
249 | sleep(1000)
250 | if (!textContains('累计任务奖励').findOne(5000)) {
251 | if (currentActivity() == 'com.taobao.tao.TBMainActivity') {
252 | console.log('返回到了主页,尝试重新进入任务')
253 | id('com.taobao.taobao:id/rv_main_container').findOnce().child(3).child(0).click()
254 | } else {
255 | console.log('似乎没有返回,二次尝试')
256 | back()
257 | }
258 | }
259 | }
260 |
261 | // 喵币数量
262 | function getCoin() {
263 | console.log('获取喵币数量')
264 | try {
265 | let e = textContains('我的喵币').findOnce()
266 | let num = e.text().match(/(\d*)个/)[1]
267 | console.log('当前共有', num, '喵币')
268 | return num
269 | } catch (err) {
270 | console.log(err)
271 | console.log('获取喵币数量错误,不影响脚本运行')
272 | return null
273 | }
274 | }
275 |
276 | try {
277 | if (autoOpen) {
278 | // 打开淘宝活动页面
279 | console.log('正在打开淘宝...')
280 | var url = 'pages.tmall.com/wow/z/hdwk/hd2023618/home?disableNav=YES&qd_from=tbsybutton'
281 |
282 | app.startActivity({
283 | action: "VIEW",
284 | data: "taobao://" + url
285 | })
286 | sleep(2000)
287 |
288 | console.log('等待页面加载...')
289 | textContains('领喵币').findOne(20000)
290 | console.log('准备打开任务列表,第一次启动页面等待10秒加载')
291 | sleep(10000)
292 |
293 | let c = textContains('领喵币').findOne(1000)
294 | if (c) {
295 | console.log('使用默认方法尝试打开任务列表')
296 | c.click()
297 | sleep(1000)
298 | c.click()
299 | console.log('已点击,未能打开建议手动点击一下任务列表。此问题并非bug,和网络以及设备性能有关。')
300 | console.log('检测任务列表,准备进行二次尝试')
301 | } else {
302 | throw '无法找到任务列表入口'
303 | }
304 | if (!textContains('累计任务奖励').findOne(8000)) {
305 | console.log('默认方式打开失败,二次尝试')
306 | console.log('首先检测弹窗')
307 | for (let i = 0; i < 2 && text('关闭').findOne(2000); i++) { // 关闭弹窗
308 | console.log('检测到弹窗,关闭')
309 | click('关闭')
310 | sleep(2000)
311 | }
312 | console.log('已试图自动关闭弹窗。有未能自动关闭的弹窗请手动关闭')
313 | sleep(5000)
314 | // let right = c.bounds().right
315 | // let left = c.bounds().left
316 | // let top = c.bounds().top
317 | // let bottom = c.bounds().bottom
318 | // click(random(right,left), random(top, bottom))
319 | click(c.bounds().centerX(), c.bounds().centerY())
320 | console.log('已点击,等待任务列表出现')
321 | if (!textContains('累计任务奖励').findOne(8000)) {
322 | throw '无法打开任务列表'
323 | }
324 | }
325 | } else {
326 | console.log('请在30秒内打开淘宝活动页,并打开任务列表')
327 | if (textContains('累计任务奖励').findOne(30000)) {
328 | console.log('已打开,继续任务')
329 | } else {
330 | console.log('未能检测到任务列表,退出')
331 | quit()
332 | }
333 | }
334 | console.log('准备搜索任务')
335 | sleep(2000)
336 | } catch (err) {
337 | console.log(err)
338 | console.log('无法进入任务列表,如果你认为这是bug,请截图反馈。注意!1级没法做任务,请先升到2级!')
339 | quit()
340 | }
341 |
342 | startCoin = getCoin()
343 |
344 | while (true) {
345 | console.log('寻找任务入口...')
346 | var jumpButton = findTask()
347 |
348 | if (jumpButton == null) {
349 | // 没有任务之后领取奖励
350 | var awardButtonFind = textMatches(/立即领取|领取奖励/)
351 | var awardButtons = findTimeout(awardButtonFind, 10000)
352 |
353 | if (awardButtons) {
354 | for (var i = 0; i < awardButtons.length; i++) {
355 | console.log('领取累计任务奖励')
356 | awardButtons[i].click()
357 | console.log('等待5秒再次领取...')
358 | sleep(5000)
359 | }
360 | }
361 |
362 | const endCoin = getCoin()
363 |
364 | console.log('没找到合适的任务。也许任务已经全部做完了。退出。互动任务不会自动完成。')
365 | console.log('请手动切换回主页面')
366 | if (startCoin && endCoin) {
367 | console.log('本次任务共获得', (endCoin - startCoin), '喵币')
368 | }
369 | alert('任务已完成', '别忘了在脚本主页领取双十一红包!互动任务需要手动完成。')
370 | quit()
371 | }
372 |
373 | if (jumpButton[0].match('去浏览店铺领能量')) {
374 | console.log('进行浏览店铺任务')
375 | jumpButton[1].click()
376 | while (!textContains('任务完成').exists()) {
377 | console.log('进入店铺浏览')
378 | text('逛店最多').findOne(15000).parent().click()
379 | liulan()
380 | sleep(2000)
381 | }
382 | back()
383 | } else if (jumpButton[0].match(/.*玩游戏.*|.*浏览餐饮卡券.*|.*加油赛.*|.*赚星星.*/)) {
384 | console.log('进行' + jumpButton[0] + '任务,10秒后返回')
385 | jumpButton[1].click()
386 | sleep(10000)
387 | back()
388 | } else if (jumpButton[0].match(/领现金/)) {
389 | console.log('进行' + jumpButton[0] + '任务')
390 | jumpButton[1].click()
391 | let into = text('打开链接').findOne(10000)
392 | if (!into) {
393 | console.log('无法找到进入领现金的按钮!')
394 | quit()
395 | }
396 | into.click()
397 | liulan()
398 | } else if (jumpButton[0].match(/搜一搜/)) {
399 | console.log('进行' + jumpButton[0] + '任务')
400 | jumpButton[1].click()
401 | console.log('等待搜索')
402 | sleep(2000)
403 | textContains('搜索后浏览').findOne(8000)
404 | let listView = className('android.widget.ListView').findOne(2000).child(0)
405 | if (listView.childCount() == 1) {
406 | listView.child(0).click()
407 | } else {
408 | listView.child(1).click()
409 | }
410 | liulan()
411 | sleep(1000)
412 | back()
413 | backToList()
414 | } else {
415 | console.log('进行' + jumpButton[0] + '任务')
416 | jumpButton[1].click()
417 | liulan()
418 | }
419 |
420 | console.log('等待页面刷新...')
421 | sleep(2000)
422 | }
423 | } catch (err) {
424 | device.cancelKeepingAwake()
425 | if (err.toString() != 'JavaException: com.stardust.autojs.runtime.exception.ScriptInterruptedException: null') {
426 | console.error(err)
427 | }
428 | }
429 |
--------------------------------------------------------------------------------
/tb_hc.js:
--------------------------------------------------------------------------------
1 |
2 | if (!auto.service) {
3 | toast('无障碍服务未启动!退出!')
4 | exit()
5 | }
6 |
7 | // alert('请把手机放稳,不要摇晃!', '不然有时候会跳出合伙赢喵币,导致任务阻塞')
8 |
9 | function getSetting() {
10 | let indices = []
11 | autoOpen && indices.push(0)
12 | autoMute && indices.push(1)
13 | indices.push(2)
14 |
15 | let settings = dialogs.multiChoice('任务设置', ['自动打开淘宝进入活动。多开或任务列表无法自动打开时取消勾选(注意,分身运行淘宝大概率导致任务收益变为100)', '自动调整媒体音量为0。以免直播任务发出声音,首次选择需要修改系统设置权限', '此选项用于保证选择的处理,勿动!'], indices)
16 |
17 | if (settings.length == 0) {
18 | toast('取消选择,任务停止')
19 | exit()
20 | }
21 |
22 | if (settings.indexOf(0) != -1) {
23 | storage.put('autoOpen', true)
24 | autoOpen = true
25 | } else {
26 | storage.put('autoOpen', false)
27 | autoOpen = false
28 | }
29 | if (settings.indexOf(1) != -1) {
30 | storage.put('autoMute', true)
31 | autoMute = true
32 | } else {
33 | storage.put('autoMute', false)
34 | autoMute = false
35 | }
36 | }
37 |
38 | let storage = storages.create("tb_task");
39 | let autoOpen = storage.get('autoOpen', true)
40 | let autoMute = storage.get('autoMute', true)
41 | getSetting()
42 |
43 | if (autoMute) {
44 | try {
45 | device.setMusicVolume(0)
46 | toast('成功设置媒体音量为0')
47 | } catch (err) {
48 | alert('首先需要开启权限,请开启后再次运行脚本')
49 | exit()
50 | }
51 | }
52 |
53 | console.show()
54 | console.log('开始完成能量任务...')
55 | console.log('按音量下键停止')
56 |
57 | device.keepScreenDim(60 * 60 * 1000)
58 |
59 | function registerKey() {
60 | try {
61 | events.observeKey()
62 | } catch (err) {
63 | console.log('监听音量键停止失败,应该是无障碍权限出错,请关闭软件后台任务重新运行。')
64 | console.log('如果还是不行可以重启手机尝试。')
65 | quit()
66 | }
67 | events.onKeyDown('volume_down', function (event) {
68 | console.log('喵币任务脚本停止了')
69 | console.log('请手动切换回主页面')
70 | device.cancelKeepingAwake()
71 | exit()
72 | })
73 | }
74 | threads.start(registerKey)
75 |
76 | // 全局try catch,应对无法显示报错
77 | try {
78 |
79 | // 自定义去取消亮屏的退出方法
80 | function quit() {
81 | device.cancelKeepingAwake()
82 | exit()
83 | }
84 |
85 | // 自定义一个findTimeout,find_f是原本的查询器 text('sss').find()
86 | function findTimeout(findF, timeout) {
87 | let c = 0
88 | while (c < timeout / 50) {
89 | let result = findF.find()
90 | if (result.nonEmpty()) return result
91 | sleep(50)
92 | c++
93 | }
94 | return null
95 | }
96 |
97 | // 自定义一个findTextDescMatchesTimeout
98 | function findTextDescMatchesTimeout(reg, timeout) {
99 | let c = 0
100 | while (c < timeout / 50) {
101 | let result = textMatches(reg).findOnce() || descMatches(reg).findOnce()
102 | if (result) return result
103 | sleep(50)
104 | c++
105 | }
106 | return null
107 | }
108 |
109 | // 打开任务列表
110 | function openTaskList() {
111 | let c = textContains('KEYBWc').findOne(5000)
112 | if (c) {
113 | console.log('使用默认方法尝试打开任务列表')
114 | c.click()
115 | } else {
116 | throw '无法找到任务列表入口'
117 | }
118 | if (!textContains('task_detail').findOne(8000)) {
119 | console.log('默认方式打开失败,二次尝试')
120 | console.log('首先检测弹窗')
121 | for (let i = 0; i < 2 && text('关闭').findOne(2000); i++) { // 关闭弹窗
122 | console.log('检测到弹窗,关闭')
123 | click('关闭')
124 | sleep(2000)
125 | }
126 | console.log('出现未能自动关闭的弹窗请手动关闭')
127 | sleep(2000)
128 | // let right = c.bounds().right
129 | // let left = c.bounds().left
130 | // let top = c.bounds().top
131 | // let bottom = c.bounds().bottom
132 | // click(random(right,left), random(top, bottom))
133 | click(c.bounds().centerX(), c.bounds().centerY())
134 | console.log('已点击,等待任务列表出现')
135 | if (!textContains('KEYBWc').findOne(8000)) {
136 | throw '无法打开任务列表'
137 | }
138 | }
139 | }
140 |
141 | // 查找任务按钮
142 | function findTask() {
143 | var jumpButtonFind = textMatches(/去浏览|去完成/) // 找进入任务的按钮,10秒
144 | var jumpButtons = findTimeout(jumpButtonFind, 10000)
145 |
146 | if (!jumpButtons) {
147 | return null
148 | }
149 |
150 | for (var i = 0; i < jumpButtons.length; i++) {
151 | var taskName, content
152 | try {
153 | taskName = jumpButtons[i].parent().child(1).text()
154 | content = jumpButtons[i].parent().child(2).child(0).text()
155 | } catch (err) {
156 | console.log(err)
157 | continue
158 | }
159 | if (taskName) {
160 | // if (taskName.match(/签到领/)) {
161 | // console.log('进行签到任务')
162 | // sleep(1000)
163 | // jumpButtons[i].click()
164 | // sleep(8000)
165 | // return findTask()
166 | // }
167 | // if (!(taskName.match(/淘金币|提醒|话费|斗地主|消消乐|流浪猫|开88|扔喵糖|占领|邀请|登录|组队|参与|施肥|浇水|特价版|小鸡|消除|穿搭|森林|点淘|人生|我的淘宝|庄园/) || content.match(/小互动/))) {
168 | // return [taskName, jumpButtons[i]]
169 | // }
170 | return [taskName, jumpButtons[i]]
171 | }
172 | }
173 | return null
174 | }
175 |
176 | function liulan() {
177 | // if (textMatches(/.*浏览.*/).findOne(10000)) { // 等待浏览出现
178 | // let v = className('android.support.v7.widget.RecyclerView').findOnce() // 滑动
179 | // if (v) {
180 | // sleep(1000)
181 | // v.scrollForward()
182 | // }
183 | // }
184 |
185 | // textMatches(/.*浏览得奖励.*/).findOne(15000) // 等待开始
186 | let finish_c = 0
187 | while (finish_c < 50) { // 0.5 * 50 = 25 秒,防止死循环
188 | if (textMatches(/.*下拉浏览.*/).exists()) {
189 | console.log('进行模拟滑动')
190 | swipe(device.width / 2, device.height - 200, device.width / 2 + 20, device.height - 500, 2000)
191 | }
192 | let finish_reg = /.*任务已完成[\s\S]*|.*失败.*|.*上限.*|.*开小差.*/
193 | if (textMatches(finish_reg).exists() || descMatches(finish_reg).exists()) { // 等待已完成出现,有可能失败
194 | break
195 | }
196 | if (textMatches(/.*4ZSN0.*/).exists() && !textMatches(/.*浏览.*/).exists()) { // 标识加载且已浏览消失代表完成
197 | break
198 | }
199 | if (textMatches(/.*休息会呗.*/).exists()) {
200 | alert('触发淘宝验证', '请手动验证后返回淘宝首页,重新执行任务')
201 | console.log('异常退出。')
202 | quit()
203 | }
204 | if (textContains('互动奖励').exists() ||
205 | descContains('互动奖励').exists()) {
206 | console.log('跳过互动任务')
207 | break
208 | }
209 | sleep(500)
210 | finish_c++
211 | }
212 |
213 | if (finish_c > 49) {
214 | console.log('未检测到任务完成标识。返回。')
215 | // console.log('如果你认为这是一个bug请截图反馈。')
216 | // console.log('一般情况下,二次运行脚本即可。')
217 | // console.log('请手动切换回主页面')
218 | // device.cancelKeepingAwake()
219 | // quit()
220 | back()
221 | sleep(1000)
222 | // TODO: 返回检测
223 | if (!textContains('KEYBWc').findOne(5000)) {
224 | console.log('似乎没有返回,二次尝试')
225 | back()
226 | }
227 | return
228 | }
229 |
230 | console.log('任务完成,返回')
231 |
232 | sleep(1000)
233 | back()
234 | sleep(1000)
235 | if (!textContains('KEYBWc').findOne(5000)) {
236 | console.log('似乎没有返回,二次尝试')
237 | back()
238 | }
239 | }
240 |
241 | if (autoOpen) {
242 | // 打开淘宝活动页面
243 | console.log('正在打开淘宝...')
244 | var url = 's.click.taobao.com/6htqRGu'
245 |
246 | app.startActivity({
247 | action: "VIEW",
248 | data: "taobao://" + url
249 | })
250 | sleep(2000)
251 |
252 | console.log('等待页面加载...')
253 | } else {
254 | console.log('请在30秒内打开淘宝做任务赢红包活动页,48¥ CZ0001 9eJedLXdmv0¥ https://m.tb.cn/h.Uw6N4h0')
255 | }
256 | if (!textContains('KEYBWc').findOne(30000)) {
257 | console.log('未能检测到任务页,退出')
258 | quit()
259 | }
260 |
261 | console.log('已打开活动,准备搜索任务')
262 | sleep(5000)
263 |
264 | while (true) {
265 | console.log('准备打开任务列表')
266 | sleep(2000)
267 | openTaskList()
268 | console.log('寻找任务入口...')
269 | var jumpButton = findTask()
270 |
271 | if (jumpButton == null) {
272 | console.log('没找到合适的任务。也许任务已经全部做完了。退出。互动任务不会自动完成。')
273 | console.log('请手动切换回主页面')
274 | alert('任务已完成', '别忘了在脚本主页领取618红包!互动任务需要手动完成。')
275 | quit()
276 | }
277 |
278 | console.log('进行' + jumpButton[0] + '任务')
279 | sleep(2000)
280 |
281 | if (jumpButton[0].match(/精选/)) {
282 | jumpButton[1].click()
283 | liulan()
284 | } else if (jumpButton[0].match(/浏览点击/)) {
285 | jumpButton[1].click()
286 | sleep(2000)
287 | if (jumpButton[0].match(/直播/)) {
288 | if (!text('直播尖货').findOne(10000)) {
289 | throw '打开活动页失败'
290 | }
291 | }
292 | let count = jumpButton[0].match(/点击(\d*)个/)[1]
293 | let done = 0
294 | try {
295 | let anchor = textContains('已浏览商品').findOne(5000).parent().child(1).children()
296 | done = parseInt(anchor[1].text())
297 | count -= done
298 | } catch(err) {
299 | console.log('获取数量失败,使用默认值', err)
300 | }
301 |
302 | console.log('点击', count, '个商品')
303 | let buttons = textMatches(/.*马上抢.*|.*付定随机.*|.*立付.*|.*爆款热卖中.*|.*爆卖.*/).find()
304 | if (!buttons) {
305 | throw '无法找到马上抢按钮,任务失败'
306 | }
307 |
308 | console.log('从第', done, '个开始寻找')
309 | for (let i = 0; i < 10 && count + done > buttons.length; i++) {
310 | console.log('商品数量不足,向下翻页', buttons.length)
311 | scrollDown()
312 | sleep(2000)
313 | scrollDown()
314 | sleep(2000)
315 | buttons = textMatches(/.*马上抢.*|.*付定随机.*|.*立付.*|.*爆款热卖中.*|.*爆卖.*/).find()
316 | console.log(buttons.length)
317 | }
318 | if (count + done > buttons.length) {
319 | console.log('商品数量不足,分次完成')
320 | count = buttons.length - done
321 | }
322 |
323 | for (let i = done; i < count + done; i++) {
324 | console.log('第' , i+1-done, '次,点击第', i + 1, '个')
325 | sleep(2000)
326 | buttons[i].click()
327 | console.log('等待加载')
328 | if (text('加入购物车').findOne(10000) || currentActivity() == 'com.taobao.android.detail.wrapper.activity.DetailActivity') {
329 | console.log('商品打开成功,返回')
330 | sleep(2000)
331 | back()
332 | if (jumpButton[0].match(/直播/)) {
333 | if (!text('直播尖货').findOne(10000)) {
334 | console.log('似乎没有返回,二次尝试')
335 | back()
336 | }
337 | } else {
338 | if (!textContains('KEYBWc').findOne(10000)) {
339 | console.log('似乎没有返回,二次尝试')
340 | back()
341 | }
342 | }
343 | } else {
344 | throw '商品页未能加载'
345 | }
346 | }
347 | if (jumpButton[0].match(/直播/)) {
348 | console.log('返回')
349 | back()
350 | sleep(1000)
351 | if (!textContains('KEYBWc').findOne(5000)) {
352 | console.log('似乎没有返回,二次尝试')
353 | back()
354 | sleep(1000)
355 | }
356 | }
357 | } else {
358 | throw '未知任务类型' + jumpButton[0] + '请反馈!'
359 | }
360 |
361 | console.log('等待页面刷新...')
362 | sleep(2000)
363 | }
364 | } catch (err) {
365 | device.cancelKeepingAwake()
366 | if (err.toString() != 'JavaException: com.stardust.autojs.runtime.exception.ScriptInterruptedException: null') {
367 | console.error(err)
368 | }
369 | }
370 |
--------------------------------------------------------------------------------
/tb_nl.js:
--------------------------------------------------------------------------------
1 | if (!auto.service) {
2 | toast('无障碍服务未启动!退出!')
3 | exit()
4 | }
5 |
6 |
7 | // alert('请把手机放稳,不要摇晃!', '不然有时候会跳出合伙赢喵币,导致任务阻塞')
8 |
9 | function getSetting() {
10 | let indices = []
11 | autoOpen && indices.push(0)
12 | autoMute && indices.push(1)
13 | indices.push(2)
14 |
15 | let settings = dialogs.multiChoice('任务设置', ['自动打开淘宝进入活动。多开或任务列表无法自动打开时取消勾选(注意,分身运行淘宝大概率导致任务收益变为100)', '自动调整媒体音量为0。以免直播任务发出声音,首次选择需要修改系统设置权限', '此选项用于保证选择的处理,勿动!'], indices)
16 |
17 | if (settings.length == 0) {
18 | toast('取消选择,任务停止')
19 | exit()
20 | }
21 |
22 | if (settings.indexOf(0) != -1) {
23 | storage.put('autoOpen', true)
24 | autoOpen = true
25 | } else {
26 | storage.put('autoOpen', false)
27 | autoOpen = false
28 | }
29 | if (settings.indexOf(1) != -1) {
30 | storage.put('autoMute', true)
31 | autoMute = true
32 | } else {
33 | storage.put('autoMute', false)
34 | autoMute = false
35 | }
36 | }
37 |
38 | let storage = storages.create("tb_task");
39 | let autoOpen = storage.get('autoOpen', true)
40 | let autoMute = storage.get('autoMute', true)
41 | getSetting()
42 |
43 | if (autoMute) {
44 | try {
45 | device.setMusicVolume(0)
46 | toast('成功设置媒体音量为0')
47 | } catch (err) {
48 | alert('首先需要开启权限,请开启后再次运行脚本')
49 | exit()
50 | }
51 | }
52 |
53 | console.show()
54 | console.log('开始完成能量任务...')
55 | console.log('按音量下键停止')
56 |
57 | device.keepScreenDim(60 * 60 * 1000)
58 |
59 | function registerKey() {
60 | try {
61 | events.observeKey()
62 | } catch (err) {
63 | console.log('监听音量键停止失败,应该是无障碍权限出错,请关闭软件后台任务重新运行。')
64 | console.log('如果还是不行可以重启手机尝试。')
65 | quit()
66 | }
67 | events.onKeyDown('volume_down', function (event) {
68 | console.log('喵币任务脚本停止了')
69 | console.log('请手动切换回主页面')
70 | device.cancelKeepingAwake()
71 | exit()
72 | })
73 | }
74 | threads.start(registerKey)
75 |
76 | // 全局try catch,应对无法显示报错
77 | try {
78 |
79 | // 自定义去取消亮屏的退出方法
80 | function quit() {
81 | device.cancelKeepingAwake()
82 | exit()
83 | }
84 |
85 | // 自定义一个findTimeout,find_f是原本的查询器 text('sss').find()
86 | function findTimeout(findF, timeout) {
87 | let c = 0
88 | while (c < timeout / 50) {
89 | let result = findF.find()
90 | if (result.nonEmpty()) return result
91 | sleep(50)
92 | c++
93 | }
94 | return null
95 | }
96 |
97 | // 自定义一个findTextDescMatchesTimeout
98 | function findTextDescMatchesTimeout(reg, timeout) {
99 | let c = 0
100 | while (c < timeout / 50) {
101 | let result = textMatches(reg).findOnce() || descMatches(reg).findOnce()
102 | if (result) return result
103 | sleep(50)
104 | c++
105 | }
106 | return null
107 | }
108 |
109 | // 打开任务列表
110 | function openTaskList() {
111 | let c = idContains('node_2_icon').findOne(5000)
112 | if (c) {
113 | console.log('使用默认方法尝试打开任务列表')
114 | c.click()
115 | } else {
116 | throw '无法找到任务列表入口'
117 | }
118 | if (!textContains('task_detail').findOne(8000)) {
119 | console.log('默认方式打开失败,二次尝试')
120 | console.log('首先检测弹窗')
121 | try {
122 | idContains('J_wfdlgwrap_5').findOnce().child(0).click()
123 | sleep(1000)
124 | } catch (err) {
125 | console.log(err)
126 | console.log('领红包弹窗关闭失败。此问题不影响运行')
127 | }
128 | try {
129 | idContains('CLOSE').findOnce().click()
130 | sleep(1000)
131 | } catch (err) {
132 | console.log(err)
133 | console.log('其他弹窗关闭失败。此问题不影响运行')
134 | }
135 | console.log('出现未能自动关闭的弹窗请手动关闭')
136 | sleep(2000)
137 | // let right = c.bounds().right
138 | // let left = c.bounds().left
139 | // let top = c.bounds().top
140 | // let bottom = c.bounds().bottom
141 | // click(random(right,left), random(top, bottom))
142 | click(c.bounds().centerX(), c.bounds().centerY())
143 | console.log('已点击,等待任务列表出现')
144 | if (!textContains('task_detail').findOne(8000)) {
145 | throw '无法打开任务列表'
146 | }
147 | }
148 | }
149 |
150 | // TODO:
151 | // 查找任务按钮
152 | function findTask() {
153 | var jumpButtonFind = textMatches(/去浏览|去完成/) // 找进入任务的按钮,10秒
154 | var jumpButtons = findTimeout(jumpButtonFind, 10000)
155 |
156 | if (!jumpButtons) {
157 | return null
158 | }
159 |
160 | for (var i = 0; i < jumpButtons.length; i++) {
161 | var taskName, content
162 | try {
163 | taskName = jumpButtons[i].parent().child(1).text()
164 | content = jumpButtons[i].parent().child(2).child(0).text()
165 | } catch (err) {
166 | console.log(err)
167 | continue
168 | }
169 | if (taskName) {
170 | // if (taskName.match(/签到领/)) {
171 | // console.log('进行签到任务')
172 | // sleep(1000)
173 | // jumpButtons[i].click()
174 | // sleep(8000)
175 | // return findTask()
176 | // }
177 | // if (!(taskName.match(/淘金币|提醒|话费|斗地主|消消乐|流浪猫|开88|扔喵糖|占领|邀请|登录|组队|参与|施肥|浇水|特价版|小鸡|消除|穿搭|森林|点淘|人生|我的淘宝|庄园/) || content.match(/小互动/))) {
178 | // return [taskName, jumpButtons[i]]
179 | // }
180 | return [taskName, jumpButtons[i]]
181 | }
182 | }
183 | return null
184 | }
185 |
186 | // TODO:
187 | function liulan() {
188 | // if (textMatches(/.*浏览.*/).findOne(10000)) { // 等待浏览出现
189 | // let v = className('android.support.v7.widget.RecyclerView').findOnce() // 滑动
190 | // if (v) {
191 | // sleep(1000)
192 | // v.scrollForward()
193 | // }
194 | // }
195 |
196 | // textMatches(/.*浏览得奖励.*/).findOne(15000) // 等待开始
197 | let finish_c = 0
198 | while (finish_c < 60) { // 0.5 * 60 =30 秒,防止死循环
199 | if (textMatches(/.*下拉浏览.*/).exists() || textContains('下滑').exists()) {
200 | console.log('进行模拟滑动')
201 | swipe(device.width / 2, device.height - 200, device.width / 2 + 20, device.height - 500, 2000)
202 | continue
203 | }
204 | let finish_reg = /.*任务已完成[\s\S]*|.*失败.*|.*上限.*|.*开小差.*/
205 | if (textMatches(finish_reg).exists() || descMatches(finish_reg).exists()) { // 等待已完成出现,有可能失败
206 | break
207 | }
208 | if (textMatches(/.*休息会呗.*/).exists()) {
209 | alert('触发淘宝验证', '请手动验证后返回淘宝首页,重新执行任务')
210 | console.log('异常退出。')
211 | quit()
212 | }
213 | if (textContains('互动奖励').exists() ||
214 | descContains('互动奖励').exists()) {
215 | console.log('跳过互动任务')
216 | break
217 | }
218 | if (finish_c % 5 == 0) {
219 | console.log('滑动防止页面卡顿')
220 | swipe( device.width / 2, device.height - 400, device.width / 2 + 20, device.height - 500, 500)
221 | // finish_c = finish_c + 5
222 | }
223 | sleep(500)
224 | finish_c++
225 | }
226 |
227 | if (finish_c > 59) {
228 | console.log('未检测到任务完成标识。返回。')
229 | return false
230 | }
231 |
232 | console.log('任务完成')
233 | return true
234 | }
235 |
236 | // TODO:
237 | function backToList() {
238 | console.log('返回上级')
239 | back()
240 | sleep(1000)
241 | if (!idContains('node_2_icon').findOne(5000)) {
242 | console.log('似乎没有返回,二次尝试')
243 | back()
244 | }
245 | sleep(1000)
246 | }
247 |
248 | if (autoOpen) {
249 | // 打开淘宝活动页面
250 | console.log('正在打开淘宝...')
251 |
252 | app.startActivity({
253 | action: "VIEW",
254 | data: "taobao://s.click.taobao.com/FS8zAGu"
255 | })
256 | sleep(2000)
257 |
258 | console.log('等待页面加载...')
259 | } else {
260 | console.log('请在30秒内打开淘宝做任务赢红包活动页 88¥ CZ3457 ekQIdp0kJjm¥ https://m.tb.cn/h.UxaRSaD ')
261 | }
262 | if (!idContains('node_2_icon').findOne(30000)) {
263 | console.log('未能检测到任务页,退出')
264 | quit()
265 | }
266 |
267 | console.log('已打开活动,准备搜索任务')
268 | sleep(2000)
269 |
270 | console.log('首先关闭弹窗')
271 | try {
272 | idContains('J_wfdlgwrap_5').findOnce().child(0).click()
273 | sleep(5000)
274 | console.log('领红包弹窗已关闭')
275 | } catch (err) {
276 | console.log(err)
277 | console.log('领红包弹窗关闭失败。此问题不影响运行')
278 | }
279 | try {
280 | idContains('CLOSE').findOnce().click()
281 | sleep(2000)
282 | console.log('其他弹窗已关闭')
283 | } catch (err) {
284 | console.log(err)
285 | console.log('其他弹窗关闭失败。此问题不影响运行')
286 | }
287 | console.log('检测任务列表是否打开')
288 | if (textContains('task_detail').findOne(5000)) {
289 | console.log('先关闭列表')
290 | idContains('close_btn').findOnce().click()
291 | sleep(2000)
292 | }
293 |
294 | while (true) {
295 | console.log('准备打开任务列表')
296 | sleep(2000)
297 | openTaskList()
298 | console.log('寻找任务入口...')
299 | var jumpButton = findTask()
300 |
301 | if (jumpButton == null) {
302 | console.log('没找到合适的任务。也许任务已经全部做完了。退出。互动任务不会自动完成。')
303 | console.log('请手动切换回主页面')
304 | alert('任务已完成', '别忘了在脚本主页领取双11红包!互动任务需要手动完成。')
305 | quit()
306 | }
307 |
308 | console.log('进行' + jumpButton[0] + '任务')
309 | sleep(2000)
310 |
311 | if (jumpButton[0].match(/商品/)) {
312 | jumpButton[1].click()
313 | sleep(2000)
314 | let count = jumpButton[0].match(/浏览(\d*)个/)[1]
315 | console.log('等待页面')
316 | if (!textContains('超红精选热卖').findOne(8000)) {
317 | throw '商品页面未加载'
318 | }
319 | try {
320 | count -= idContains('J_wf_node_2_time').findOne(5000).text()
321 | } catch(err) {
322 | console.log('获取数量失败,使用默认值', err)
323 | }
324 | console.log('点击', count, '个商品')
325 | let buttons = textContains('q75').find()
326 | if (!buttons) {
327 | throw '无法找到商品,任务失败'
328 | }
329 | for (let i = 0; i < 10 && count > buttons.length; i++) {
330 | console.log('商品数量不足,向下翻页', buttons.length)
331 | scrollDown()
332 | sleep(2000)
333 | scrollDown()
334 | sleep(2000)
335 | buttons = textContains('q75').find()
336 | console.log(buttons.length)
337 | }
338 | if (count > buttons.length) {
339 | console.log('商品数量不足,分次完成')
340 | count = buttons.length
341 | }
342 |
343 | for (let i = 0; i < count; i++) {
344 | console.log('点击第', i + 1, '个')
345 | sleep(2000)
346 | buttons[i].click()
347 | console.log('等待加载')
348 | if (textMatches(/加入购物车|粉丝福利购/).findOne(10000) || currentActivity() == 'com.taobao.android.detail.wrapper.activity.DetailActivity') {
349 | console.log('商品打开成功,返回')
350 | back()
351 | if (!textContains('超红精选热卖').findOne(10000)) {
352 | console.log('似乎没有返回,二次尝试')
353 | back()
354 | }
355 | } else {
356 | throw '商品页未能加载'
357 | }
358 | }
359 | // sleep(1000)
360 | backToList()
361 | } else if (jumpButton[0].match(/搜索/)) {
362 | jumpButton[1].click()
363 | console.log('等待搜索')
364 | sleep(2000)
365 | textContains('搜索发现').findOne(8000)
366 | let listView = className('android.widget.ListView').findOne(2000).child(0)
367 | if (listView.childCount() == 1) {
368 | listView.child(0).click()
369 | } else {
370 | listView.child(1).click()
371 | }
372 | liulan()
373 | sleep(1000)
374 | back()
375 | backToList()
376 | } else if (jumpButton[0].match(/为你推荐|主会场/)) {
377 | jumpButton[1].click()
378 | liulan()
379 | } else {
380 | jumpButton[1].click()
381 | liulan()
382 | // sleep(1000)
383 | // back()
384 | backToList()
385 | }
386 |
387 | console.log('等待页面刷新...')
388 | sleep(2000)
389 | }
390 | } catch (err) {
391 | device.cancelKeepingAwake()
392 | if (err.toString() != 'JavaException: com.stardust.autojs.runtime.exception.ScriptInterruptedException: null') {
393 | console.error(err)
394 | }
395 | }
396 |
--------------------------------------------------------------------------------
/version:
--------------------------------------------------------------------------------
1 | {
2 | "version": "2.0.6",
3 | "versionCode": "206",
4 | "log": "1.超级喵运会活动(黑号风险谨慎使用)\n2.增加淘宝能量任务",
5 | "url":"https://wwp.lanzoui.com/iR0ML0xnewcf"
6 | }
7 |
--------------------------------------------------------------------------------
/wechart.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ljt0515/618/690c545eb359796e15910e51275d0a765f1d58d9/wechart.png
--------------------------------------------------------------------------------