@devassure/tpp-engine 0.0.0-stage → 1.8.1

package/src/mobile/mobile-actions.js

@@ -0,0 +1,1568 @@
+const { remote } = require('webdriverio');
+const { Logger, LOG_PREFIX } = require("../utils/logger");
+const { getCapabilities, getConnectionDetails } = require("./web-driver-utils");
+const { setDeviceCloudTestStatus } = require('./device-cloud/device-cloud-service');
+const { TppElement } = require('../models/tpp-mobile-element');
+const fs = require('fs');
+const { getScreenshotPath, getScreenshotLog } = require('../utils/screenshot-utils');
+const { FileUtils } = require('../library/file/file-utils');
+const { sleep } = require('../utils/common-utils');
+const { MobileRecorderControl } = require('./recorder-utils/mobile-recorder');
+const { getCloudCommand } = require('./device-cloud/commands/device-cloud-commands');
+
+class MobileActions {
+    
+    constructor(config, retry, totalRetries, projectInfo, timeouts) {
+        this.config = config;
+        this.retry = retry;
+        this.totalRetries = totalRetries;
+        this.projectInfo = projectInfo;
+        this.timeouts = timeouts;
+    }
+
+    newChild(name) {
+        const childActions = new MobileActions(this.config, this.retry, this.totalRetries, this.projectInfo);
+        childActions.driver = this.driver;
+        childActions.app = this.app;
+        childActions.caller = this.caller + " :: " + name;
+        childActions.blacklistedLogs = this.blacklistedLogs;
+        return childActions;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    async connect(app, testLabel) {
+        let devicePrettyLog = `App: ${app.name}, Device: ${this.config.device?.name || this.config.device?.id || this.config.cloudDevice?.name}`;
+        this.log(undefined, `[MOBILE_OS] ${this.config.os}`);
+        this.log(undefined, `[MOBILE_APP] ${app.name}`);
+        this.log(undefined, `[MOBILE_DEVICE_NAME] ${this.config.device?.name || this.config.cloudDevice?.name}`);
+        if(this.config.device?.id) {
+            this.log(undefined, `[MOBILE_DEVICE_ID] ${this.config.device.id}`);
+        }
+        if(this.config.deviceCloud?.type) {
+            this.log(undefined, `[MOBILE_CLOUD] ${this.config.deviceCloud.type}`);
+            devicePrettyLog = `${devicePrettyLog}, Cloud: ${this.config.deviceCloud.type}`;
+        }
+        this.log(undefined, devicePrettyLog);
+        const logLabel = `Connect to device and install App`;
+        this.startLog(logLabel);
+        this.app = app;
+        try {
+            //TODO read timeouts from this.timeouts
+            const timeouts = {
+                inactiveTimeout: this.timeouts?.inactivityTimeout || 2 * 60, //2 minutes
+            }
+            const capabilities = getCapabilities(this.config, app, {projectInfo: this.projectInfo, label: testLabel}, timeouts);
+            const connection = getConnectionDetails(this.config);
+            this.driver = await remote({
+                ...connection,
+                logLevel: 'trace',
+                capabilities: capabilities,
+                connectionRetryTimeout: 4 * 60 * 1000, // 4 minutes
+            });
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+            await this.open_app(true);
+        } catch (ex) {
+            this.failureLog(logLabel);
+            if(ex.message.includes("adb: device unauthorized")) {
+                throw {message: `Permission issue in running test on device ${this.config.device?.name} , id - ${this.config.device?.id}. Please Check 'Always allow' and tap 'OK' in 'Allow USB Debugging' popup that appears in the device.`}
+            }
+            if(ex.message.includes("writing to settings requires:android.permission.WRITE_SECURE_SETTINGS")) {
+                throw {message: `Permission issue in running test on device ${this.config.device?.name} , id - ${this.config.device?.id}. Please turn ON 'Disable permission monitoring' under Developer Settings -> Apps Section. You might want to restart your phone for this settings to take effect.`}
+            }
+            if(ex.message.includes('Failed to create session')) {
+                throw {message: ex.message.replace('\n', '  ')}
+            }
+            throw ex;
+        }
+        this.endLog(logLabel);
+    }
+
+    async startMobileRecorder() {
+        try {
+            await (new MobileRecorderControl(this)).openMobileRecorder();
+        } catch(error) {
+            this.log(undefined, `[RECORDER-ERROR] ${error?.message || 'Unable to read the device state!'}`);
+            throw error;
+        }
+    }
+
+    async get_device_details() {
+        const logLabel = `Get device details`;
+        this.startLog(logLabel);
+    
+        const { os = "UNKNOWN", devices = [], cloudDevices = [], deviceCloud = null } = this.config || {};
+        const device = devices.length > 0 ? devices[0] : {};
+        const cloudDevice = cloudDevices.length > 0 ? cloudDevices[0] : {};
+    
+        const details = {
+            os,
+            emulator: device.emulator ?? false,
+            id: device.id ?? cloudDevice.id ?? "UNKNOWN",
+            name: device.name ?? cloudDevice.name ?? "UNKNOWN"
+        };
+    
+        if (cloudDevices.length > 0) {
+            if (os.toLowerCase() === "android" && cloudDevice.androidVersion) {
+                details.androidVersion = cloudDevice.androidVersion;
+            } else if (os.toLowerCase() === "ios" && cloudDevice.iosVersion) {
+                details.iosVersion = cloudDevice.iosVersion;
+            }
+        }
+        else {
+            if(os.toLowerCase() === "android"){
+                details.sdkVersion = device.sdk_version;
+            }
+            else if (os.toLowerCase() === "ios"){
+                details.iosVersion = this.config.device?.os_version;
+            }
+        }
+    
+        if (deviceCloud) {
+            details.deviceCloudType = deviceCloud.type ?? "UNKNOWN";
+        }
+    
+        this.endLog(logLabel);
+        return details;
+    }
+    
+
+    async shutdown(status) {
+        if(status && this.config?.deviceCloud) {
+            await setDeviceCloudTestStatus(this.config, this.driver, status.pass, status.message);
+        }
+        this.startLog('Close mobile session');
+        try {
+            let appId = this.config?.os === 'ios' ? this.app?.ios?.bundleId : this.app?.android?.package;
+            if(appId) {
+                let idParam = this.config?.os === 'ios' ? {bundleId: appId} : {appId: appId};
+                const cloudCommand = getCloudCommand(this.config, this.driver);
+                if(cloudCommand?.closeApp) {
+                    await cloudCommand.closeApp();
+                } else {
+                    await this.driver.execute('mobile: terminateApp', idParam);
+                }
+            }
+        } finally {
+            await this.driver?.deleteSession();
+        }
+        this.endLog('Close mobile session');
+    }
+
+    getSessionDetails() {
+        return {
+            host: '127.0.0.1',
+            port: this.config.appium.port,
+            sessionId: this.driver.sessionId,
+        };
+    }
+
+    async unlock_device() {
+        const logLabel = `Unlock device`;
+        this.startLog(logLabel);
+        try {
+            const deviceOs = this.config?.os || 'android'
+    
+            if (deviceOs === 'android') {
+                const isLocked = await this.driver.isLocked();
+                if (isLocked) {
+                    await this.driver.unlock();
+                } else {
+                    this.log(logLabel, 'Android device is already unlocked.');
+                }
+            } else if (deviceOs === 'ios') {
+                await this.driver.execute('mobile: pressButton', { name: 'home' });
+            } else {
+                this.failureLog(logLabel);
+                throw {message: `Unsupported platform: ${deviceOs}`};
+            }
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error unlocking device: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+    }
+
+    async lock_device() {
+        const logLabel = `Lock device`;
+        this.startLog(logLabel);
+        try {
+            const isLocked = await this.driver.isLocked();
+            if (!isLocked) {
+                await this.driver.lock();
+            } else {
+                this.log(logLabel, 'Device is already locked.');
+            }
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error locking device: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+    }
+
+    async hide_keyboard() {
+        const logLabel = `Hide keyboard`;
+        this.startLog(logLabel);
+        try {
+            await this.driver.hideKeyboard();
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error hiding keyboard: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+    }
+
+    async is_keyboard_open() {
+        const logLabel = `Is keyboard open`;
+        this.startLog(logLabel);
+        let isOpen = false;
+        try {
+            const deviceOs = this.config?.os || 'android';
+            if (deviceOs === 'android') {
+                isOpen = await this.driver.isKeyboardShown();
+            } else if (deviceOs === 'ios') {
+                const keyboardElement = await this.driver.$('//XCUIElementTypeKeyboard');
+                isOpen = await keyboardElement.isDisplayed().catch(() => false);
+            }
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error checking keyboard state: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+        return isOpen;
+    }
+
+    async press_back_button() {
+        const logLabel = `Press back button`;
+        this.startLog(logLabel);
+        try {
+            await this.driver.back();
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error pressing back button: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+    }
+
+    async switch_to_landscape() {
+        const logLabel = `Switch to landscape orientation`;
+        this.startLog(logLabel);
+        try {
+            await this.driver.setOrientation('LANDSCAPE');
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error switching to landscape orientation: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+    }
+
+    async switch_to_portrait() {
+        const logLabel = `Switch to portrait orientation`;
+        this.startLog(logLabel);
+        try {
+            await this.driver.setOrientation('PORTRAIT');
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error switching to portrait orientation: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+    }
+
+    async get_device_orientation() {
+        const logLabel = `Get device orientation`;
+        this.startLog(logLabel);
+        let orientation;
+        try {
+            orientation = await this.driver.getOrientation();
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error getting orientation: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+        return orientation;
+    }
+
+    async get_device_resolution() {
+        const logLabel = `Get device resolution`;
+        this.startLog(logLabel);
+        let resolution = null;
+        try {
+            const {width, height} = await this.driver.getWindowSize();
+            resolution = {width, height};
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error getting device resolution: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+        return resolution;
+    }
+
+    async shake_device() {
+        const logLabel = `Shake device`;
+        this.startLog(logLabel);
+
+        if(this.config?.os === 'android') {
+            this.failureLog(logLabel);
+            throw {message: `Shaking device is not supported on Android`};
+        }
+
+        try {
+            await this.driver.shake();
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error shaking device: ${error?.message || error}`};
+        }
+
+        this.endLog(logLabel);
+    }
+
+    async open_app(skipEmptyId) {
+        const logLabel = `Open app`;
+        this.startLog(logLabel);
+
+        const cloudCommand = getCloudCommand(this.config, this.driver);
+        
+        try {
+            if(cloudCommand?.openApp) {
+                await cloudCommand.openApp();
+            } else {
+                const deviceOs = this.config?.os || 'android'
+                let appId = deviceOs === 'ios' ? this.app?.ios?.bundleId : this.app?.android?.package;
+                if(!appId) {
+                    if(!skipEmptyId) {
+                        throw {message: `Mobile App ${deviceOs === 'ios' ? 'bundleId' : 'packageName'} is empty`};
+                    }
+                } else {
+                    if (deviceOs === 'ios') {
+                        await this.driver.execute('mobile: launchApp', { bundleId: appId });
+                    } else {
+                        await this.driver.execute('mobile: activateApp', { appId: appId });
+                    }
+                }
+            }
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error opening app: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+    }
+
+    async minimise_app(timeInSeconds) {
+        const logLabel = `Minimise app`;
+        this.startLog(logLabel);
+        
+        const cloudCommand = getCloudCommand(this.config, this.driver);
+
+        try {
+            if(cloudCommand?.minimiseApp) {
+                await cloudCommand.minimiseApp(timeInSeconds);
+            } else {
+                await this.driver.execute('mobile: backgroundApp', { seconds: timeInSeconds });
+            }
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error minimising app: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+    }
+
+    async close_app() {
+        const logLabel = `Close app`;
+        this.startLog(logLabel);
+        const cloudCommand = getCloudCommand(this.config, this.driver);
+        try {
+            if(cloudCommand?.closeApp) {
+                await cloudCommand.closeApp();
+            } else {
+                let appId = this.config?.os === 'ios' ? this.app?.ios?.bundleId : this.app?.android?.package;
+                if(appId) {
+                    let idParam = this.config?.os === 'ios' ? {bundleId: appId} : {appId: appId};
+                    await this.driver.execute('mobile: terminateApp', idParam);
+                } else {
+                    this.failureLog(logLabel);
+                    throw {message: `Mobile App ${this.config?.os === 'ios' ? 'bundleId' : 'appId'} is empty`};
+                }
+            }
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error closing app: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+    }
+
+    async open_app_id(appId) {
+        const logLabel = `Open app with id ${appId}`;
+        this.startLog(logLabel);
+        try {
+            const deviceOs = this.config?.os || 'android'
+            if (deviceOs === 'ios') {
+                await this.driver.execute('mobile: launchApp', { bundleId: appId });
+            } else {
+                await this.driver.execute('mobile: activateApp', { appId: appId });
+            }
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error opening app ${appId}: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+    }
+
+    async close_app_id(appId) {
+        const logLabel = `Close app with id ${appId}`;
+        this.startLog(logLabel);
+        try {
+            let idParam = this.config?.os === 'ios' ? {bundleId: appId} : {appId: appId};
+            const cloudCommand = getCloudCommand(this.config, this.driver);
+            if(cloudCommand?.closeApp) {
+                await cloudCommand.closeApp();
+            } else {
+                await this.driver.execute('mobile: terminateApp', idParam);
+            }
+        } catch (error) {
+            this.failureLog(logLabel);
+            throw {message: `Error closing app ${appId}: ${error?.message || error}`};
+        }
+        this.endLog(logLabel);
+    }
+
+    async switch_to_webview() {
+        const logLabel = `Switch to Web View`;
+        this.startLog(logLabel);
+
+        let contexts = await this.driver.getContexts();
+        contexts = contexts?.filter(context => {
+            if(typeof context === 'string') {
+                return context.startsWith('WEBVIEW_') && !context.startsWith('WEBVIEW_com.google');
+            }
+            return context?.id?.includes('WEBVIEW_')
+        });
+        let targetContext = contexts?.find(context => {
+            let appId = this.config?.os === 'ios' ? this.app?.ios?.bundleId : this.app?.android?.package;
+            if(!appId) {
+                return false;
+            }
+            if(typeof context === 'string') {
+                return context.includes(appId);
+            }
+            if(context?.bundleId) {
+                return context?.bundleId.includes(appId);
+            }
+            return context?.id?.includes(appId);
+        })
+        || contexts[0];
+        if(!targetContext) {
+            this.failureLog(logLabel);
+            throw {messae: 'WebView is not available!'};
+        }
+        const targetId = typeof targetContext === 'string' ? targetContext : targetContext?.id;
+        await this.driver.switchContext(targetId);
+        this.endLog(logLabel);
+    }
+
+    async switch_to_native_app () {
+        const logLabel = `Switch to Native App`;
+        this.startLog(logLabel);
+
+        let contexts = await this.driver.getContexts();
+        let targetContext = contexts?.find(context => {
+            if(typeof context === 'string') {
+                return context === 'NATIVE_APP';
+            }
+            return context?.id?.includes('NATIVE_APP');
+        });
+        if(!targetContext) {
+            this.failureLog(logLabel);
+            throw {messae: 'Native App Context is not available!'};
+        }
+        const targetId = typeof targetContext === 'string' ? targetContext : targetContext?.id;
+        await this.driver.switchContext(targetId);
+        this.endLog(logLabel);
+    }
+
+    async waitForElementExists(uiElement, userTimeout) {
+        let timeout = userTimeout || ((this.timeouts?.actionTimeout || 30) * 1000);
+        await uiElement.waitForExist({
+            timeout: timeout,
+            timeoutMsg: `Element not present within ${timeout} ms`,
+        });
+    }
+
+    async waitForElementVisiblity(uiElement, userTimeout) {
+        let timeout = userTimeout || ((this.timeouts?.actionTimeout || 30) * 1000);
+        await uiElement.waitForDisplayed({
+            timeout: timeout,
+            timeoutMsg: `Element not visible within ${timeout} ms`,
+        });
+    }
+
+    async waitForElementActionable(uiElement, userTimeout) {
+        await this.waitForElementVisiblity(uiElement);
+        let timeout = userTimeout || ((this.timeouts?.actionTimeout || 30) * 1000);
+        
+        await uiElement.waitForEnabled({
+            timeout: timeout,
+            timeoutMsg: `Element not enabled within ${timeout} ms`,
+        });
+
+        //TODO add scroll if necessary
+
+        //TODO check if there is option to check if element is clickable / interactable
+    }
+
+    async getElementCenter(uiElement) {
+        const {x, y} = await uiElement.getLocation();
+        const {width, height} = await uiElement.getSize();
+        return {
+            x: Math.round(x + (width / 2)),
+            y: Math.round(y + (height / 2)),
+        };
+    }
+
+    async getElementOffset(uiElement, xOffset, yOffset) {
+        const {x, y} = await uiElement.getLocation();
+        return {
+            x: Math.round(x + xOffset),
+            y: Math.round(y + yOffset),
+        };
+    }
+
+    async get_element_dimensions(element) {
+        const logLabel = `Get dimensions of - ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        let dimensions = null;
+        let uiElement = null;
+        try {
+            uiElement = await tppElement.locator();
+            await this.waitForElementExists(uiElement);
+        } catch (e) {
+            await this.handleElementException(e, tppElement, logLabel);
+        }
+        try {
+            const {width, height} = await uiElement.getSize();
+            const {x, y} = await uiElement.getLocation();
+            dimensions = {width, height, x, y};
+        } catch (e) {
+            this.failureLog(logLabel);
+            throw {message: `Error getting dimensions of ${element.label}: ${e?.message || e}`};
+        }
+        this.endLog(logLabel);
+        return dimensions;
+    }
+
+    async scroll_element_into_view(parentElement, element) {
+        const logLabel = `Scroll ${parentElement.label} until ${element.label} is in view`;
+        this.startLog(logLabel);
+
+        const tppParentElement = await this.tpp_element_or_backup(parentElement, logLabel, 1);
+        try {
+            let uiElement = await tppParentElement.locator();
+            await this.waitForElementExists(uiElement);
+        } catch (e) {
+            await this.handleElementException(e, tppParentElement, logLabel);
+        }
+
+        let timeout = (this.timeouts?.actionTimeout || 30) * 1000;
+        try {
+            await this.driver.waitUntil(
+                async () => {
+                    const isPresent = await this.wait_for_single_element(element, 1);
+                    if (isPresent) {
+                        return true;
+                    }
+    
+                    this.vertical_scroll_element(parentElement);
+    
+                    return false;
+                },
+                {
+                    timeout: timeout,
+                    timeoutMsg: `Element ${element.label} was not found within the ${timeout} ms`,
+                }
+            );
+        } catch (error) {
+            const tppElement = await this.tpp_element_or_backup(element, logLabel, 1, 1);
+            this.handleElementException(error, tppElement, logLabel, true);
+        }
+        this.endLog(logLabel);
+    }
+
+    async horizontal_scroll_element_into_view(parentElement, element) {
+        const logLabel = `Scroll horizontally ${parentElement.label} until ${element.label} is in view`;
+        this.startLog(logLabel);
+
+        const tppParentElement = await this.tpp_element_or_backup(parentElement, logLabel, 1);
+        try {
+            let uiElement = await tppParentElement.locator();
+            await this.waitForElementExists(uiElement);
+        } catch (e) {
+            await this.handleElementException(e, tppParentElement, logLabel);
+        }
+
+        let timeout = (this.timeouts?.actionTimeout || 30) * 1000;
+        try {
+            await this.driver.waitUntil(
+                async () => {
+                    const isPresent = await this.wait_for_single_element(element, 1);
+                    if (isPresent) {
+                        return true;
+                    }
+    
+                    this.horizontal_scroll_element(parentElement);
+    
+                    return false;
+                },
+                {
+                    timeout: timeout,
+                    timeoutMsg: `Element ${element.label} was not found within the ${timeout} ms`,
+                }
+            );
+        } catch (error) {
+            const tppElement = await this.tpp_element_or_backup(element, logLabel, 1, 1);
+            this.handleElementException(error, tppElement, logLabel, true);
+        }
+        this.endLog(logLabel);
+    }
+
+    async click_on_element(element) {
+        const logLabel = `Click on element - ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            let uiElement = await tppElement.locator();
+            await this.waitForElementActionable(uiElement);
+            await uiElement.click();
+        } catch (e) {
+            await this.handleClickException(e, tppElement, logLabel);
+        }
+        this.endLog(logLabel);
+    }
+
+    async tap_on_element(element) {
+        const logLabel = `Tap on element - ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            const uiElement = await tppElement.locator();
+            await this.waitForElementActionable(uiElement);
+            const {x, y} = await this.getElementCenter(uiElement);
+            await this.driver.performActions([{
+                type: "pointer",
+                id: "finger1",
+                parameters: { pointerType: "touch" },
+                actions:[
+                    {type: "pointerMove", duration:0, x: x, y: y},
+                    {type: "pointerDown", button: 0},
+                    {type: "pointerUp", button: 0},
+                ]
+            }]);
+        } catch (e) {
+            await this.handleClickException(e, tppElement, logLabel);
+        }
+        this.endLog(logLabel);
+    }
+
+    //function for tap at given point x,y from top of screen
+    async tap_at_point(x, y) {
+        const logLabel = `Tap at point (${x}, ${y})`;
+        this.startLog(logLabel);
+        try {
+            await this.driver.performActions([{
+                type: "pointer",
+                id: "finger1",
+                parameters: { pointerType: "touch" },
+                actions:[
+                    {type: "pointerMove", duration:0, x: x, y: y},
+                    {type: "pointerDown", button: 0},
+                    {type: "pointerUp", button: 0},
+                ]
+            }]);
+        } catch (e) {
+            this.failureLog(logLabel);
+            throw {message: `Error tapping at point (${x}, ${y}): ${e?.message || e}`};
+        }
+        this.endLog(logLabel);
+    }
+
+    //function for tap on element at given offset x,y from top
+    async tap_at_point_on_element(xOffset, yOffset, element) {
+        const logLabel = `Tap at point (${xOffset}, ${yOffset}) on element - ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            const uiElement = await tppElement.locator();
+            await this.waitForElementActionable(uiElement);
+            const {x, y} = await this.getElementOffset(uiElement, xOffset, yOffset);
+            await this.driver.performActions([{
+                type: "pointer",
+                id: "finger1",
+                parameters: { pointerType: "touch" },
+                actions:[
+                    {type: "pointerMove", duration:0, x: x, y: y},
+                    {type: "pointerDown", button: 0},
+                    {type: "pointerUp", button: 0},
+                ]
+            }]);
+        } catch (e) {
+            await this.handleClickException(e, tppElement, logLabel);
+        }
+        this.endLog(logLabel);
+    }
+
+    async double_tap_on_element(element) {
+        const logLabel = `Double tap on element - ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            const uiElement = await tppElement.locator();
+            await this.waitForElementActionable(uiElement);
+            const {x, y} = await this.getElementCenter(uiElement);
+            await this.driver.performActions([{
+                type: "pointer",
+                id: "finger1",
+                parameters: { pointerType: "touch" },
+                actions:[
+                    {type: "pointerMove", duration:0, x: x, y: y},
+                    {type: "pointerDown", button: 0},
+                    {type: "pointerUp", button: 0},
+                    {type: "pause", duration: 50},
+                    {type: "pointerMove", duration:0, x: x, y: y},
+                    {type: "pointerDown", button: 0},
+                    {type: "pointerUp", button: 0},
+                ]
+            }]);
+        } catch (e) {
+            await this.handleClickException(e, tppElement, logLabel);
+        }
+        this.endLog(logLabel);
+    }
+
+    async tap_on_element_and_hold(element, holdDuration) {
+        const logLabel = `Tap on element - ${element.label} and hold for ${holdDuration} ms`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            const uiElement = await tppElement.locator();
+            await this.waitForElementActionable(uiElement);
+            const {x, y} = await this.getElementCenter(uiElement);
+            await this.driver.performActions([{
+                type: "pointer",
+                id: "finger1",
+                parameters: { pointerType: "touch" },
+                actions:[
+                    {type: "pointerMove", duration:0, x: x, y: y},
+                    {type: "pointerDown", button: 0},
+                    {type: "pause", duration: holdDuration},
+                    {type: "pointerUp", button: 0},
+                ]
+            }]);
+        } catch (e) {
+            await this.handleClickException(e, tppElement, logLabel);
+        }
+        this.endLog(logLabel);
+    }
+
+    async swipeAction(element, dx, dy, logLabel) {
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            const uiElement = await tppElement.locator();
+            await this.waitForElementActionable(uiElement);
+            const {x, y} = await this.getElementCenter(uiElement);
+            await this.driver.performActions([{
+                type: "pointer",
+                id: "finger1",
+                parameters: { pointerType: "touch" },
+                actions:[
+                    { type: "pointerMove", duration: 0, x: x, y: y },
+                    { type: "pointerDown", button: 0 },
+                    {type: "pause", duration: 100},
+                    { type: "pointerMove", duration: 200, x: x + dx, y: y + dy },
+                    {type: "pause", duration: 100},
+                    { type: "pointerUp", button: 0 },
+                ]
+            }]);
+        } catch (e) {
+            await this.handleClickException(e, tppElement, logLabel);
+        }
+    }
+
+    async vertical_scroll_element(element) {
+        const logLabel = `Scroll vertically on element - ${element.label}`;
+        this.startLog(logLabel);
+        await this.swipeAction(element, 0, -800, logLabel);
+        this.endLog(logLabel);
+    }
+
+    async horizontal_scroll_element(element) {
+        const logLabel = `Scroll horizontally on element - ${element.label}`;
+        this.startLog(logLabel);
+        await this.swipeAction(element, -500, 0, logLabel);
+        this.endLog(logLabel);
+    }
+
+    async swipe_up_on_element(element) {
+        const logLabel = `Swipe up on element - ${element.label}`;
+        this.startLog(logLabel);
+        await this.swipeAction(element, 0, -800, logLabel);
+        this.endLog(logLabel);
+    }
+
+    async swipe_down_on_element(element) {
+        const logLabel = `Swipe down on element - ${element.label}`;
+        this.startLog(logLabel);
+        await this.swipeAction(element, 0, 800, logLabel);
+        this.endLog(logLabel);
+    }
+
+    async swipe_left_on_element(element) {
+        const logLabel = `Swipe left on element - ${element.label}`;
+        this.startLog(logLabel);
+        await this.swipeAction(element, -500, 0, logLabel);
+        this.endLog(logLabel);
+    }
+
+    async swipe_right_on_element(element) {
+        const logLabel = `Swip right on element - ${element.label}`;
+        this.startLog(logLabel);
+        await this.swipeAction(element, 500, 0, logLabel);
+        this.endLog(logLabel);
+    }
+
+    async swipe_and_hold(element, xDistance, yDistance, holdDuration) {
+        const logLabel = `Swipe on element - ${element.label} for distance x = ${xDistance}, y = ${yDistance} and hold for ${holdDuration} ms`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            const uiElement = await tppElement.locator();
+            await this.waitForElementActionable(uiElement);
+            const {x, y} = await this.getElementCenter(uiElement);
+            await this.driver.performActions([{
+                type: "pointer",
+                id: "finger1",
+                parameters: { pointerType: "touch" },
+                actions:[
+                    { type: "pointerMove", duration: 0, x: x, y: y },
+                    { type: "pointerDown", button: 0 },
+                    {type: "pause", duration: 100},
+                    { type: "pointerMove", duration: 100, x: x + xDistance, y: y + yDistance },
+                    {type: "pause", duration: holdDuration},
+                    { type: "pointerUp", button: 0 },
+                ]
+            }]);
+        } catch (e) {
+            await this.handleClickException(e, tppElement, logLabel);
+        }
+        this.endLog(logLabel);
+    }
+
+    async pinch_in_on_element(element) {
+        const logLabel = `Pinch IN on element - ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            let uiElement = await tppElement.locator();
+            await this.waitForElementActionable(uiElement);
+            const {x, y} = await this.getElementCenter(uiElement);
+            
+            // TODO find dynamic size rather than using 100
+            const startDistance = 100 * 2;
+            const endDistance = 100 / 2;
+
+            await this.performPinchAction({
+                xProps: {x: x, xStartDistance: startDistance, xEndDistace: endDistance},
+                yProps: {y: y, yStartDistance: startDistance, yEndDistace: endDistance},
+            });
+        } catch (e) {
+            await this.handleClickException(e, tppElement, logLabel);
+        }
+        this.endLog(logLabel);
+    }
+
+    async pinch_out_on_element(element) {
+        const logLabel = `Pinch OUT on element - ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            let uiElement = await tppElement.locator();
+            await this.waitForElementActionable(uiElement);
+            const {x, y} = await this.getElementCenter(uiElement);
+            
+            // TODO find dynamic size rather than using 100
+            const startDistance = 100 / 2;
+            const endDistance = 100 * 2;
+
+            await this.performPinchAction({
+                xProps: {x: x, xStartDistance: startDistance, xEndDistace: endDistance},
+                yProps: {y: y, yStartDistance: startDistance, yEndDistace: endDistance},
+            });
+        } catch (e) {
+            await this.handleClickException(e, tppElement, logLabel);
+        }
+        this.endLog(logLabel);
+    }
+
+    async performPinchAction({xProps: {x, xStartDistance, xEndDistace}, yProps: {y, yStartDistance, yEndDistace}}) {
+        try {
+            await this.driver.performActions([
+                {
+                    type: "pointer",
+                    id: "finger1",
+                    parameters: { pointerType: "touch" },
+                    actions: [
+                        { type: "pointerMove", duration: 0, x: x - xStartDistance, y: y - yStartDistance },
+                        { type: "pointerDown", button: 0 },
+                        { type: "pointerMove", duration: 0, x: x - xEndDistace, y: y - yEndDistace },
+                        { type: "pointerUp", button: 0 },
+                    ]
+                },
+                {
+                    type: "pointer",
+                    id: "finger2",
+                    parameters: { pointerType: "touch" },
+                    actions: [
+                        { type: "pointerMove", duration: 0, x: x + xStartDistance, y: y + yStartDistance },
+                        { type: "pointerDown", button: 0 },
+                        { type: "pointerMove", duration: 0, x: x + xEndDistace, y: y + yEndDistace },
+                        { type: "pointerUp", button: 0 },
+                    ]
+                },
+            ]);
+        } catch (ex) {
+            if(ex.message?.includes("make sure your input actions chain is valid")) {
+                //Ignoring as above actions is working. TODO check if subsequent steps are fine
+            } else {
+                throw ex;
+            }
+        }
+    }
+
+    async input_value(value, element) {
+        const logLabel = `Input - ${value}, on element ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            let uiElement = await tppElement.locator();
+            try {
+                await uiElement.setValue(value);
+            } catch (er) {
+                this.log(logLabel, `Element ${tppElement.label()} is unstable, retrying...`);
+                if(!uiElement.elementId) {
+                    uiElement = await tppElement.locator();
+                    await uiElement.setValue(value);
+                } else {
+                    throw er;
+                }
+            }
+        } catch (e) {
+          await this.handleElementException(e, tppElement, logLabel, true); 
+        }
+        this.endLog(logLabel);
+    }
+
+    async send_keys(value, element) {
+        const logLabel = `Send keys - ${value}, to element ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            let uiElement = await tppElement.locator();
+            const eleId = uiElement.elementId;
+            this.driver.elementSendKeys(eleId, value);
+        } catch (e) {
+          await this.handleElementException(e, tppElement, logLabel, true); 
+        }
+        this.endLog(logLabel);
+    }
+
+    async typeText(text) {
+        if (this.config?.os === 'ios') {
+            const actions = text.split('').flatMap(char => ([
+                { type: 'keyDown', value: char },
+                { type: 'keyUp', value: char }
+            ]));
+
+            await this.driver.performActions([{
+                type: 'key',
+                id: 'keyboard',
+                actions: actions
+            }]);
+        } else {
+            // Escape spaces with %s for Android shell command
+            const escapedText = text.replace(/ /g, '%s');
+
+            await this.driver.execute('mobile: shell', {
+                command: 'input',
+                args: ['text', escapedText]
+            });
+        }
+    }
+
+    async type_text(text) {
+        const logLabel = `Type text - ${text}`;
+        try {
+            this.typeText(text);
+        } catch(err) {
+            this.failureLog(logLabel);
+            throw {message: `Error typing text on device keyboard - ${err?.message || err}`}
+        }
+        this.endLog(logLabel);
+    }
+
+    //type_text_with_delay
+    async type_text_with_delay(text, delay) {
+        const logLabel = `Type text - ${text}, with delay of ${delay} ms between keys`;
+        this.startLog(logLabel);
+
+        if(!text?.trim()) {
+            this.log(logLabel, 'Text is empty, skipping typing');
+            this.endLog(logLabel);
+            return;
+        }
+
+        if (!delay || isNaN(delay) || delay < 0) {
+            this.failureLog(logLabel);
+            throw {message: `Invalid delay value: ${delay}`};
+        }
+
+        try {
+            for (const char of text) {
+                await this.typeText(char);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        } catch(err) {
+            this.failureLog(logLabel);
+            throw {message: `Error typing text on device keyboard - ${err?.message || err}`}
+        }
+        this.endLog(logLabel);
+    }
+
+    async clear_text(element) {
+        const logLabel = `Clear text on element ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            let uiElement = await tppElement.locator();
+            await uiElement.clearValue(); 
+        } catch (e) {
+          await this.handleElementException(e, tppElement, logLabel, true); 
+        }
+        this.endLog(logLabel);
+    }
+
+    async wait_for_element_visible(element) {
+        const logLabel = `Wait for - ${element.label} to be visible`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            let uiElement = await tppElement.locator();
+            await this.waitForElementVisiblity(uiElement);
+        } catch (e) {
+            await this.handleElementException(e, tppElement, logLabel, true);
+        }
+        this.endLog(logLabel);
+    }
+
+    async wait_for_element_visible_ms(element, timeout) {
+        const logLabel = `Wait for - ${element.label} to be visible within ${timeout} ms`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1, (timeout / 1000) || 20000);
+        try {
+            let uiElement = await tppElement.locator();
+            await this.waitForElementVisiblity(uiElement, timeout);
+        } catch (e) {
+            await this.handleElementException(e, tppElement, logLabel, true);
+        }
+        this.endLog(logLabel);
+    }
+
+    async wait_for_element(element) {
+        const logLabel = `Wait for - ${element.label} to be present`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            let uiElement = await tppElement.locator();
+            await this.waitForElementExists(uiElement);
+        } catch (e) {
+            await this.handleElementException(e, tppElement, logLabel, true);
+        }
+        this.endLog(logLabel);
+    }
+
+    async wait_for_element_ms(element, timeout) {
+        const logLabel = `Wait for - ${element.label} to be present within ${timeout} ms`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1, (timeout / 1000) || 20000);
+        try {
+            let uiElement = await tppElement.locator();
+            await this.waitForElementExists(uiElement, timeout);
+        } catch (e) {
+            await this.handleElementException(e, tppElement, logLabel, true);
+        }
+        this.endLog(logLabel);
+    }
+
+    async wait_for_element_to_disappear(element) {
+        const logLabel = `Wait for elment - ${element.label} to disappear`;
+        this.startLog(logLabel);
+        const timeout = (this.timeouts?.actionTimeout || 30) * 1000;
+        const tppElement = new TppElement(element, this.driver);
+        try {
+            await this.driver.waitUntil(
+                async () => (await tppElement.getCount()) === 0,
+                {timeout: timeout},
+            );
+        } catch (_ex) {
+            this.failureLog(logLabel);
+            throw {message: `Element is still visible after ${timeout} ms`};
+        }
+        this.endLog(logLabel);
+    }
+    
+    async wait_for_element_to_disappear_ms(element, duration) {
+        const logLabel = `Wait for elment - ${element.label} to disappear within ${duration} ms`;
+        this.startLog(logLabel);
+        const timeout = duration || ((this.timeouts?.actionTimeout || 30) * 1000);
+        const tppElement = new TppElement(element, this.driver);
+        try {
+            await this.driver.waitUntil(
+                async () => (await tppElement.getCount()) === 0,
+                {timeout: timeout},
+            );
+        } catch (_ex) {
+            this.failureLog(logLabel);
+            throw {message: `Element is still visible after ${timeout} ms`};
+        }
+        this.endLog(logLabel);
+    }
+
+    async verify_element_count(element, count) {
+        const logLabel = `Verify if count of - ${element.label} == ${count}`;
+        this.startLog(logLabel);
+        count = Number(count);
+        const timeout = (this.timeouts?.actionTimeout || 30) * 1000;
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, count);
+        try {
+            await this.driver.waitUntil(
+                async () => (await tppElement.getCount()) === count,
+                {timeout: timeout},
+            );
+        } catch (e) {
+            let currentCount = await tppElement.getCount();
+            throw {message: `Count of element is not as expeced: found ${currentCount} vs expected ${count}`}
+        }
+        this.endLog(logLabel);
+    }
+
+    async verify_element_text(element, text) {
+        const logLabel = `Verify if text of - ${element.label} == ${text.replaceAll("\n", " ")}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        const timeout = (this.timeouts?.actionTimeout || 30) * 1000;
+        try {
+            await this.driver.waitUntil(
+                async () => (await (await tppElement.locator()).getText()) === text,
+                {timeout: timeout},
+            );
+        } catch (e) {
+            await this.waitForElementExists(await tppElement.locator(), 5000);
+            let uiElement = await tppElement.locator();
+            let currentText = await uiElement.getText();
+            throw {message: `Text of element is not as expeced: found ${currentText} vs expected ${text}`}
+        }
+        this.endLog(logLabel);
+    }
+
+    async verify_if_element_present(element) {
+        const logLabel = `Verify if element - ${element.label} is present`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            let uiElement = await tppElement.locator();
+            await this.waitForElementExists(uiElement);
+        } catch (e) {
+            await this.handleElementException(e, tppElement, logLabel, true);
+        }
+        this.endLog(logLabel);
+    }
+
+    async verify_if_element_visible(element) {
+        const logLabel = `Verify if element - ${element.label} is visible`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        try {
+            let uiElement = await tppElement.locator();
+            await this.waitForElementVisiblity(uiElement);
+        } catch (e) {
+            await this.handleElementException(e, tppElement, logLabel, true);
+        }
+        this.endLog(logLabel);
+    }
+
+    isStaleElementException(e) {
+        return e?.name && e.name === 'stale element reference error';
+    }
+
+    // If expected count is 1, wait when multiple elements are matching
+    async tpp_element_or_backup(element, logLabel, expectedCount, timeOutSeconds) {
+        let i = 0;
+        let expected = element.index != null ? 2 : expectedCount;
+        while (i < 4) {
+            try {
+                return await this.getTppElementOrBackup(element, logLabel, expected, timeOutSeconds);
+            } catch (e) {
+                i++;
+                if (i < 4 && this.isStaleElementException(e)) {
+                    this.log(logLabel, `Stale Element Reference. Retrying... #${i}`);
+                } else {
+                    throw e;
+                }
+            }
+        }
+    }
+
+    async is_element_visible(element, timeout) {
+        const logLabel = `Is element - ${element.label} visible within ${timeout} ms`;
+        this.startLog(logLabel);
+        if(timeout === -1) timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+        const tppElement = new TppElement(element, this.driver);
+        try {
+            let uiElement = await tppElement.locator();
+            await this.waitForElementVisiblity(uiElement, timeout);
+        } catch (ex) {
+            this.log(logLabel, `Returning false! Exception - ${ex}`);
+            this.endLog(logLabel);
+            return false;
+        }
+        this.endLog(logLabel);
+        return true;
+    }
+    
+    async is_element_present(element, timeout) {
+        const logLabel = `Is element - ${element.label} present within ${timeout} ms`;
+        this.startLog(logLabel);
+        if(timeout === -1) timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+        const tppElement = new TppElement(element, this.driver);
+        try {
+            let uiElement = await tppElement.locator();
+            await this.waitForElementExists(uiElement, timeout);
+        } catch (ex) {
+            this.log(logLabel, `Returning false! Exception - ${ex}`);
+            this.endLog(logLabel);
+            return false;
+        }
+        this.endLog(logLabel);
+        return true;
+    }
+
+    async is_nth_element_present(element, n, timeout) {
+        const tppElement = new TppElement(element, this.driver);
+        let exception = undefined;
+        const startTime = Date.now();
+        while (Date.now() - startTime < (timeout || 10000)) {
+            exception = undefined; //Ignore the exception other than the last iteration
+            try {
+                const elements = await this.driver.$$(tppElement.getSelector());
+                if (elements.length > n) {
+                    return true;
+                }
+            } catch (ex) {
+                exception = ex;
+            }
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+
+        if(exception) {
+          this.log(logLabel, `Returning false! Exception - ${e}`);
+        }
+        return false;
+    }
+
+    async is_element_enabled(element, timeout) {
+        const logLabel = `Is element - ${element.label} enabled within ${timeout} ms`;
+        this.startLog(logLabel);
+        if(timeout === 0) timeout = 100;
+        if(timeout === -1) timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+        const tppElement = new TppElement(element, this.driver);
+        try {
+            let uiElement = await tppElement.locator();
+            await this.waitForElementActionable(uiElement, timeout);
+        } catch (ex) {
+            this.log(logLabel, `Returning false! Exception - ${ex}`);
+            this.endLog(logLabel);
+            return false;
+        }
+        this.endLog(logLabel);
+        return true;
+    }
+
+    async is_element_checked(element, timeout) {
+        const logLabel = `Is element - ${element.label} checked within ${timeout} ms`;
+        this.startLog(logLabel);
+        if(timeout === 0) timeout = 100;
+        if(timeout === -1) timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+        const tppElement = new TppElement(element, this.driver);
+        let uiElement;
+        try {
+            uiElement = await tppElement.locator();
+            await this.waitForElementVisiblity(uiElement, timeout);
+        } catch (ex) {
+            this.log(logLabel, `Element not visible - ${ex}`);
+            this.endLog(logLabel);
+            return false;
+        }
+        try {
+            await this.driver.waitUntil(
+                async () => {
+                    const isChecked = await uiElement.getAttribute('checked');
+                    return isChecked === 'true';
+                },
+                {
+                    timeout: timeout, // Timeout in milliseconds
+                    timeoutMsg: `Element was not checked within ${timeout} ms`,
+                }
+            );
+        } catch (ex) {
+            this.log(logLabel, `Element not checked - ${ex}`);
+            this.endLog(logLabel);
+            return false;
+        }
+
+        this.endLog(logLabel);
+        return true;
+    }
+
+    //Unused
+    async waitForElementDisappear(element, userTimeout) {
+        let timeout = userTimeout || ((this.timeouts?.actionTimeout || 30) * 1000);
+        const tppElement = new TppElement(element, this.driver);
+        const startTime = Date.now();
+        let size;
+        while (Date.now() - startTime < timeout) {
+            exception = undefined; //Ignore the exception other than the last iteration
+            try {
+                const elements = await this.driver.$$(tppElement.getSelector());
+                size = elements?.length;
+                if (size && size <= 0) {
+                    return;
+                }
+            } catch (ex) {
+                return;
+            }
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+        throw {message: `Element is still visible after ${timeout} ms. Count = ${size}`};
+    }
+
+    async get_element_text(element) {
+        const logLabel = `Get text of - ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        let uiElement = await tppElement.locator();
+        let text = await uiElement.getText();
+        this.endLog(logLabel);
+        return text;
+      }
+    
+    async get_element_count(element) {
+        const logLabel = `Get count of - ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 0);
+        const count = await tppElement.getCount();
+        this.endLog(logLabel);
+        return count;
+    }
+
+    async get_element_attribute(attribute, element) {
+        const logLabel = `Get attribute ${attribute} from element ${element.label}`;
+        this.startLog(logLabel);
+        const tppElement = await this.tpp_element_or_backup(element, logLabel, 1);
+        let uiElement = await tppElement.locator();
+        try {
+            let attributeValue = await uiElement.getAttribute(attribute);
+            this.endLog(logLabel);
+            return attributeValue;
+        } catch (e) {
+            if(e.message.includes(" attribute is unknown ")) {
+                this.failureLog(logLabel);
+                throw {message: `Attribute ${attribute} is not present in element ${element.label}`};
+            }
+            await this.handleElementException(e, tppElement, logLabel, true);
+        }
+    }
+
+    get_nth_element(element, n) {
+        const logLabel = `Get nth element of ${element.label}. n = ${n}`;
+        n = Number(n);
+        this.startLog(logLabel);
+        if(n < 0) {
+          throw {
+            message: `index n = ${n} is invalid. should be >= 0`,
+          };
+        }
+        this.endLog(logLabel);
+        return {...element, index: n};
+    }
+
+    async wait_for_single_element(element, timeOutSeconds) {
+        const tppElement = new TppElement(element, this.driver);
+        let count = await tppElement.getCount();
+        let i = 0;
+        while(count != 1 && i < timeOutSeconds) {
+          await sleep(1000);
+          count = await tppElement.getCount();
+          i++;
+        }
+        return count === 1;
+    }
+
+    async take_screenshot(label) {
+        const logLabel = `Take Screenshot with label ${label}`;
+        this.startLog(logLabel);
+        await this.addScreenshotWithLogs(label);
+        this.endLog(logLabel);
+    }
+
+    async addScreenshotWithLogs(imageName) {
+        const filePath = getScreenshotPath(imageName, this.caller, this.retry);
+        try {
+            await this.addScreenshot(filePath);
+            this.action_log(getScreenshotLog(imageName, filePath, this.caller));
+        } catch (ex) {
+            this.exceptionLog(`Error capturing screenshot - ${ex.message || 'screenshot failed'}.`);
+        }
+    }
+
+    async addScreenshot(filePath) {
+        const screenshotBase64 = await this.driver.takeScreenshot();
+        new FileUtils().createParentIfNotPresent(filePath);
+        fs.writeFileSync(filePath, screenshotBase64, 'base64');
+    }
+
+    async getSpecialExceptionMessage(tppElement, ignoreCount) {
+        const eleCount = await tppElement.getCount();
+        if(eleCount <= 0) {
+            return undefined;
+        }
+        if(!ignoreCount && eleCount > 1) {
+            return {message: "More than one element is matching in the DOM"};
+        }
+        //TODO handle other mobile element exceptions
+    }
+
+    async throwElementNotPresent(element, label, expectSingle) {
+        this.failureLog(label);
+        const tppElement = new TppElement(element, this.driver)
+        const specilExcpetion = await this.getSpecialExceptionMessage(tppElement, !expectSingle);
+        let ex = specilExcpetion || {message: `Unable to find element : ${element.label} : ${tppElement.getSelector()}${new Logger().getIndexLog(tppElement)}`}
+        throw ex;
+    }
+
+    async handleElementException(ex, tppElement, label, expectSingle) {
+        if(ex.source === 'tpp') {
+          this.failureLog(label);
+          throw ex;
+        }
+        const regex = /^elements_\d+\.(\w+) is not a function(?:.*)?$/;
+        const match = ex.message.match(regex);
+        if(match){
+          const missingElement = match[1];
+          this.failureLog(`Element : ${missingElement} not defined in Page file`);
+          throw {message : `Element : ${missingElement} not defined in Page file`};
+        }
+        if(expectSingle && await tppElement.getCount() > 1) {
+          throw {message: "More than one element is matching in the DOM"};
+        }
+        this.action_log("Element exception: ", ex);
+        this.failureLog(label);
+        // const exceptionLines = (ex?.message || ex.toString()).split('\n');
+        // const message = exceptionLines[0].replace(ansiRegex(), '');
+        throw ex;
+    }
+
+    async handleClickException(e, tppElement, logLabel, ignoreCount) {
+        let ex = e;
+        console.log("Click exception: ", ex);
+        const specilExcpetion = await this.getSpecialExceptionMessage(tppElement, ignoreCount);
+        if(specilExcpetion) ex = specilExcpetion;
+        await this.handleElementException(ex, tppElement, logLabel); 
+    }
+  
+    async getTppElementOrBackup(element, logLabel, expectedCount, timeOutSeconds) {
+        if (expectedCount === 0) {
+            return new TppElement(element, this.driver);
+        }
+    
+        const checkFn = async (ele) => {
+            if (expectedCount === 1) {
+                return await this.wait_for_single_element(ele, timeOutSeconds || (element.backupLocators?.length ? 10 : this.timeouts?.actionTimeout || 30));
+            }
+            return await this.is_nth_element_present(ele, 0);
+        };
+    
+        if (await checkFn(element)) {
+            return new TppElement(element, this.driver);
+        }
+
+        if (!element.backupLocators?.length) {
+            await this.throwElementNotPresent(element, logLabel, expectedCount === 1);
+        }
+    
+        let i = 0;
+        let tppElement = new TppElement(element, this.driver);
+        while (i < element.backupLocators.length) {
+            new Logger(this.caller, this.blacklistedLogs).elementBackupRetryLog(tppElement, i, logLabel);
+            const backup = element.backupLocators[i];
+            tppElement = new TppElement(
+                { ...element, ...backup },
+                this.driver,
+            );
+        
+            if (await checkFn(tppElement.element)) {
+                new Logger(this.caller, this.blacklistedLogs).logBackupLocatorUsed(tppElement);
+                return tppElement;
+            }
+            i++;
+        }
+    
+        return new TppElement(element, this.driver);
+    }
+
+    log(stepName, msg) {
+        new Logger(this.caller, this.blacklistedLogs).log(stepName, msg);
+    }
+
+    startLog(stepName) {
+        new Logger(this.caller, this.blacklistedLogs).startLog(stepName);
+    }
+
+    endLog(stepName) {
+        new Logger(this.caller, this.blacklistedLogs).endLog(stepName);
+    }
+
+    failureLog(stepName) {
+        new Logger(this.caller, this.blacklistedLogs).failureLog(stepName);
+    }
+
+    action_log(log) {
+        new Logger(this.caller, this.blacklistedLogs).action_log(log);
+    }
+
+    exceptionLog(message) {
+        if(typeof message === 'string'){
+            const errorLines = message.split('\n');
+            for(let i = 0;i < errorLines.length; i++){
+                this.action_log(`${LOG_PREFIX}${this.caller} :: [EXCEPTION] ${errorLines[i]}`);
+            }
+        }
+        else {
+            this.action_log(`${LOG_PREFIX}${this.caller} :: [EXCEPTION] ${message}`);
+        }
+    }
+}
+
+exports.MobileActions = MobileActions;