Python使用Appium实现自动化操作手机入门教学

node --version
npm --version

npm install -g appium

appium

pip install appium-python-client

from appium import webdriver
from appium.webdriver.common.appiumby import appiumby
from appium.options.android import uiautomator2options
import time
import unittest

def setup_driver():
    # 配置appium选项
    options = uiautomator2options()
    
    # 设置设备基本信息
    options.platform_name = 'android'
    options.platform_version = '12'  # 根据你的设备版本修改
    options.device_name = 'android emulator'
    options.automation_name = 'uiautomator2'
    
    # 设置应用信息
    options.app_package = 'com.android.calculator2'
    options.app_activity = 'com.android.calculator2.calculator'
    
    # 其他设置
    options.no_reset = true  # 不重置应用状态
    
    # 连接appium服务器
    driver = webdriver.remote('http://localhost:4723', options=options)
    
    return driver

def calculator_operations(driver):
    """执行计算器操作"""
    try:
        # 等待计算器加载完成
        time.sleep(2)
        
        # 定位数字按钮和操作符
        # 注意：不同设备上的计算器应用可能具有不同的元素id
        # 这里使用的是android原生计算器的元素id
        
        # 点击数字 7
        btn_7 = driver.find_element(appiumby.id, 'com.android.calculator2:id/digit_7')
        btn_7.click()
        
        # 点击加号
        btn_plus = driver.find_element(appiumby.id, 'com.android.calculator2:id/op_add')
        btn_plus.click()
        
        # 点击数字 8
        btn_8 = driver.find_element(appiumby.id, 'com.android.calculator2:id/digit_8')
        btn_8.click()
        
        # 点击等号
        btn_equals = driver.find_element(appiumby.id, 'com.android.calculator2:id/eq')
        btn_equals.click()
        
        # 获取结果
        result = driver.find_element(appiumby.id, 'com.android.calculator2:id/result')
        calculated_result = result.text
        
        print(f"计算结果: 7 + 8 = {calculated_result}")
        
        # 验证结果是否正确
        expected_result = '15'
        if calculated_result == expected_result:
            print("测试通过！计算结果正确。")
        else:
            print(f"测试失败！期望结果: {expected_result}, 实际结果: {calculated_result}")
            
        return calculated_result
        
    except exception as e:
        print(f"操作过程中出现错误: {str(e)}")
        return none

class calculatortest(unittest.testcase):
    """计算器测试类"""
    
    def setup(self):
        """测试前置设置"""
        self.driver = setup_driver()
        self.driver.implicitly_wait(10)  # 设置隐式等待时间
        
    def teardown(self):
        """测试后置清理"""
        if self.driver:
            self.driver.quit()
            
    def test_addition_operation(self):
        """测试加法运算"""
        result = calculator_operations(self.driver)
        self.assertequal(result, '15', "加法运算结果不正确")
        
    def test_clear_operation(self):
        """测试清除操作"""
        try:
            # 先输入一些数字
            btn_5 = self.driver.find_element(appiumby.id, 'com.android.calculator2:id/digit_5')
            btn_5.click()
            
            # 点击清除按钮
            btn_clear = self.driver.find_element(appiumby.id, 'com.android.calculator2:id/clr')
            btn_clear.click()
            
            # 验证显示区域是否已清除
            result = self.driver.find_element(appiumby.id, 'com.android.calculator2:id/formula')
            current_display = result.text
            
            # 清除后显示区域应该为空或显示0
            self.asserttrue(not current_display or current_display == '0', 
                          "清除操作未正常工作")
            
        except exception as e:
            self.fail(f"清除操作测试失败: {str(e)}")

def advanced_element_locating(driver):
    """演示高级元素定位方法"""
    
    # 1. 使用xpath定位
    # 通过文本内容定位元素
    element_by_text = driver.find_element(appiumby.xpath, "//*[@text='确定']")
    
    # 通过部分文本内容定位
    element_by_partial_text = driver.find_element(
        appiumby.xpath, "//*[contains(@text, '确定')]"
    )
    
    # 2. 使用accessibility id定位（通常对应content-desc属性）
    element_by_accessibility = driver.find_element(
        appiumby.accessibility_id, "按钮描述"
    )
    
    # 3. 使用class name定位
    elements_by_class = driver.find_elements(
        appiumby.class_name, "android.widget.button"
    )
    
    # 4. 使用android ui automator定位
    element_by_uiautomator = driver.find_element(
        appiumby.android_uiautomator, 
        'new uiselector().text("确定")'
    )
    
    return {
        'by_text': element_by_text,
        'by_partial_text': element_by_partial_text,
        'by_accessibility': element_by_accessibility,
        'by_class': elements_by_class,
        'by_uiautomator': element_by_uiautomator
    }

def gesture_operations(driver):
    """演示手势操作"""
    
    # 获取屏幕尺寸
    window_size = driver.get_window_size()
    screen_width = window_size['width']
    screen_height = window_size['height']
    
    # 1. 滑动操作 - 从底部滑动到顶部
    start_x = screen_width / 2
    start_y = screen_height * 0.8
    end_x = screen_width / 2
    end_y = screen_height * 0.2
    
    driver.swipe(start_x, start_y, end_x, end_y, 1000)
    
    # 2. 滚动操作
    # 滚动到指定元素
    scroll_to_element = driver.find_element(
        appiumby.android_uiautomator,
        'new uiscrollable(new uiselector().scrollable(true))'
        '.scrollintoview(new uiselector().text("目标元素"))'
    )
    
    # 3. 长按操作
    element_to_long_press = driver.find_element(appiumby.id, 'some.element.id')
    driver.long_press(element_to_long_press)
    
    # 4. 拖拽操作
    source_element = driver.find_element(appiumby.id, 'source.element')
    target_element = driver.find_element(appiumby.id, 'target.element')
    driver.drag_and_drop(source_element, target_element)

def handle_popups_and_permissions(driver):
    """处理弹窗和权限请求"""
    
    try:
        # 尝试查找并点击允许按钮
        allow_button = driver.find_element(
            appiumby.id, 'com.android.packageinstaller:id/permission_allow_button'
        )
        allow_button.click()
        print("已处理权限请求")
        
    except exception:
        # 如果找不到特定的允许按钮，尝试其他方式
        try:
            # 使用文本定位允许按钮
            allow_by_text = driver.find_element(
                appiumby.xpath, "//*[@text='允许' or @text='allow']"
            )
            allow_by_text.click()
            print("通过文本定位处理了权限请求")
            
        except exception:
            print("未找到权限请求弹窗或处理失败")
            
    # 处理其他类型的弹窗
    try:
        # 查找确定、好的、知道了等按钮
        confirm_buttons = [
            "确定", "确认", "好的", "知道了", "ok", "okay"
        ]
        
        for button_text in confirm_buttons:
            try:
                confirm_btn = driver.find_element(
                    appiumby.xpath, f"//*[@text='{button_text}']"
                )
                confirm_btn.click()
                print(f"点击了 {button_text} 按钮")
                break
            except exception:
                continue
                
    except exception as e:
        print(f"处理弹窗时出现错误: {str(e)}")

from selenium.webdriver.support.ui import webdriverwait
from selenium.webdriver.support import expected_conditions as ec

def wait_strategies(driver):
    """演示不同的等待策略"""
    
    # 1. 显式等待 - 等待元素可点击
    wait = webdriverwait(driver, 10)
    element = wait.until(
        ec.element_to_be_clickable((appiumby.id, 'some.element.id'))
    )
    element.click()
    
    # 2. 显式等待 - 等待元素可见
    visible_element = wait.until(
        ec.visibility_of_element_located((appiumby.id, 'visible.element'))
    )
    
    # 3. 显式等待 - 等待元素存在（不一定可见）
    present_element = wait.until(
        ec.presence_of_element_located((appiumby.id, 'present.element'))
    )
    
    # 4. 自定义等待条件
    def custom_condition(driver):
        """自定义等待条件"""
        try:
            element = driver.find_element(appiumby.id, 'custom.element')
            return element.is_displayed()
        except exception:
            return false
    
    custom_element = wait.until(custom_condition)
    
    return {
        'clickable': element,
        'visible': visible_element,
        'present': present_element,
        'custom': custom_element
    }

#!/usr/bin/env python3
"""
appium手机操作示例
作者：你的名字
日期：2024年1月
描述：使用python和appium操作手机计算器应用
"""

import time
import unittest
import logging
from appium import webdriver
from appium.webdriver.common.appiumby import appiumby
from appium.options.android import uiautomator2options
from selenium.webdriver.support.ui import webdriverwait
from selenium.webdriver.support import expected_conditions as ec
from selenium.common.exceptions import timeoutexception, nosuchelementexception


# 配置日志
logging.basicconfig(
    level=logging.info,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getlogger(__name__)


class mobileautomationframework:
    """移动自动化框架类"""
    
    def __init__(self, server_url='http://localhost:4723'):
        self.server_url = server_url
        self.driver = none
        self.wait = none
        
    def setup_driver(self, capabilities_dict=none):
        """设置appium驱动"""
        
        if capabilities_dict is none:
            # 默认配置 - android计算器
            capabilities_dict = {
                'platformname': 'android',
                'platformversion': '12',
                'devicename': 'android emulator',
                'automationname': 'uiautomator2',
                'apppackage': 'com.android.calculator2',
                'appactivity': 'com.android.calculator2.calculator',
                'noreset': true,
                'newcommandtimeout': 300
            }
        
        try:
            options = uiautomator2options()
            for key, value in capabilities_dict.items():
                setattr(options, key, value)
                
            logger.info("正在连接appium服务器...")
            self.driver = webdriver.remote(self.server_url, options=options)
            
            # 设置显式等待
            self.wait = webdriverwait(self.driver, 15)
            
            logger.info("appium驱动设置成功")
            return true
            
        except exception as e:
            logger.error(f"设置appium驱动失败: {str(e)}")
            return false
    
    def teardown(self):
        """清理资源"""
        if self.driver:
            self.driver.quit()
            logger.info("appium驱动已关闭")
    
    def find_element_with_wait(self, by, value, timeout=15):
        """带等待的元素查找"""
        wait = webdriverwait(self.driver, timeout)
        return wait.until(ec.presence_of_element_located((by, value)))
    
    def safe_click(self, by, value, timeout=15):
        """安全的点击操作"""
        try:
            element = self.find_element_with_wait(by, value, timeout)
            element.click()
            logger.info(f"成功点击元素: {value}")
            return true
        except exception as e:
            logger.error(f"点击元素失败: {value}, 错误: {str(e)}")
            return false
    
    def take_screenshot(self, filename=none):
        """截取屏幕截图"""
        if filename is none:
            filename = f"screenshot_{int(time.time())}.png"
        
        try:
            self.driver.save_screenshot(filename)
            logger.info(f"截图已保存: {filename}")
            return true
        except exception as e:
            logger.error(f"截图失败: {str(e)}")
            return false
    
    def get_page_source(self):
        """获取页面源代码"""
        try:
            return self.driver.page_source
        except exception as e:
            logger.error(f"获取页面源代码失败: {str(e)}")
            return none


class calculatorautomation(mobileautomationframework):
    """计算器自动化类"""
    
    def __init__(self):
        super().__init__()
        self.number_mapping = {
            '0': 'digit_0', '1': 'digit_1', '2': 'digit_2',
            '3': 'digit_3', '4': 'digit_4', '5': 'digit_5',
            '6': 'digit_6', '7': 'digit_7', '8': 'digit_8',
            '9': 'digit_9'
        }
        self.operator_mapping = {
            '+': 'op_add', '-': 'op_sub', 
            '*': 'op_mul', '/': 'op_div'
        }
    
    def input_number(self, number):
        """输入数字"""
        if not isinstance(number, (int, str)):
            raise valueerror("数字必须是整数或字符串")
        
        number_str = str(number)
        for digit in number_str:
            if digit in self.number_mapping:
                element_id = f"com.android.calculator2:id/{self.number_mapping[digit]}"
                self.safe_click(appiumby.id, element_id)
                time.sleep(0.1)  # 短暂延迟，确保输入稳定
            else:
                logger.warning(f"无法识别的数字: {digit}")
    
    def input_operator(self, operator):
        """输入操作符"""
        if operator not in self.operator_mapping:
            raise valueerror(f"不支持的操作符: {operator}")
        
        element_id = f"com.android.calculator2:id/{self.operator_mapping[operator]}"
        self.safe_click(appiumby.id, element_id)
    
    def calculate(self, num1, operator, num2):
        """执行计算"""
        logger.info(f"执行计算: {num1} {operator} {num2}")
        
        # 输入第一个数字
        self.input_number(num1)
        
        # 输入操作符
        self.input_operator(operator)
        
        # 输入第二个数字
        self.input_number(num2)
        
        # 点击等号
        self.safe_click(appiumby.id, 'com.android.calculator2:id/eq')
        
        # 获取结果
        return self.get_result()
    
    def get_result(self):
        """获取计算结果"""
        try:
            result_element = self.find_element_with_wait(
                appiumby.id, 'com.android.calculator2:id/result'
            )
            result = result_element.text
            logger.info(f"计算结果: {result}")
            return result
        except exception as e:
            logger.error(f"获取结果失败: {str(e)}")
            return none
    
    def clear_calculator(self):
        """清除计算器"""
        self.safe_click(appiumby.id, 'com.android.calculator2:id/clr')
        logger.info("计算器已清除")


class testcalculatoroperations(unittest.testcase):
    """计算器操作测试类"""
    
    @classmethod
    def setupclass(cls):
        """测试类设置"""
        cls.calculator = calculatorautomation()
        success = cls.calculator.setup_driver()
        if not success:
            raise exception("无法初始化appium驱动")
    
    @classmethod
    def teardownclass(cls):
        """测试类清理"""
        cls.calculator.teardown()
    
    def setup(self):
        """单个测试设置"""
        # 确保每次测试前计算器是清除状态
        self.calculator.clear_calculator()
        time.sleep(1)
    
    def test_addition(self):
        """测试加法"""
        result = self.calculator.calculate(15, '+', 7)
        self.assertequal(result, '22', "加法测试失败")
    
    def test_subtraction(self):
        """测试减法"""
        result = self.calculator.calculate(20, '-', 8)
        self.assertequal(result, '12', "减法测试失败")
    
    def test_multiplication(self):
        """测试乘法"""
        result = self.calculator.calculate(6, '*', 9)
        self.assertequal(result, '54', "乘法测试失败")
    
    def test_division(self):
        """测试除法"""
        result = self.calculator.calculate(56, '/', 7)
        self.assertequal(result, '8', "除法测试失败")
    
    def test_complex_operation(self):
        """测试复杂运算"""
        # 15 + 27 - 8
        self.calculator.input_number(15)
        self.calculator.input_operator('+')
        self.calculator.input_number(27)
        self.calculator.input_operator('-')
        self.calculator.input_number(8)
        self.calculator.safe_click(appiumby.id, 'com.android.calculator2:id/eq')
        
        result = self.calculator.get_result()
        self.assertequal(result, '34', "复杂运算测试失败")


def main():
    """主函数"""
    logger.info("开始appium手机操作演示")
    
    # 创建计算器自动化实例
    calculator = calculatorautomation()
    
    try:
        # 设置驱动
        if not calculator.setup_driver():
            logger.error("无法启动appium驱动，程序退出")
            return
        
        # 执行一系列测试计算
        test_calculations = [
            (8, '+', 4),
            (15, '-', 6),
            (7, '*', 9),
            (81, '/', 9)
        ]
        
        for num1, op, num2 in test_calculations:
            result = calculator.calculate(num1, op, num2)
            expected = str(eval(f"{num1}{op}{num2}"))
            
            if result == expected:
                logger.info(f"✓ {num1} {op} {num2} = {result} (正确)")
            else:
                logger.error(f"✗ {num1} {op} {num2} = {result} (期望: {expected})")
        
        # 截取屏幕截图
        calculator.take_screenshot("calculator_final_state.png")
        
        logger.info("appium手机操作演示完成")
        
    except exception as e:
        logger.error(f"程序执行过程中出现错误: {str(e)}")
        
    finally:
        # 确保资源被正确清理
        calculator.teardown()


if __name__ == "__main__":
    # 可以直接运行演示
    main()
    
    # 或者运行单元测试
    # unittest.main(verbosity=2)