Пример #1
0
    def handle_cn_user_agreement(self):
        if not self._user_agreement_timer.reached():
            return False

        confirm = self.image_color_button(area=(640, 360, 1280, 720),
                                          color=(78, 189, 234),
                                          color_threshold=250,
                                          encourage=25,
                                          name='AGREEMENT_CONFIRM')
        if confirm is None:
            return False
        scroll = self.image_color_button(area=(640, 0, 1280, 720),
                                         color=(182, 189, 202),
                                         color_threshold=250,
                                         encourage=5,
                                         name='AGREEMENT_SCROLL')
        if scroll is not None:
            # User agreement
            p1 = random_rectangle_point(scroll.button)
            p2 = random_rectangle_point(scroll.move((0, 350)).button)
            self.device.swipe(p1, p2, name='AGREEMENT_SCROLL')
            self.device.click(confirm)
            self._user_agreement_timer.reset()
            return True
        else:
            # User login
            self.device.click(confirm)
            self._user_agreement_timer.reset()
            return True
Пример #2
0
    def run(self):
        logger.hr('Benchmark', level=1)
        self.device.uninstall_minicap()
        self.ui_goto_campaign()
        self.campaign_set_chapter('7-2')

        data = []
        if self.config.Benchmark_AdbScreenshot:
            data.append(['ADB', self.benchmark_test(self.device.screenshot_adb)])
        if self.config.Benchmark_Uiautomator2Screenshot:
            data.append(['uiautomator2', self.benchmark_test(self.device.screenshot_uiautomator2)])
        if self.config.Benchmark_AscreencapScreenshot:
            data.append(['aScreenCap', self.benchmark_test(self.device.screenshot_ascreencap)])
        screenshot = data

        data = []
        area = (124, 4, 649, 106)  # Somewhere save to click.
        if self.config.Benchmark_AdbClick:
            x, y = random_rectangle_point(area)
            data.append(['ADB', self.benchmark_test(self.device.click_adb, x, y)])
        if self.config.Benchmark_Uiautomator2Click:
            x, y = random_rectangle_point(area)
            data.append(['uiautomator2', self.benchmark_test(self.device.click_uiautomator2, x, y)])
        if self.config.Benchmark_MinitouchClick:
            x, y = random_rectangle_point(area)
            data.append(['minitouch', self.benchmark_test(self.device.click_minitouch, x, y)])
        if self.config.Benchmark_HermitClick:
            x, y = random_rectangle_point(area)
            data.append(['Hermit', self.benchmark_test(self.device.click_hermit, x, y)])
        control = data

        def compare(res):
            res = res[1]
            if not isinstance(res, (int, float)):
                return 100
            else:
                return res

        logger.hr('Benchmark Results', level=1)
        if screenshot:
            self.show(test='Screenshot', data=screenshot, evaluate_func=self.evaluate_screenshot)
            fastest = sorted(screenshot, key=lambda item: compare(item))[0]
            logger.info(f'Recommend screenshot method: {fastest[0]} ({float2str(fastest[1])})')
        if control:
            self.show(test='Control', data=control, evaluate_func=self.evaluate_click)
            fastest = sorted(control, key=lambda item: compare(item))[0]
            logger.info(f'Recommend control method: {fastest[0]} ({float2str(fastest[1])})')
Пример #3
0
 def appear_then_click(xpath):
     b = HierarchyButton(h, xpath)
     if b:
         point = random_rectangle_point(b.button)
         logger.info(f'Click {point2str(*point)} @ {b}')
         self.click_adb(*point)
         return True
     else:
         return False
Пример #4
0
    def set(self,
            position,
            main,
            random_range=(-0.05, 0.05),
            skip_first_screenshot=True):
        """
        Set scroll to a specific position.

        Args:
            position (float, int): 0 to 1.
            main (ModuleBase):
            random_range (tuple(int, float)):
            skip_first_screenshot:
        """
        logger.info(f'{self.name} set to {position}')
        self.drag_interval.clear()
        if position == 0:
            random_range = np.subtract(0, self.edge_add)
        if position == 1:
            random_range = self.edge_add

        while 1:
            if skip_first_screenshot:
                skip_first_screenshot = False
            else:
                main.device.screenshot()

            current = self.cal_position(main)
            if abs(position - current) < self.drag_threshold:
                break

            if self.drag_interval.reached():
                p1 = random_rectangle_point(self.position_to_screen(current),
                                            n=1)
                p2 = random_rectangle_point(self.position_to_screen(
                    position, random_range=random_range),
                                            n=1)
                main.device.drag(p1,
                                 p2,
                                 shake=(0, 0),
                                 point_random=(0, 0, 0, 0),
                                 shake_random=(0, 0, 0, 0))
                main.device.sleep(0.3)
                self.drag_interval.reset()
Пример #5
0
    def _commission_swipe_to_top(self, bar_padding_y=10):
        if self.appear(COMMISSION_SCROLL_TOP):
            # Already at top
            return False

        mean = np.mean(self.device.image.crop(COMMISSION_SCROLL.area), axis=1)
        bar = np.where(color_similar_1d(mean, color=(247, 211, 66)))[0]
        if len(bar) < bar_padding_y * 2:
            # No scroll found.
            return False

        bar = (COMMISSION_SCROLL.area[0], np.min(bar) + bar_padding_y,
               COMMISSION_SCROLL.area[2], np.max(bar) - bar_padding_y)
        p1 = random_rectangle_point(bar)
        p2 = random_rectangle_point(COMMISSION_SCROLL_TOP.area)
        self.device.drag(p1, p2, shake=(15, 0), point_random=(0, 0, 0, 0))
        self.device.sleep(0.3)
        self.device.screenshot()
        return True
Пример #6
0
    def set(self, position, main, random_range=(-0.05, 0.05), distance_check=True, skip_first_screenshot=True):
        """
        Set scroll to a specific position.

        Args:
            position (float, int): 0 to 1.
            main (ModuleBase):
            random_range (tuple(int, float)):
            distance_check (bool): Whether to drop short swipes
            skip_first_screenshot:
        """
        logger.info(f'{self.name} set to {position}')
        self.drag_interval.clear()
        if position == 0:
            random_range = np.subtract(0, self.edge_add)
        if position == 1:
            random_range = self.edge_add

        while 1:
            if skip_first_screenshot:
                skip_first_screenshot = False
            else:
                main.device.screenshot()

            current = self.cal_position(main)
            if abs(position - current) < self.drag_threshold:
                break
            if not self.length:
                logger.warning('Scroll disappeared, assume scroll set')
                break

            if self.drag_interval.reached():
                p1 = random_rectangle_point(self.position_to_screen(current), n=1)
                p2 = random_rectangle_point(self.position_to_screen(position, random_range=random_range), n=1)
                main.device.swipe(p1, p2, name=self.name, distance_check=distance_check)
                main.device.sleep(0.3)
                self.drag_interval.reset()
Пример #7
0
    def run(self):
        logger.hr('Benchmark', level=1)
        self.device.remove_minicap()
        self.ui_ensure(page_campaign)

        data = []
        if self.config.Benchmark_TestScreenshotMethod:
            data.append(
                ['ADB',
                 self.benchmark_test(self.device._screenshot_adb)])
            data.append(
                ['WSA',
                 self.benchmark_test(self.device._screenshot_wsa)])
            data.append([
                'uiautomator2',
                self.benchmark_test(self.device._screenshot_uiautomator2)
            ])
            data.append([
                'aScreenCap',
                self.benchmark_test(self.device._screenshot_ascreencap)
            ])
        screenshot = data

        data = []
        area = (124, 4, 649, 106)  # Somewhere save to click.
        if self.config.Benchmark_TestClickMethod:
            x, y = random_rectangle_point(area)
            data.append(
                ['ADB',
                 self.benchmark_test(self.device._click_adb, x, y)])
            x, y = random_rectangle_point(area)
            data.append(
                ['WSA',
                 self.benchmark_test(self.device._click_wsa, x, y)])
            x, y = random_rectangle_point(area)
            data.append([
                'uiautomator2',
                self.benchmark_test(self.device._click_uiautomator2, x, y)
            ])
            x, y = random_rectangle_point(area)
            data.append([
                'minitouch',
                self.benchmark_test(self.device._click_minitouch, x, y)
            ])
        control = data

        def compare(res):
            res = res[1]
            if not isinstance(res, (int, float)):
                return 100
            else:
                return res

        logger.hr('Benchmark Results', level=1)
        if screenshot:
            self.show(test='Screenshot',
                      data=screenshot,
                      evaluate_func=self.evaluate_screenshot)
            fastest = sorted(screenshot, key=lambda item: compare(item))[0]
            logger.info(
                f'Recommend screenshot method: {fastest[0]} ({float2str(fastest[1])})'
            )
        if control:
            self.show(test='Control',
                      data=control,
                      evaluate_func=self.evaluate_click)
            fastest = sorted(control, key=lambda item: compare(item))[0]
            logger.info(
                f'Recommend control method: {fastest[0]} ({float2str(fastest[1])})'
            )