@silasfmartins/testhub 1.0.0

package/dist/src/appium/MobileActions.js

@@ -0,0 +1,1632 @@
+import fs from 'node:fs';
+import { BaseError, IntegrationError, ValidationError, } from '../functions/errors/index.js';
+import { ExecutionTracker } from '../hubdocs/ExecutionTracker.js';
+import { TestContext } from '../testContext/TestContext.js';
+import { UnifiedReportManager } from '../testContext/UnifiedReportManager.js';
+import { Logger } from '../utils/Logger.js';
+import { MobileConnection } from './MobileConnection.js';
+// 🤖 IMPORTAÇÃO CRÍTICA: Força inicialização do StatementTracker para projetos Mobile
+import '../hubdocs/StatementTracker.js';
+import path from 'node:path';
+import { StatementTracker } from '../hubdocs/StatementTracker.js';
+import { EvidenceCapture } from '../utils/EvidenceCapture.js';
+import { DeviceFarmViewer } from './DeviceFarmViewer.js';
+// 🚫 REMOVIDO: import { installDatabaseInterceptor } from '../utils/DatabaseInterceptor.js'
+/**
+ * Enum para direções de swipe
+ */
+export var Direcao;
+(function (Direcao) {
+    Direcao["CIMA"] = "CIMA";
+    Direcao["BAIXO"] = "BAIXO";
+    Direcao["ESQUERDA"] = "ESQUERDA";
+    Direcao["DIREITA"] = "DIREITA";
+})(Direcao || (Direcao = {}));
+/**
+ * Classe utilitária para interações com aplicativos mobile via Appium
+ * Fornece métodos para manipulação de elementos, gestos e validações
+ * Baseada nos padrões Actions do framework mobile
+ */
+export class MobileActions {
+    /**
+     * 🧹 Limpa pasta de screenshots mobile no início da execução
+     */
+    static async cleanMobileScreenshots() {
+        try {
+            const screenshotDir = path.join(process.cwd(), 'test-results', 'mobile-screenshots');
+            if (fs.existsSync(screenshotDir)) {
+                // Remove todos os arquivos PNG da pasta
+                const files = fs.readdirSync(screenshotDir);
+                const pngFiles = files.filter((file) => file.endsWith('.png'));
+                for (const file of pngFiles) {
+                    const filePath = path.join(screenshotDir, file);
+                    fs.unlinkSync(filePath);
+                }
+                Logger.info(`🧹 Limpos ${pngFiles.length} screenshot(s) mobile da execução anterior`);
+            }
+            else {
+                // Criar diretório se não existir
+                fs.mkdirSync(screenshotDir, { recursive: true });
+                Logger.info(`📁 Diretório de screenshots mobile criado: ${screenshotDir}`);
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao limpar screenshots mobile: ${String(error)}`);
+        }
+    }
+    /**
+     * 🚫 ULTRA-RADICAL SSL KILLER: Initialize before any mobile operation
+     */
+    static async initializeSSLKillerForMobile() {
+        try {
+            // Force global SSL killer from MobileConnection
+            await MobileConnection.initializeGlobalSSLKiller();
+            // Additional mobile-specific SSL killer
+            process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+            process.env.HTTPS_PROXY_REJECT_UNAUTHORIZED = '0';
+            process.env.SSL_VERIFY = '0';
+            process.env.DISABLE_SSL_VERIFICATION = '1';
+        }
+        catch (error) {
+            Logger.warning(`⚠️ SSL Killer initialization warning: ${String(error)}`);
+        }
+    }
+    /**
+     * ✅ NOVO: Detecta o tipo do seletor mobile
+     * @private
+     * @param {string} selector Seletor a analisar
+     * @returns {string} Tipo do seletor
+     */
+    static detectMobileSelectorType(selector) {
+        // XPath
+        if (selector.startsWith('//') ||
+            selector.startsWith('/') ||
+            selector.includes('[@')) {
+            return 'XPath';
+        }
+        // iOS Accessibility ID (XCUID)
+        if (selector.includes('accessibility-id') || selector.includes('~')) {
+            return 'iOS Accessibility ID';
+        }
+        // Android Resource ID
+        if (selector.includes(':id/') || selector.includes('android:id/')) {
+            return 'Android Resource ID';
+        }
+        // iOS Predicate
+        if (selector.includes('type=') && selector.includes('name=')) {
+            return 'iOS Predicate';
+        }
+        // Android UiSelector
+        if (selector.includes('UiSelector') ||
+            selector.includes('resourceId') ||
+            selector.includes('className')) {
+            return 'Android UiSelector';
+        }
+        // Text/Content Description
+        if (selector.startsWith('text=') || selector.startsWith('content-desc=')) {
+            return 'Text/Content-Desc';
+        }
+        // Class Name
+        if (selector.includes('android.widget.') ||
+            selector.includes('XCUIElementType')) {
+            return 'Class Name';
+        }
+        // ID simples
+        if (!(selector.includes(' ') ||
+            selector.includes('[') ||
+            selector.includes('='))) {
+            return 'ID';
+        }
+        return 'Mobile Selector';
+    }
+    /**
+     * ✅ NOVO: Função auxiliar para criar objeto de ação mobile para o AutoDocs
+     * @private
+     * @param {string} action Nome da ação
+     * @param {string} selector Seletor do elemento
+     * @param {string} description Descrição da ação
+     * @param {any} [value] Valor da ação (opcional)
+     * @param {boolean} [captureScreenshot] Se deve capturar screenshot
+     * @returns {object} Objeto de ação mobile
+     */
+    static async createMobileAction(action, selector, description, value, captureScreenshot = false) {
+        const deviceId = MobileConnection.getCurrentDeviceId();
+        const platform = MobileConnection.getCurrentPlatform();
+        const testName = TestContext.getSafeTestInfo()?.title || 'Mobile Action';
+        let screenshotPath;
+        // 📸 Capturar screenshot se solicitado
+        if (captureScreenshot) {
+            try {
+                const screenshot = await MobileConnection.captureScreenshotBuffer(`${action}-${description || 'unknown'}`);
+                if (screenshot) {
+                    // Salvar screenshot e obter o caminho
+                    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                    const safeName = `${action}-${description || 'action'}`.replace(/[^a-zA-Z0-9\-_]/g, '_');
+                    const fileName = `mobile-${timestamp}-${safeName}.png`;
+                    const evidenceDir = './test-results/mobile-screenshots';
+                    if (!fs.existsSync(evidenceDir)) {
+                        fs.mkdirSync(evidenceDir, { recursive: true });
+                    }
+                    const filePath = path.join(evidenceDir, fileName);
+                    fs.writeFileSync(filePath, screenshot);
+                    screenshotPath = `../test-results/mobile-screenshots/${fileName}`;
+                    Logger.info(`📸 Screenshot capturada para ação ${action}: ${screenshotPath}`);
+                }
+            }
+            catch (error) {
+                Logger.warning(`⚠️ Erro ao capturar screenshot para ação ${action}: ${String(error)}`);
+            }
+        }
+        return {
+            action,
+            element: selector || 'unknown',
+            device: deviceId || 'unknown',
+            platform,
+            timestamp: new Date().toISOString(),
+            testName,
+            value: value || description || '',
+            selectorType: selector
+                ? MobileActions.detectMobileSelectorType(selector)
+                : undefined,
+            coordinates: undefined,
+            screenshot: screenshotPath,
+        };
+    }
+    /**
+     * ✅ HELPER: Garante que o driver existe e não é null
+     * @private
+     */
+    static ensureDriverExists() {
+        const driver = MobileConnection.getDriver();
+        if (!driver) {
+            throw new Error('Driver mobile não inicializado. Execute MobileConnection.connect() primeiro.');
+        }
+        return driver;
+    }
+    /**
+     * Executa um método específico no contexto mobile com logs unificados.
+     * @param nomeMetodo Nome do método para identificação nos logs.
+     * @param executarAcao Função que executa a ação específica.
+     * @returns Resultado da execução da ação.
+     * @private
+     */
+    static async executarComLog(nomeMetodo, executarAcao) {
+        // 🚫 FORCE SSL KILLER before EVERY mobile operation
+        await MobileActions.initializeSSLKillerForMobile();
+        const startTime = Date.now();
+        Logger.info(`🤖 ${nomeMetodo} - Iniciando ação mobile`);
+        // ✅ NOVO: Capturar evidência antes da ação
+        let beforeScreenshot = null;
+        try {
+            beforeScreenshot = await MobileConnection.captureEvidence(`before_${nomeMetodo}`);
+        }
+        catch (evidenceError) {
+            Logger.warning(`⚠️ Erro ao capturar evidência antes: ${String(evidenceError)}`);
+        }
+        // ✅ NOVO: Delay configurável para visualização (antes da ação)
+        const preActionDelay = Number.parseInt(process.env.MOBILE_PRE_ACTION_DELAY || '500', 10);
+        if (preActionDelay > 0) {
+            Logger.info(`Aguardando ${preActionDelay}ms antes da ação (visualização)`);
+            await new Promise((resolve) => setTimeout(resolve, preActionDelay));
+        }
+        // Registrar no UnifiedReportManager se o teste estiver configurado
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo?.title) {
+            try {
+                UnifiedReportManager.adicionarLog(testInfo.title, `🔄 Executando: ${nomeMetodo}`);
+            }
+            catch {
+                // Silenciosamente ignorar se o contexto não estiver configurado
+            }
+        }
+        try {
+            const resultado = await executarAcao();
+            const duration = Date.now() - startTime;
+            // ✅ NOVO: Capturar evidência após a ação
+            let afterScreenshot = null;
+            try {
+                afterScreenshot = await MobileConnection.captureEvidence(`after_${nomeMetodo}`);
+                // 🆕 INTEGRAR COM EVIDENCECAPTURE
+                if (testInfo?.title && afterScreenshot) {
+                    await EvidenceCapture.captureAction(testInfo.title, `Mobile: ${nomeMetodo}`, `✅ Ação concluída com sucesso (${duration}ms)`, { duration, method: nomeMetodo }, afterScreenshot);
+                }
+            }
+            catch (evidenceError) {
+                Logger.warning(`⚠️ Erro ao capturar evidência depois: ${String(evidenceError)}`);
+            }
+            // ✅ NOVO: Delay configurável para visualização (após a ação)
+            const postActionDelay = Number.parseInt(process.env.MOBILE_POST_ACTION_DELAY || '1000', 10);
+            if (postActionDelay > 0) {
+                Logger.info(`Aguardando ${postActionDelay}ms após ação (visualização)`);
+                await new Promise((resolve) => setTimeout(resolve, postActionDelay));
+            }
+            Logger.success(`${nomeMetodo} executado com sucesso (${duration}ms)`);
+            // Log de sucesso no UnifiedReportManager
+            if (testInfo?.title) {
+                try {
+                    UnifiedReportManager.adicionarLog(testInfo.title, `✅ ${nomeMetodo} executado com sucesso (${duration}ms)`);
+                }
+                catch {
+                    // Silenciosamente ignorar se o contexto não estiver configurado
+                }
+            }
+            // Configurar limpeza automática se ainda não foi configurada
+            MobileActions.ensureAutoCleanupConfigured();
+            return resultado;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = String(error);
+            // ✅ NOVO: Capturar evidência do erro
+            let errorScreenshot = null;
+            try {
+                errorScreenshot = await MobileConnection.captureEvidence(`error_${nomeMetodo}`);
+                // 🆕 INTEGRAR COM EVIDENCECAPTURE
+                if (testInfo?.title && errorScreenshot) {
+                    await EvidenceCapture.captureAction(testInfo.title, `Mobile: ${nomeMetodo}`, `❌ ERRO: ${errorMessage} (${duration}ms)`, { duration, method: nomeMetodo, error: errorMessage }, errorScreenshot);
+                }
+            }
+            catch (evidenceError) {
+                Logger.warning(`⚠️ Erro ao capturar evidência de erro: ${String(evidenceError)}`);
+            }
+            Logger.error(`❌ Erro ao executar ${nomeMetodo} após ${duration}ms`, error);
+            // Log de erro no UnifiedReportManager
+            if (testInfo?.title) {
+                try {
+                    UnifiedReportManager.adicionarLog(testInfo.title, `❌ Erro ao executar ${nomeMetodo} (${duration}ms): ${errorMessage}`);
+                }
+                catch {
+                    // Silenciosamente ignorar se o contexto não estiver configurado
+                }
+            }
+            // Criar um IntegrationError se não for já um erro customizado
+            if (error instanceof BaseError) {
+                throw error;
+            }
+            throw new IntegrationError('MOBILE_ACTION_FAILED', `Mobile action '${nomeMetodo}' failed: ${String(error)}`, `Falha na ação mobile '${nomeMetodo}': ${String(error)}`, error instanceof Error ? error : new Error(String(error)), {
+                metadata: { method: nomeMetodo, timestamp: new Date().toISOString() },
+            });
+        }
+    }
+    /**
+     * Garante que a limpeza automática está configurada para o teste mobile.
+     * @private
+     */
+    static ensureAutoCleanupConfigured() {
+        const testInfo = TestContext.getSafeTestInfo();
+        if (!(testInfo && MobileConnection.isConnected()))
+            return;
+        // Verificar se já foi configurado para este teste
+        const testTitle = testInfo.title;
+        if (global[`mobileCleanup_${testTitle}`]) {
+            return; // Já configurado
+        }
+        // Marcar como configurado
+        ;
+        global[`mobileCleanup_${testTitle}`] = true;
+        // Configurar limpeza automática via Promise cleanup
+        let cleanupExecuted = false;
+        // Interceptar quando o teste realmente termina
+        const executeCleanup = async () => {
+            if (cleanupExecuted)
+                return;
+            cleanupExecuted = true;
+            try {
+                const hasActiveSession = MobileConnection.isConnected();
+                if (hasActiveSession) {
+                    Logger.info('🔚 Finalizando sessão mobile automaticamente...');
+                    await MobileConnection.closeSession();
+                    Logger.success('✅ Sessão mobile finalizada automaticamente');
+                    if (testInfo?.title) {
+                        UnifiedReportManager.adicionarLog(testInfo.title, '✅ Sessão mobile finalizada automaticamente');
+                    }
+                }
+            }
+            catch (error) {
+                Logger.warning(`⚠️ Erro na limpeza automática mobile: ${String(error)}`);
+            }
+        };
+        // Estratégia 1: Interceptar via Promise.allSettled no final
+        setTimeout(() => {
+            const originalAllSettled = Promise.allSettled;
+            Promise.allSettled = function (...args) {
+                const result = originalAllSettled.apply(this, args);
+                result.finally(() => {
+                    setTimeout(executeCleanup, 100);
+                });
+                return result;
+            };
+        }, 100);
+        // Estratégia 2: Timeout como fallback
+        setTimeout(executeCleanup, 30_000); // 30 segundos
+        // Estratégia 3: Detectar quando não há mais atividade
+        let lastActivity = Date.now();
+        const activityChecker = setInterval(() => {
+            const now = Date.now();
+            if (now - lastActivity > 5000) {
+                clearInterval(activityChecker);
+                setTimeout(executeCleanup, 500);
+            }
+        }, 1000);
+        global[`updateActivity_${testTitle}`] = () => {
+            lastActivity = Date.now();
+        };
+    }
+    /**
+     * Realiza clique inteligente em elemento mobile, com fallback para coordenadas.
+     * @param seletor Seletor do elemento.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param timeout Tempo máximo de espera em ms.
+     */
+    static async click(seletor, descriptionToAction, getSnapshot = true, // 🔧 MUDANÇA: Agora captura screenshot por padrão
+    timeout = TestContext.getProjectTimeout()) {
+        const startTime = Date.now();
+        // 🆕 Marcar uso automático do Mobile
+        UnifiedReportManager.registrarInicioExecucao();
+        // 🆕 Registrar statement no StatementTracker
+        let statementTimestamp = null;
+        try {
+            statementTimestamp = StatementTracker.startStatement('MobileActions', `click: ${descriptionToAction}`);
+        }
+        catch (error) {
+            Logger.warning(`Não foi possível registrar statement no StatementTracker: ${String(error)}`);
+        }
+        // 🆕 Criar ação mobile para AutoDocs com screenshot
+        const mobileAction = await MobileActions.createMobileAction('click', seletor, descriptionToAction, undefined, getSnapshot);
+        // 🆕 Registrar no ExecutionTracker
+        ExecutionTracker.trackMobile(mobileAction);
+        // Atualizar atividade
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo?.title &&
+            global[`updateActivity_${testInfo.title}`]) {
+            ;
+            global[`updateActivity_${testInfo.title}`]();
+        }
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            const elemento = await driver.$(seletor);
+            await elemento.waitForDisplayed({ timeout });
+            // Estratégia 1: Tentar clique direto
+            try {
+                Logger.info('Tentando clique direto no elemento');
+                const presente = await elemento.isDisplayed();
+                if (!presente) {
+                    throw new ValidationError('MOBILE_ELEMENT_NOT_VISIBLE', 'Element is not visible for interaction', 'Elemento não visível para interação', undefined, { metadata: { selector: seletor } });
+                }
+                // Verificação nativa de habilitação
+                try {
+                    const habilitado = await elemento.isEnabled();
+                    if (!habilitado) {
+                        Logger.warning('⚠️ Elemento pode estar desabilitado, tentando clique mesmo assim');
+                    }
+                }
+                catch (error) {
+                    Logger.info(`Verificação de habilitação ignorada: ${String(error)}`);
+                }
+                await driver.pause(300);
+                await elemento.click();
+                Logger.success(`Clique direto bem-sucedido: ${descriptionToAction}`);
+            }
+            catch (error) {
+                Logger.warning(`Clique direto falhou, tentando por coordenadas: ${String(error)}`);
+                // Estratégia 2: Fallback para clique por coordenadas
+                try {
+                    const location = await elemento.getLocation();
+                    const size = await elemento.getSize();
+                    const centerX = location.x + size.width / 2;
+                    const centerY = location.y + size.height / 2;
+                    Logger.info(`📍 Clicando por coordenadas: (${centerX}, ${centerY})`);
+                    await driver.touchAction({
+                        action: 'tap',
+                        x: Math.round(centerX),
+                        y: Math.round(centerY),
+                    });
+                    Logger.success(`✅ Clique por coordenadas bem-sucedido: ${descriptionToAction}`);
+                }
+                catch (coordError) {
+                    Logger.error('Ambos os métodos de clique falharam');
+                    // ✅ MELHORAR: Identificar tipo de erro
+                    const errorMessage = String(error);
+                    const coordErrorMessage = String(coordError);
+                    let errorCategory = 'ELEMENTO_NAO_ENCONTRADO';
+                    let userFriendlyMessage = 'Clique falhou: elemento não encontrado ou não acessível';
+                    // Detectar problemas de SSL/Certificado/Frame
+                    if (errorMessage.includes('SELF_SIGNED_CERT_IN_CHAIN') ||
+                        coordErrorMessage.includes('SELF_SIGNED_CERT_IN_CHAIN') ||
+                        errorMessage.includes('certificate') ||
+                        errorMessage.includes('SSL') ||
+                        errorMessage.includes('TLS')) {
+                        errorCategory = 'CONEXAO_SSL_FRAME';
+                        userFriendlyMessage =
+                            '❌ PROBLEMA DE CONEXÃO: Erro de certificado SSL/TLS com o DeviceFarm. O frame mobile não consegue se comunicar com o servidor devido a problemas de certificado.';
+                    }
+                    // Detectar problemas de timeout/rede
+                    else if (errorMessage.includes('timeout') ||
+                        errorMessage.includes('ETIMEDOUT') ||
+                        errorMessage.includes('ECONNRESET')) {
+                        errorCategory = 'TIMEOUT_FRAME';
+                        userFriendlyMessage =
+                            '❌ PROBLEMA DE CONEXÃO: Timeout na comunicação com o DeviceFarm. O frame mobile perdeu conexão.';
+                    }
+                    // Detectar problemas de elemento não encontrado
+                    else if (errorMessage.includes('element not found') ||
+                        errorMessage.includes('no such element') ||
+                        errorMessage.includes('element not visible')) {
+                        errorCategory = 'ELEMENTO_NAO_ENCONTRADO';
+                        userFriendlyMessage = `❌ PROBLEMA DE ELEMENTO: O elemento '${seletor}' não foi encontrado ou não está visível na tela.`;
+                    }
+                    // Detectar problemas de elemento não clicável
+                    else if (errorMessage.includes('not clickable') ||
+                        errorMessage.includes('element not interactable')) {
+                        errorCategory = 'ELEMENTO_NAO_CLICAVEL';
+                        userFriendlyMessage = `❌ PROBLEMA DE ELEMENTO: O elemento '${seletor}' foi encontrado mas não está clicável (pode estar sobreposto ou desabilitado).`;
+                    }
+                    Logger.info(`🔍 Diagnóstico: ${errorCategory}`);
+                    Logger.info(`💡 ${userFriendlyMessage}`);
+                    // 📝 NOVO: Registrar ação automaticamente no Statement ativo (erro)
+                    const duration = Date.now() - startTime;
+                    try {
+                        StatementTracker.recordAction('MOBILE', `Click FALHOU: ${descriptionToAction || seletor}`, false, duration, {
+                            selector: seletor,
+                            action: 'click',
+                        });
+                    }
+                    catch (recordError) {
+                        // Falha silenciosa - não afetar funcionalidade principal
+                    }
+                    throw new IntegrationError(errorCategory, `Mobile click failed: ${errorMessage} | Coordinates: ${coordErrorMessage}`, userFriendlyMessage, error instanceof Error ? error : new Error(String(error)), {
+                        metadata: {
+                            selector: seletor,
+                            originalError: errorMessage,
+                            coordError: coordErrorMessage,
+                            errorCategory,
+                            diagnosticMessage: userFriendlyMessage,
+                        },
+                    });
+                }
+            }
+            if (getSnapshot) {
+                // ✅ USAR MobileConnection.captureEvidence para integração com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+        });
+        // 📝 NOVO: Registrar ação automaticamente no Statement ativo (sucesso)
+        const duration = Date.now() - startTime;
+        try {
+            StatementTracker.recordAction('MOBILE', descriptionToAction || `Click: ${seletor}`, true, duration, {
+                selector: seletor,
+                action: 'click',
+            });
+        }
+        catch (recordError) {
+            // Falha silenciosa - não afetar funcionalidade principal
+        }
+        // 🆕 Finalizar statement com sucesso
+        if (statementTimestamp) {
+            try {
+                StatementTracker.finishStatement(statementTimestamp, true, `✅ ${descriptionToAction} (${duration}ms)`);
+            }
+            catch (error) {
+                Logger.warning(`Não foi possível finalizar statement no StatementTracker: ${String(error)}`);
+            }
+        }
+    }
+    /**
+     * Realiza clique robusto em elemento mobile, com múltiplas tentativas.
+     * @param seletor Seletor do elemento.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param timeout Tempo máximo de espera em ms.
+     * @param retry Número de tentativas.
+     */
+    static async clickNative(seletor, descriptionToAction, getSnapshot = false, timeout = TestContext.getProjectTimeout(), retry = 3) {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            let lastError = null;
+            for (let tentativa = 1; tentativa <= retry; tentativa++) {
+                try {
+                    Logger.info(`🔄 Tentativa ${tentativa}/${retry} de clique nativo`);
+                    const elemento = await driver.$(seletor);
+                    await elemento.waitForDisplayed({ timeout: timeout / retry });
+                    const presente = await elemento.isDisplayed();
+                    if (!presente) {
+                        throw new Error(`Elemento não visível na tentativa ${tentativa}`);
+                    }
+                    await driver.pause(300);
+                    await elemento.click();
+                    Logger.success(`✅ Clique nativo bem-sucedido na tentativa ${tentativa}: ${descriptionToAction}`);
+                    if (getSnapshot) {
+                        // ✅ USAR MobileConnection.captureEvidence para integração com Playwright Report
+                        await MobileConnection.captureEvidence(descriptionToAction);
+                    }
+                    return;
+                }
+                catch (error) {
+                    lastError = error;
+                    Logger.warning(`⚠️ Tentativa ${tentativa} falhou: ${String(error)}`);
+                    if (tentativa < retry) {
+                        await driver.pause(1000);
+                    }
+                }
+            }
+            throw new Error(`Clique falhou após ${retry} tentativas. Último erro: ${lastError?.message}`);
+        });
+    }
+    /**
+     * Realiza clique por coordenadas no centro do elemento.
+     * @param seletor Seletor do elemento.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param timeout Tempo máximo de espera em ms.
+     */
+    static async clickByCoordinates(seletor, descriptionToAction, getSnapshot = false, timeout = TestContext.getProjectTimeout()) {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            const elemento = await driver.$(seletor);
+            await elemento.waitForDisplayed({ timeout });
+            const location = await elemento.getLocation();
+            const size = await elemento.getSize();
+            const centerX = location.x + size.width / 2;
+            const centerY = location.y + size.height / 2;
+            Logger.info(`📍 Clicando nas coordenadas: (${centerX}, ${centerY})`);
+            await driver.touchAction({
+                action: 'tap',
+                x: Math.round(centerX),
+                y: Math.round(centerY),
+            });
+            Logger.success(`✅ Clique por coordenadas bem-sucedido: ${descriptionToAction}`);
+            if (getSnapshot) {
+                // ✅ USAR MobileConnection.captureEvidence para integração com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+        });
+    }
+    /**
+     * Realiza um clique em uma coordenada específica na tela.
+     * @param point Coordenada {x, y}.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     */
+    static async clickPoint(point, descriptionToAction, getSnapshot = false) {
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo?.title &&
+            global[`updateActivity_${testInfo.title}`]) {
+            ;
+            global[`updateActivity_${testInfo.title}`]();
+        }
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            await driver.touchAction({
+                action: 'tap',
+                x: point.x,
+                y: point.y,
+            });
+            Logger.success(`✅ Clique na coordenada (${point.x}, ${point.y}): ${descriptionToAction}`);
+            if (getSnapshot) {
+                // ✅ USAR MobileConnection.captureEvidence para integração com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+        });
+    }
+    /**
+     * Valida se um elemento está presente na tela.
+     * @param seletor Seletor do elemento.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param timeout Tempo máximo de espera em ms.
+     * @returns True se o elemento está presente.
+     */
+    static async validateObject(seletor, descriptionToAction, getSnapshot = false, timeout = TestContext.getProjectTimeout()) {
+        const driver = MobileActions.ensureDriverExists();
+        return await MobileActions.executarComLog(descriptionToAction, async () => {
+            try {
+                const elemento = await driver.$(seletor);
+                await elemento.waitForDisplayed({ timeout });
+                const presente = await elemento.isDisplayed();
+                if (presente) {
+                    Logger.success(`✅ Validação passou: elemento presente - ${descriptionToAction}`);
+                    if (getSnapshot) {
+                        // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                        await MobileConnection.captureEvidence(descriptionToAction);
+                    }
+                    return true;
+                }
+                const errorMsg = `Validação falhou: elemento não está visível - ${descriptionToAction}`;
+                Logger.error(errorMsg);
+                throw new Error(errorMsg);
+            }
+            catch (error) {
+                const errorMsg = `Validação falhou: elemento não encontrado - ${descriptionToAction}`;
+                Logger.error(errorMsg);
+                throw new Error(errorMsg);
+            }
+        });
+    }
+    /**
+     * Valida que um elemento não está presente na tela.
+     * @param seletor Seletor do elemento.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param timeout Tempo máximo de espera em ms.
+     * @returns True se o elemento não está presente.
+     */
+    static async validateObjectNotExist(seletor, descriptionToAction, getSnapshot = false, timeout = TestContext.getProjectTimeout()) {
+        const driver = MobileActions.ensureDriverExists();
+        return await MobileActions.executarComLog(descriptionToAction, async () => {
+            try {
+                const elemento = await driver.$(seletor);
+                await elemento.waitForDisplayed({ timeout, reverse: true });
+                const presente = await elemento.isDisplayed();
+                if (presente) {
+                    const errorMsg = `Validação falhou: elemento ainda está presente - ${descriptionToAction}`;
+                    Logger.error(errorMsg);
+                    throw new Error(errorMsg);
+                }
+                Logger.success(`✅ Validação passou: elemento não está presente - ${descriptionToAction}`);
+                if (getSnapshot) {
+                    // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                    await MobileConnection.captureEvidence(descriptionToAction);
+                }
+                return true;
+            }
+            catch (error) {
+                Logger.success(`✅ Validação passou: elemento não existe - ${descriptionToAction}`);
+                if (getSnapshot) {
+                    // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                    await MobileConnection.captureEvidence(descriptionToAction);
+                }
+                return true;
+            }
+        });
+    }
+    /**
+     * Define um texto em um campo de entrada.
+     * @param seletor Seletor do campo.
+     * @param text Texto a ser inserido.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param timeout Tempo máximo de espera em ms.
+     */
+    static async setText(seletor, text, descriptionToAction, getSnapshot = false, timeout = TestContext.getProjectTimeout()) {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            const elemento = await driver.$(seletor);
+            await elemento.waitForDisplayed({ timeout });
+            try {
+                const habilitado = await elemento.isEnabled();
+                if (!habilitado) {
+                    Logger.warning('⚠️ Elemento pode estar desabilitado');
+                }
+            }
+            catch (error) {
+                Logger.info(`ℹ️ Verificação de habilitação ignorada: ${String(error)}`);
+            }
+            await elemento.clearValue();
+            await elemento.setValue(text);
+            Logger.success(`✅ Texto inserido com sucesso: "${text}" - ${descriptionToAction}`);
+            if (getSnapshot) {
+                // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+        });
+    }
+    /**
+     * Envia caracteres individualmente para um elemento.
+     * @param seletor Seletor do campo.
+     * @param text Texto a ser inserido.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param timeout Tempo máximo de espera em ms.
+     * @param delayBetweenChars Delay entre caracteres em ms.
+     */
+    static async setChar(seletor, text, descriptionToAction, getSnapshot = false, timeout = TestContext.getProjectTimeout(), delayBetweenChars = 100) {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            const elemento = await driver.$(seletor);
+            await elemento.waitForDisplayed({ timeout });
+            try {
+                const habilitado = await elemento.isEnabled();
+                if (!habilitado) {
+                    Logger.warning('⚠️ Elemento pode estar desabilitado');
+                }
+            }
+            catch (error) {
+                Logger.info(`ℹ️ Verificação de habilitação ignorada: ${String(error)}`);
+            }
+            await elemento.clearValue();
+            for (const char of text) {
+                await elemento.addValue(char);
+                await driver.pause(delayBetweenChars);
+            }
+            Logger.success(`✅ Caracteres digitados com sucesso: "${text}" - ${descriptionToAction}`);
+            if (getSnapshot) {
+                // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+        });
+    }
+    /**
+     * Obtém o texto presente em um elemento.
+     * @param seletor Seletor do elemento.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param timeout Tempo máximo de espera em ms.
+     * @returns Texto do elemento.
+     */
+    static async getText(seletor, descriptionToAction, getSnapshot = false, timeout = TestContext.getProjectTimeout()) {
+        const driver = MobileActions.ensureDriverExists();
+        return await MobileActions.executarComLog(descriptionToAction, async () => {
+            const elemento = await driver.$(seletor);
+            await elemento.waitForDisplayed({ timeout });
+            const texto = await elemento.getText();
+            Logger.success(`Texto obtido: "${texto}" - ${descriptionToAction}`);
+            if (getSnapshot) {
+                // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+            return texto;
+        });
+    }
+    /**
+     * Alterna o contexto da aplicação (ex: Nativo/Webview).
+     * @param contextName Nome do contexto.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     */
+    static async switchToContext(contextName, descriptionToAction, getSnapshot = false) {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            const contextos = await driver.getContexts();
+            Logger.info(`📱 Contextos disponíveis: ${contextos.join(', ')}`);
+            if (!contextos.includes(contextName)) {
+                throw new Error(`Contexto '${contextName}' não encontrado. Disponíveis: ${contextos.join(', ')}`);
+            }
+            await driver.switchContext(contextName);
+            const contextoAtual = await driver.getContext();
+            Logger.success(`✅ Contexto alterado para: ${contextoAtual} - ${descriptionToAction}`);
+            if (getSnapshot) {
+                // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+        });
+    }
+    /**
+     * Verifica se um elemento está presente na tela.
+     * @param seletor Seletor do elemento.
+     * @param timeout Tempo máximo de espera em ms.
+     * @returns True se o elemento está presente.
+     */
+    static async isPresent(seletor, timeout = TestContext.getProjectTimeout()) {
+        const driver = MobileActions.ensureDriverExists();
+        try {
+            const elemento = await driver.$(seletor);
+            await elemento.waitForDisplayed({ timeout });
+            const presente = await elemento.isDisplayed();
+            Logger.info(`ℹ️ Elemento ${presente ? 'presente' : 'não presente'}: ${seletor}`);
+            return presente;
+        }
+        catch {
+            Logger.info(`ℹ️ Elemento não presente: ${seletor}`);
+            return false;
+        }
+    }
+    /**
+     * Realiza a ação de voltar na navegação.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     */
+    static async back(descriptionToAction, getSnapshot = false) {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            await driver.back();
+            Logger.success(`Ação de voltar executada - ${descriptionToAction}`);
+            if (getSnapshot) {
+                // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+        });
+    }
+    /**
+     * Realiza um gesto de swipe na tela.
+     * @param xInit Coordenada X inicial.
+     * @param yInit Coordenada Y inicial.
+     * @param xFinal Coordenada X final.
+     * @param yFinal Coordenada Y final.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param duracao Duração do swipe em ms.
+     */
+    static async swipe(xInit, yInit, xFinal, yFinal, descriptionToAction, getSnapshot = false, duracao = 1000) {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            await driver.touchAction([
+                { action: 'press', x: xInit, y: yInit },
+                { action: 'wait', ms: duracao },
+                { action: 'moveTo', x: xFinal, y: yFinal },
+                { action: 'release' },
+            ]);
+            Logger.success(`✅ Swipe executado: (${xInit}, ${yInit}) → (${xFinal}, ${yFinal}) - ${descriptionToAction}`);
+            if (getSnapshot) {
+                // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+        });
+    }
+    /**
+     * Executa swipes até encontrar elemento.
+     * @param xInit Coordenada X inicial.
+     * @param yInit Coordenada Y inicial.
+     * @param xFinal Coordenada X final.
+     * @param yFinal Coordenada Y final.
+     * @param seletorElementoEsperado Seletor do elemento esperado.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param maxTentativas Número máximo de tentativas.
+     * @param duracao Duração do swipe em ms.
+     * @returns True se o elemento foi encontrado.
+     */
+    static async swipeUntilFind(xInit, yInit, xFinal, yFinal, seletorElementoEsperado, descriptionToAction, getSnapshot = false, maxTentativas = 10, duracao = 1000) {
+        const driver = MobileActions.ensureDriverExists();
+        return await MobileActions.executarComLog(descriptionToAction, async () => {
+            for (let tentativa = 1; tentativa <= maxTentativas; tentativa++) {
+                Logger.info(`🔄 Tentativa ${tentativa}/${maxTentativas} de swipe até encontrar elemento`);
+                const presente = await MobileActions.isPresent(seletorElementoEsperado, 2000);
+                if (presente) {
+                    Logger.success(`✅ Elemento encontrado após ${tentativa} tentativa(s) - ${descriptionToAction}`);
+                    if (getSnapshot) {
+                        // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                        await MobileConnection.captureEvidence(descriptionToAction);
+                    }
+                    return true;
+                }
+                if (tentativa < maxTentativas) {
+                    await MobileActions.swipe(xInit, yInit, xFinal, yFinal, `Swipe ${tentativa} - ${descriptionToAction}`, false, duracao);
+                    await driver.pause(500);
+                }
+            }
+            const errorMsg = `Elemento não encontrado após ${maxTentativas} tentativas de swipe - ${descriptionToAction}`;
+            Logger.error(errorMsg);
+            throw new Error(errorMsg);
+        });
+    }
+    /**
+     * Obtém valor de atributo de um elemento.
+     * @param seletor Seletor do elemento.
+     * @param attributeName Nome do atributo.
+     * @param timeout Tempo máximo de espera em ms.
+     * @returns Valor do atributo.
+     */
+    static async getAttribute(seletor, attributeName, timeout = TestContext.getProjectTimeout()) {
+        const driver = MobileActions.ensureDriverExists();
+        return await MobileActions.executarComLog(`Obter atributo '${attributeName}' do elemento: ${seletor}`, async () => {
+            const elemento = await driver.$(seletor);
+            await elemento.waitForDisplayed({ timeout });
+            const atributo = await elemento.getAttribute(attributeName);
+            Logger.success(`Atributo '${attributeName}' obtido: "${atributo}"`);
+            return atributo || '';
+        });
+    }
+    /**
+     * Simula cliques no teclado numérico.
+     * @param number Número a ser digitado.
+     * @param getSnapshot Se deve capturar screenshot.
+     */
+    static async clickNumberPad(number, getSnapshot = false) {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(`Digitar número '${number}' no teclado numérico`, async () => {
+            for (const digit of number) {
+                const digitSelector = `//android.widget.TextView[@text="${digit}"] | //XCUIElementTypeStaticText[@name="${digit}"]`;
+                const elemento = await driver.$(digitSelector);
+                await elemento.waitForDisplayed({ timeout: 5000 });
+                await elemento.click();
+                await driver.pause(300);
+            }
+            Logger.success(`Número '${number}' digitado no teclado numérico`);
+            if (getSnapshot) {
+                // ✅ USAR MobileConnection.captureEvidence para integração com Playwright Report
+                await MobileConnection.captureEvidence(`Teclado numérico - ${number}`);
+            }
+        });
+    }
+    /**
+     * Executa script personalizado no driver.
+     * @param scriptType Tipo do script.
+     * @param jsonParams Parâmetros do script.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @returns Resultado do script.
+     */
+    static async executeScript(scriptType, jsonParams, descriptionToAction, getSnapshot = false) {
+        const driver = MobileActions.ensureDriverExists();
+        return await MobileActions.executarComLog(descriptionToAction, async () => {
+            const result = await driver.executeScript(scriptType, [jsonParams]);
+            Logger.success(`✅ Script '${scriptType}' executado - ${descriptionToAction}`);
+            if (getSnapshot) {
+                // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+            return result;
+        });
+    }
+    /**
+     * Executa swipe genérico Android.
+     * @param direcao Direção do swipe.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param distancia Distância do swipe (0 a 1).
+     */
+    static async genericSwipeAndroid(direcao, descriptionToAction, getSnapshot = false, distancia = 0.5) {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            const { width, height } = await driver.getWindowSize();
+            const centerX = width / 2;
+            const centerY = height / 2;
+            let startX, startY, endX, endY;
+            switch (direcao) {
+                case Direcao.CIMA:
+                    startX = centerX;
+                    startY = centerY + (height * distancia) / 2;
+                    endX = centerX;
+                    endY = centerY - (height * distancia) / 2;
+                    break;
+                case Direcao.BAIXO:
+                    startX = centerX;
+                    startY = centerY - (height * distancia) / 2;
+                    endX = centerX;
+                    endY = centerY + (height * distancia) / 2;
+                    break;
+                case Direcao.ESQUERDA:
+                    startX = centerX + (width * distancia) / 2;
+                    startY = centerY;
+                    endX = centerX - (width * distancia) / 2;
+                    endY = centerY;
+                    break;
+                case Direcao.DIREITA:
+                    startX = centerX - (width * distancia) / 2;
+                    startY = centerY;
+                    endX = centerX + (width * distancia) / 2;
+                    endY = centerY;
+                    break;
+                default:
+                    throw new Error(`Direção inválida: ${direcao}`);
+            }
+            await driver.touchAction([
+                { action: 'press', x: Math.round(startX), y: Math.round(startY) },
+                { action: 'wait', ms: 1000 },
+                { action: 'moveTo', x: Math.round(endX), y: Math.round(endY) },
+                { action: 'release' },
+            ]);
+            Logger.success(`✅ Swipe genérico Android executado para ${direcao} - ${descriptionToAction}`);
+            if (getSnapshot) {
+                // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+        });
+    }
+    /**
+     * Executa swipe genérico iOS.
+     * @param direcao Direção do swipe.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param distancia Distância do swipe (0 a 1).
+     */
+    static async genericSwipeIOS(direcao, descriptionToAction, getSnapshot = false, distancia = 0.5) {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            try {
+                let swipeDirection;
+                switch (direcao) {
+                    case Direcao.CIMA:
+                        swipeDirection = 'up';
+                        break;
+                    case Direcao.BAIXO:
+                        swipeDirection = 'down';
+                        break;
+                    case Direcao.ESQUERDA:
+                        swipeDirection = 'left';
+                        break;
+                    case Direcao.DIREITA:
+                        swipeDirection = 'right';
+                        break;
+                    default:
+                        throw new Error(`Direção inválida: ${direcao}`);
+                }
+                await driver.executeScript('mobile: swipe', [
+                    {
+                        direction: swipeDirection,
+                        velocity: 1000 * distancia,
+                    },
+                ]);
+                Logger.success(`Swipe genérico iOS executado para ${direcao} - ${descriptionToAction}`);
+            }
+            catch (error) {
+                Logger.warning('⚠️ Comando nativo falhou, usando swipe manual');
+                await MobileActions.genericSwipeAndroid(direcao, descriptionToAction, false, distancia);
+            }
+            if (getSnapshot) {
+                // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+        });
+    }
+    /**
+     * Executa swipe genérico Android até encontrar elemento.
+     * @param direcao Direção do swipe.
+     * @param seletorElementoEsperado Seletor do elemento esperado.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param maxTentativas Número máximo de tentativas.
+     * @param distancia Distância do swipe (0 a 1).
+     * @returns True se o elemento foi encontrado.
+     */
+    static async genericSwipeUntilFindAndroid(direcao, seletorElementoEsperado, descriptionToAction, getSnapshot = false, maxTentativas = 10, distancia = 0.5) {
+        const driver = MobileActions.ensureDriverExists();
+        return await MobileActions.executarComLog(descriptionToAction, async () => {
+            for (let tentativa = 1; tentativa <= maxTentativas; tentativa++) {
+                Logger.info(`🔄 Tentativa ${tentativa}/${maxTentativas} de swipe genérico Android até encontrar elemento`);
+                const presente = await MobileActions.isPresent(seletorElementoEsperado, 2000);
+                if (presente) {
+                    Logger.success(`✅ Elemento encontrado após ${tentativa} tentativa(s) - ${descriptionToAction}`);
+                    if (getSnapshot) {
+                        // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                        await MobileConnection.captureEvidence(descriptionToAction);
+                    }
+                    return true;
+                }
+                if (tentativa < maxTentativas) {
+                    await MobileActions.genericSwipeAndroid(direcao, `Swipe ${tentativa} - ${descriptionToAction}`, false, distancia);
+                    await driver.pause(500);
+                }
+            }
+            const errorMsg = `Elemento não encontrado após ${maxTentativas} tentativas de swipe genérico Android - ${descriptionToAction}`;
+            Logger.error(errorMsg);
+            throw new Error(errorMsg);
+        });
+    }
+    /**
+     * Executa swipe genérico iOS até encontrar elemento.
+     * @param direcao Direção do swipe.
+     * @param seletorElementoEsperado Seletor do elemento esperado.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param maxTentativas Número máximo de tentativas.
+     * @param distancia Distância do swipe (0 a 1).
+     * @returns True se o elemento foi encontrado.
+     */
+    static async genericSwipeUntilFindIOS(direcao, seletorElementoEsperado, descriptionToAction, getSnapshot = false, maxTentativas = 10, distancia = 0.5) {
+        const driver = MobileActions.ensureDriverExists();
+        return await MobileActions.executarComLog(descriptionToAction, async () => {
+            for (let tentativa = 1; tentativa <= maxTentativas; tentativa++) {
+                Logger.info(`🔄 Tentativa ${tentativa}/${maxTentativas} de swipe genérico iOS até encontrar elemento`);
+                const presente = await MobileActions.isPresent(seletorElementoEsperado, 2000);
+                if (presente) {
+                    Logger.success(`✅ Elemento encontrado após ${tentativa} tentativa(s) - ${descriptionToAction}`);
+                    if (getSnapshot) {
+                        // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                        await MobileConnection.captureEvidence(descriptionToAction);
+                    }
+                    return true;
+                }
+                if (tentativa < maxTentativas) {
+                    await MobileActions.genericSwipeIOS(direcao, `Swipe ${tentativa} - ${descriptionToAction}`, false, distancia);
+                    await driver.pause(500);
+                }
+            }
+            const errorMsg = `Elemento não encontrado após ${maxTentativas} tentativas de swipe genérico iOS - ${descriptionToAction}`;
+            Logger.error(errorMsg);
+            throw new Error(errorMsg);
+        });
+    }
+    /**
+     * Realiza clique em elemento com verificação de presença.
+     * @param seletor Seletor do elemento.
+     * @param descriptionToAction Descrição da ação.
+     * @param getSnapshot Se deve capturar screenshot.
+     * @param timeout Tempo máximo de espera em ms.
+     */
+    static async clickOnObjectPresence(seletor, descriptionToAction, getSnapshot = false, timeout = TestContext.getProjectTimeout()) {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            const elemento = await driver.$(seletor);
+            await elemento.waitForDisplayed({ timeout });
+            const presente = await elemento.isDisplayed();
+            if (!presente) {
+                throw new Error(`Elemento não está presente na tela: ${seletor}`);
+            }
+            try {
+                const habilitado = await elemento.isEnabled();
+                if (!habilitado) {
+                    Logger.warning(`⚠️ Elemento está presente mas pode estar desabilitado: ${seletor}`);
+                }
+            }
+            catch (error) {
+                Logger.info(`ℹ️ Verificação de habilitação ignorada: ${String(error)}`);
+            }
+            await elemento.click();
+            Logger.success(`✅ Clique realizado no elemento presente - ${descriptionToAction}`);
+            if (getSnapshot) {
+                // ? USAR MobileConnection.captureEvidence para integra��o com Playwright Report
+                await MobileConnection.captureEvidence(descriptionToAction);
+            }
+        });
+    }
+    /**
+     * Copia texto para o clipboard (Android/iOS).
+     * @param text Texto a ser copiado.
+     * @param descriptionToAction Descrição da ação.
+     */
+    static async setClipboardText(text, descriptionToAction = 'Set clipboard text') {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            try {
+                await driver.setClipboard('plaintext', Buffer.from(text).toString('base64'));
+                Logger.success(`Texto copiado para clipboard: "${text}"`);
+            }
+            catch (error) {
+                Logger.warning(`Falha ao copiar texto para clipboard: ${String(error)}`);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Obtém texto do clipboard (Android/iOS).
+     * @param descriptionToAction Descrição da ação.
+     * @returns Texto do clipboard.
+     */
+    static async getClipboardText(descriptionToAction = 'Get clipboard text') {
+        const driver = MobileActions.ensureDriverExists();
+        return await MobileActions.executarComLog(descriptionToAction, async () => {
+            try {
+                const base64 = await driver.getClipboard('plaintext');
+                const text = Buffer.from(base64, 'base64').toString('utf-8');
+                Logger.success(`Texto obtido do clipboard: "${text}"`);
+                return text;
+            }
+            catch (error) {
+                Logger.warning(`Falha ao obter texto do clipboard: ${String(error)}`);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Executa comando shell (Android).
+     * @param command Comando shell.
+     * @param args Argumentos do comando.
+     * @param descriptionToAction Descrição da ação.
+     * @returns Resultado do comando.
+     */
+    static async executeShellCommand(command, args = [], descriptionToAction = 'Executar comando shell') {
+        const driver = MobileActions.ensureDriverExists();
+        return await MobileActions.executarComLog(descriptionToAction, async () => {
+            try {
+                const result = await driver.execute('mobile: shell', { command, args });
+                Logger.success(`Comando shell executado: ${command} ${args.join(' ')}`);
+                return result;
+            }
+            catch (error) {
+                Logger.warning(`Falha ao executar comando shell: ${String(error)}`);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Fecha o app e relança (forceAppLaunch).
+     * @param descriptionToAction Descrição da ação.
+     */
+    static async relaunchApp(descriptionToAction = 'Relaunch app') {
+        const driver = MobileActions.ensureDriverExists();
+        await MobileActions.executarComLog(descriptionToAction, async () => {
+            try {
+                await driver.closeApp();
+                await driver.launchApp();
+                Logger.success('App relançado com sucesso');
+            }
+            catch (error) {
+                Logger.warning(`Falha ao relançar app: ${String(error)}`);
+                throw error;
+            }
+        });
+    }
+    /**
+     * ✅ MELHORADO: Captura screenshot robusto com múltiplas tentativas
+     * @param nome Nome do screenshot
+     * @returns Buffer da imagem ou null
+     */
+    static async capturarScreenshot(nome) {
+        const MAX_RETRIES = 3;
+        const RETRY_DELAY = 2000;
+        const STABILIZATION_DELAY = 1500;
+        const MIN_SCREENSHOT_SIZE = 1000;
+        Logger.info(`📸 Iniciando captura de screenshot mobile: ${nome}`);
+        try {
+            // 1. Verificações preliminares
+            if (!MobileConnection.isConnected()) {
+                Logger.error('❌ Driver mobile não conectado para screenshot');
+                return null;
+            }
+            const driver = MobileActions.ensureDriverExists();
+            if (!driver) {
+                Logger.error('❌ Driver não disponível para screenshot');
+                return null;
+            }
+            // 2. Verificar conectividade visual DeviceFarm
+            const isVisuallyActive = await MobileConnection.verifyDeviceFarmVisualConnection();
+            if (!isVisuallyActive) {
+                Logger.warning('⚠️ DeviceFarm não está visualmente ativo');
+            }
+            // 3. Múltiplas tentativas de captura
+            let screenshot = null;
+            for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+                try {
+                    Logger.info(`📸 Tentativa ${attempt}/${MAX_RETRIES} de captura: ${nome}`);
+                    // Aguardar estabilização
+                    await driver.pause(STABILIZATION_DELAY);
+                    // Capturar screenshot
+                    screenshot = await MobileConnection.captureScreenshotBuffer();
+                    if (screenshot && screenshot.length > MIN_SCREENSHOT_SIZE) {
+                        Logger.success(`Screenshot capturado: ${nome} (${screenshot.length} bytes)`);
+                        break;
+                    }
+                    Logger.warning(`⚠️ Screenshot inválido na tentativa ${attempt}`);
+                    screenshot = null;
+                }
+                catch (attemptError) {
+                    Logger.warning(`⚠️ Erro na tentativa ${attempt}: ${String(attemptError)}`);
+                    screenshot = null;
+                }
+                // Aguardar antes da próxima tentativa
+                if (attempt < MAX_RETRIES) {
+                    await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY));
+                }
+            }
+            if (!screenshot) {
+                Logger.error(`❌ Falha em todas as tentativas de screenshot: ${nome}`);
+                return null;
+            }
+            // 4. Salvar arquivo local para evidência
+            await MobileActions.saveScreenshotFile(screenshot, nome);
+            // 5. Anexar ao relatório Playwright
+            await MobileActions.attachScreenshotToReport(screenshot, nome);
+            // 6. Registrar no sistema unificado
+            MobileActions.logScreenshotToUnified(nome, screenshot.length);
+            return screenshot;
+        }
+        catch (error) {
+            Logger.error(`ERRO ao capturar screenshot: ${nome} - ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Salva screenshot como arquivo local e integra com DeviceFarmViewer
+     */
+    static async saveScreenshotFile(screenshot, nome) {
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const safeName = nome.replace(/[^a-zA-Z0-9\-_]/g, '_');
+            const fileName = `mobile-${timestamp}-${safeName}.png`;
+            const evidenceDir = './test-results/mobile-screenshots';
+            if (!fs.existsSync(evidenceDir)) {
+                fs.mkdirSync(evidenceDir, { recursive: true });
+            }
+            const filePath = path.join(evidenceDir, fileName);
+            fs.writeFileSync(filePath, screenshot);
+            if (fs.existsSync(filePath)) {
+                const fileSize = fs.statSync(filePath).size;
+                Logger.success(`💾 Screenshot salvo: ${filePath} (${fileSize} bytes)`);
+                // ✅ INTEGRAÇÃO: Adicionar ao DeviceFarmViewer para visualização em tempo real
+                try {
+                    DeviceFarmViewer.addScreenshot(fileName, nome);
+                    Logger.info(`📺 Screenshot adicionado ao viewer: ${nome}`);
+                }
+                catch (viewerError) {
+                    // Não falhar se viewer não estiver disponível
+                    Logger.info(`📺 Viewer não disponível: ${String(viewerError)}`);
+                }
+            }
+        }
+        catch (saveError) {
+            Logger.error(`❌ Erro ao salvar screenshot: ${String(saveError)}`);
+        }
+    }
+    /**
+     * Anexa screenshot ao relatório Playwright
+     */
+    static async attachScreenshotToReport(screenshot, nome) {
+        try {
+            const testInfo = TestContext.testInfo;
+            if (testInfo) {
+                await testInfo.attach(`screenshot-mobile-${nome}`, {
+                    body: screenshot,
+                    contentType: 'image/png',
+                });
+                Logger.info('📎 Screenshot anexado ao Playwright');
+            }
+        }
+        catch (attachError) {
+            Logger.warning(`⚠️ Erro ao anexar: ${String(attachError)}`);
+        }
+    }
+    /**
+     * Registra screenshot no sistema unificado
+     */
+    static logScreenshotToUnified(nome, size) {
+        try {
+            const testInfo = TestContext.getSafeTestInfo();
+            if (testInfo?.title) {
+                UnifiedReportManager.adicionarLog(testInfo.title, `📸 Screenshot mobile: ${nome} (${size} bytes)`);
+            }
+        }
+        catch {
+            // Silencioso
+        }
+    }
+    /**
+     * ✅ MELHORADO: Captura screenshot forçado com verificação DeviceFarm
+     * @param nome Nome do screenshot
+     * @returns Promise<boolean> True se conseguiu capturar
+     */
+    static async capturarScreenshotForcado(nome) {
+        const EXTENDED_STABILIZATION = 2000;
+        const MIN_VALID_SIZE = 1000;
+        try {
+            Logger.info(`🔍 Iniciando captura forçada: ${nome}`);
+            // 1. Verificar conectividade DeviceFarm
+            const isVisuallyActive = await MobileConnection.verifyDeviceFarmVisualConnection();
+            if (!isVisuallyActive) {
+                Logger.warning('⚠️ DeviceFarm não está visualmente ativo');
+            }
+            // 2. Aguardar estabilização extra
+            const driver = MobileActions.ensureDriverExists();
+            await driver.pause(EXTENDED_STABILIZATION);
+            // 3. Tentar múltiplas vezes
+            const maxAttempts = 3;
+            for (let attempts = 1; attempts <= maxAttempts; attempts++) {
+                Logger.info(`📸 Tentativa ${attempts}/${maxAttempts} de captura forçada`);
+                // ✅ USAR MobileConnection.captureEvidence para integração com Playwright Report
+                const screenshot = await MobileConnection.captureEvidence(`${nome}_attempt${attempts}`);
+                if (screenshot) {
+                    Logger.success(`Screenshot forçado capturado na tentativa ${attempts}`);
+                    return true;
+                }
+                if (attempts < maxAttempts) {
+                    Logger.warning('⚠️ Tentativa falhou, aguardando para próxima...');
+                    await driver.pause(EXTENDED_STABILIZATION);
+                }
+            }
+            Logger.error(`❌ Falha em todas as tentativas de screenshot forçado: ${nome}`);
+            return false;
+        }
+        catch (error) {
+            Logger.error(`❌ Erro na captura forçada: ${String(error)}`);
+            return false;
+        }
+    }
+    /**
+     * Valida se dois valores são iguais.
+     * @param atual Valor atual.
+     * @param esperado Valor esperado.
+     * @param descricao Descrição da validação.
+     */
+    static async validateEquals(atual, esperado, descricao) {
+        await MobileActions.executarComLog(descricao, async () => {
+            if (atual === esperado) {
+                Logger.success(`✅ Validação passou: ${descricao} (${atual} === ${esperado})`);
+            }
+            else {
+                const errorMsg = `❌ Validação falhou: ${descricao} - Esperado: "${esperado}", Atual: "${atual}"`;
+                Logger.error(errorMsg);
+                throw new Error(errorMsg);
+            }
+        });
+    }
+    // ========================================
+    // 🍎 iOS DEVICEFARM HELPERS INTEGRADOS
+    // ========================================
+    /**
+     * 🎯 SELETOR PARA O ELEMENTO Wi-Fi (iOS DeviceFarm)
+     * Baseado nas propriedades: type=XCUIElementTypeCell, name=Wi‑Fi, value=VivoQA_5G
+     */
+    static getWiFiSettingSelector() {
+        // Múltiplas estratégias de seletor para máxima compatibilidade
+        return [
+            // 1. Por accessibility id (name)
+            '~Wi‑Fi',
+            // 2. Por valor específico (VivoQA_5G)
+            '**/XCUIElementTypeCell[`value == "VivoQA_5G"`]',
+            // 3. Por label
+            '**/XCUIElementTypeCell[`label == "Wi‑Fi"`]',
+            // 4. Por XPath específico (posição)
+            '//XCUIElementTypeTable/XCUIElementTypeCell[5]',
+            // 5. Por combinação de propriedades
+            '**/XCUIElementTypeCell[`name == "Wi‑Fi" AND value == "VivoQA_5G"`]',
+        ][0]; // Usar o primeiro (mais confiável)
+    }
+    /**
+     * 🎯 SELETORES ALTERNATIVOS para fallback (iOS)
+     */
+    static getWiFiFallbackSelectors() {
+        return [
+            '~Wi‑Fi', // accessibility id
+            '**/XCUIElementTypeCell[`value == "VivoQA_5G"`]', // por valor
+            '**/XCUIElementTypeCell[`label == "Wi‑Fi"`]', // por label
+            '//XCUIElementTypeTable/XCUIElementTypeCell[5]', // xpath posição
+            '**/XCUIElementTypeCell[`name CONTAINS "Wi"`]', // nome parcial
+            '(//XCUIElementTypeCell)[5]', // índice simples
+            '**/XCUIElementTypeCell[`visible == 1 AND enabled == 1`][@name="Wi‑Fi"]', // completo
+        ];
+    }
+    /**
+     * 🔍 CLIQUE INTELIGENTE no elemento Wi-Fi com múltiplas estratégias (iOS)
+     */
+    static async clickWiFiSetting(descriptionToAction = 'Clique no elemento Wi-Fi (iOS DeviceFarm)', getSnapshot = true) {
+        const driver = MobileActions.ensureDriverExists();
+        const selectors = MobileActions.getWiFiFallbackSelectors();
+        return await MobileActions.executarComLog(descriptionToAction, async () => {
+            for (let i = 0; i < selectors.length; i++) {
+                const selector = selectors[i];
+                try {
+                    Logger.info(`Tentativa ${i + 1}/${selectors.length}: ${selector}`);
+                    // Aguardar elemento aparecer
+                    const element = await driver.$(selector);
+                    await element.waitForExist({ timeout: 10_000 });
+                    // Verificar se está visível
+                    const isDisplayed = await element.isDisplayed();
+                    if (!isDisplayed) {
+                        Logger.info('Elemento encontrado mas não visível');
+                        continue;
+                    }
+                    // Verificar se está habilitado
+                    const isEnabled = await element.isEnabled();
+                    if (!isEnabled) {
+                        Logger.info('Elemento encontrado mas não habilitado');
+                        continue;
+                    }
+                    // Realizar clique
+                    await element.click();
+                    Logger.info(`Clique realizado com sucesso usando: ${selector}`);
+                    // Aguardar transição
+                    await driver.pause(2000);
+                    if (getSnapshot) {
+                        await MobileConnection.captureEvidence(descriptionToAction);
+                    }
+                    return true;
+                }
+                catch (error) {
+                    Logger.error(`Falha com seletor ${i + 1}: ${String(error).substring(0, 100)}...`);
+                }
+            }
+            Logger.error('Todos os seletores falharam para o elemento Wi-Fi');
+            return false;
+        });
+    }
+    /**
+     * 🔍 CLIQUE POR COORDENADAS do elemento Wi-Fi (iOS)
+     * Baseado nas propriedades: x=20, y=526, width=390, height=45
+     */
+    static async clickWiFiByCoordinates(descriptionToAction = 'Clique Wi-Fi por coordenadas (iOS)', getSnapshot = true) {
+        const driver = MobileActions.ensureDriverExists();
+        return await MobileActions.executarComLog(descriptionToAction, async () => {
+            try {
+                // Coordenadas originais do elemento
+                const x = 20;
+                const y = 526;
+                const width = 390;
+                const height = 45;
+                // Calcular centro do elemento
+                const centerX = x + width / 2; // 20 + 195 = 215
+                const centerY = y + height / 2; // 526 + 22.5 = 548.5
+                Logger.info(`Clicando nas coordenadas: (${centerX}, ${centerY})`);
+                // Realizar clique por coordenadas
+                await driver.touchAction([
+                    { action: 'tap', x: Math.round(centerX), y: Math.round(centerY) },
+                ]);
+                Logger.success('✅ Clique por coordenadas realizado');
+                await driver.pause(2000);
+                if (getSnapshot) {
+                    await MobileConnection.captureEvidence(descriptionToAction);
+                }
+                return true;
+            }
+            catch (error) {
+                Logger.error(`❌ Falha no clique por coordenadas: ${String(error)}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * 🔍 ESTRATÉGIA COMBINADA: Tentar seletores primeiro, depois coordenadas (iOS)
+     */
+    static async clickWiFiCombined(descriptionToAction = 'Clique combinado Wi-Fi (iOS DeviceFarm)', getSnapshot = true) {
+        return await MobileActions.executarComLog(descriptionToAction, async () => {
+            Logger.info('🍎 Iniciando clique no elemento Wi-Fi (VivoQA_5G)');
+            // 1. Tentar seletores inteligentes
+            const selectorSuccess = await MobileActions.clickWiFiSetting('Clique Wi-Fi por seletores', false);
+            if (selectorSuccess) {
+                if (getSnapshot) {
+                    await MobileConnection.captureEvidence(descriptionToAction);
+                }
+                return true;
+            }
+            Logger.info('🎯 Fallback: Tentando clique por coordenadas...');
+            // 2. Fallback para coordenadas
+            const coordinatesSuccess = await MobileActions.clickWiFiByCoordinates('Fallback clique Wi-Fi por coordenadas', false);
+            if (coordinatesSuccess) {
+                if (getSnapshot) {
+                    await MobileConnection.captureEvidence(descriptionToAction);
+                }
+                return true;
+            }
+            Logger.error('❌ Todas as estratégias falharam para o elemento Wi-Fi');
+            return false;
+        });
+    }
+    /**
+     * 🔍 VERIFICAR se elemento Wi-Fi está presente na tela (iOS)
+     */
+    static async isWiFiSettingVisible() {
+        const driver = MobileActions.ensureDriverExists();
+        const selectors = MobileActions.getWiFiFallbackSelectors();
+        for (const selector of selectors) {
+            try {
+                const element = await driver.$(selector);
+                const exists = await element.isExisting();
+                const displayed = exists ? await element.isDisplayed() : false;
+                if (exists && displayed) {
+                    Logger.success(`✅ Elemento Wi-Fi encontrado com: ${selector}`);
+                    return true;
+                }
+            }
+            catch {
+                // Continuar tentando
+            }
+        }
+        Logger.error('❌ Elemento Wi-Fi não encontrado na tela');
+        return false;
+    }
+    /**
+     * 🔍 OBTER informações do elemento Wi-Fi (iOS)
+     */
+    static async getWiFiElementInfo() {
+        const driver = MobileActions.ensureDriverExists();
+        const selector = MobileActions.getWiFiSettingSelector();
+        try {
+            const element = await driver.$(selector);
+            await element.waitForExist({ timeout: 5000 });
+            const rect = await element.getLocation();
+            const size = await element.getSize();
+            const isDisplayed = await element.isDisplayed();
+            const isEnabled = await element.isEnabled();
+            const text = await element.getText().catch(() => 'N/A');
+            const value = await element.getValue().catch(() => 'N/A');
+            return {
+                selector,
+                rect: { x: rect.x, y: rect.y, width: size.width, height: size.height },
+                isDisplayed,
+                isEnabled,
+                text,
+                value,
+                coordinates: {
+                    centerX: rect.x + size.width / 2,
+                    centerY: rect.y + size.height / 2,
+                },
+            };
+        }
+        catch (error) {
+            Logger.error(`❌ Erro ao obter informações: ${String(error)}`);
+            return null;
+        }
+    }
+}
+// 🚫 AUTO-ATIVAÇÃO REMOVIDA: MobileActions são métodos internos que não devem ser interceptados
+// MobileActions.tap(), .swipe(), etc. não são CTs válidos e devem ser filtrados
+// A interceptação foi removida para evitar falsos CTs nos relatórios
+// CTs reais vêm das classes Statement (StatementsMobile, etc.) via InterceptacaoMagica.ts
+// CÓDIGO REMOVIDO:
+// try {
+//   installDatabaseInterceptor(MobileActions, 'MobileActions')
+// } catch (error) {
+//   if (process.env.AUTOCORE_DEBUG_LOGS === 'true') {
+//     process.stderr.write(`[DatabaseInterceptor] Falha na auto-ativação MobileActions: ${String(error)}\n`)
+//   }
+// }