How to use driver.unlock method in Appium Android Driver

1import { Given, When, Then } from '@cucumber/cucumber';
2import LandingPage from '../pageobjects/landing.page';
3import LoginPage from '../pageobjects/login.page';
4
5Given(/^I open the demo app$/, async () => {
6    await console.log('Mobile app is open');
7});
8
9When(/^I lock device$/, async () => {
10    await driver.lock();
11});
12
13When(/^I unlock device$/, async () => {
14    await driver.unlock();
15});
16
17When(/^I navigate to login tab$/, async () => {
18    await LandingPage.btnLogin_tap();
19});
20
21When(
22    /^I initiate login with ([^"]*)? and ([^"]*)?$/,
23    async (email, password) => {
24        await LoginPage.txtEmail_setText(email);
25        await LoginPage.txtPassword_setText(password);
26        await LoginPage.btnLogin_tap();
27    },
28);
29
30Then(/^I close the app$/, async () => {
31    await driver.closeApp();
32});
33

Source: steps.js

import { Given, When, Then } from '@cucumber/cucumber';
import LandingPage from '../pageobjects/landing.page';
import LoginPage from '../pageobjects/login.page';

Given(/^I open the demo app$/, async () => {
    await console.log('Mobile app is open');
});

When(/^I lock device$/, async () => {
    await driver.lock();
});

When(/^I unlock device$/, async () => {
    await driver.unlock();
});

When(/^I navigate to login tab$/, async () => {
    await LandingPage.btnLogin_tap();
});

When(
    /^I initiate login with ([^"]*)? and ([^"]*)?$/,
    async (email, password) => {
        await LoginPage.txtEmail_setText(email);
        await LoginPage.txtPassword_setText(password);
        await LoginPage.btnLogin_tap();
    },
);

Then(/^I close the app$/, async () => {
    await driver.closeApp();
});

1'use strict';
2
3(function () {
4    function getDriver (callback) {
5        var interval = window.setInterval(function () {
6            var testCafeDriver = window['%testCafeDriverInstance%'];
7
8            if (testCafeDriver) {
9                window.clearInterval(interval);
10                callback(testCafeDriver);
11            }
12        }, 50);
13    }
14
15    // NOTE: enable interaction with a page when the last test is completed
16    var UNLOCK_PAGE_FLAG = 'testcafe-live|driver|unlock-page-flag';
17
18    // TestCafe > 0.18.5 required
19    getDriver(function (testCafeDriver) {
20        var testCafeCore = window['%testCafeCore%'];
21        var hammerhead   = window['%hammerhead%'];
22
23        testCafeDriver.setCustomCommandHandlers('unlock-page', function () {
24            testCafeCore.disableRealEventsPreventing();
25
26            testCafeDriver.contextStorage.setItem(UNLOCK_PAGE_FLAG, true);
27
28            return hammerhead.Promise.resolve();
29        });
30
31        var chain = testCafeDriver.contextStorage ? hammerhead.Promise.resolve() : testCafeDriver.readyPromise;
32
33        chain.then(function () {
34            if (testCafeDriver.contextStorage.getItem(UNLOCK_PAGE_FLAG))
35                testCafeCore.disableRealEventsPreventing();
36        });
37    });
38})();

Source: index.js

'use strict';

(function () {
    function getDriver (callback) {
        var interval = window.setInterval(function () {
            var testCafeDriver = window['%testCafeDriverInstance%'];

            if (testCafeDriver) {
                window.clearInterval(interval);
                callback(testCafeDriver);
            }
        }, 50);
    }

    // NOTE: enable interaction with a page when the last test is completed
    var UNLOCK_PAGE_FLAG = 'testcafe-live|driver|unlock-page-flag';

    // TestCafe > 0.18.5 required
    getDriver(function (testCafeDriver) {
        var testCafeCore = window['%testCafeCore%'];
        var hammerhead   = window['%hammerhead%'];

        testCafeDriver.setCustomCommandHandlers('unlock-page', function () {
            testCafeCore.disableRealEventsPreventing();

            testCafeDriver.contextStorage.setItem(UNLOCK_PAGE_FLAG, true);

            return hammerhead.Promise.resolve();
        });

        var chain = testCafeDriver.contextStorage ? hammerhead.Promise.resolve() : testCafeDriver.readyPromise;

        chain.then(function () {
            if (testCafeDriver.contextStorage.getItem(UNLOCK_PAGE_FLAG))
                testCafeCore.disableRealEventsPreventing();
        });
    });
})();

1// https://webdriver.io/docs/api/appium.html
2
3describe('Exercice 3', function() {
4	it('Can open notifications center', function() {
5		driver.openNotifications()
6		driver.pause(3000)
7	})
8
9	it('Can lock device', function() {
10		driver.lock()
11		driver.pause(3000)
12		expect(driver.isLocked()).toBe(true)
13		driver.unlock()
14	})
15
16	it('Can open settings app', function() {
17		// android
18		// adb shell dumpsys window windows | grep -E 'mCurrentFocus'
19		driver.startActivity('com.android.settings', 'com.android.settings.Settings')
20		driver.pause(3000)
21
22		// ios
23		// https://emm.how/t/ios-12-list-of-default-apps-and-bundle-id-s/790
24		// driver.launchApp({ bundleId: "com.apple.Preferences" })
25	})
26})

Source: exercice3.js

// https://webdriver.io/docs/api/appium.html

describe('Exercice 3', function() {
	it('Can open notifications center', function() {
		driver.openNotifications()
		driver.pause(3000)
	})

	it('Can lock device', function() {
		driver.lock()
		driver.pause(3000)
		expect(driver.isLocked()).toBe(true)
		driver.unlock()
	})

	it('Can open settings app', function() {
		// android
		// adb shell dumpsys window windows | grep -E 'mCurrentFocus'
		driver.startActivity('com.android.settings', 'com.android.settings.Settings')
		driver.pause(3000)

		// ios
		// https://emm.how/t/ios-12-list-of-default-apps-and-bundle-id-s/790
		// driver.launchApp({ bundleId: "com.apple.Preferences" })
	})
})

1angular.module("gdCameApp").controller("ItemsController",
2[
3    "$rootScope", "$scope", "gameData", "gdCameApiService",
4    function ($rootScope, $scope, gameData, gdCameApiService) {
5        $scope.items = [];
6        $scope.itemsGroups = [];
7
8        gameData.then(function (data) {
9            $scope.items = data.items;
10            var indexInGroup = 0;
11            var itemsGroup = [];
12            $scope.items.forEach(function (value, index) {
13                if (indexInGroup === 4) {
14                    $scope.itemsGroups.push(itemsGroup);
15                    itemsGroup = [];
16                    indexInGroup = 0;
17                }
18                itemsGroup.push(value);
19                indexInGroup++;
20            });
21            if (itemsGroup.length > 0) {
22                itemsGroup.push(new Array(4 - itemsGroup.length));
23                $scope.itemsGroups.push(itemsGroup);
24            }
25        });
26
27        $scope.$on("update.items",
28            function (event, value) {
29                $scope.items = value.items;
30            });
31
32        $scope.buyFundDriver = function (fundDriverId) {
33            var oldFundDriver = $scope.items.filter(function (item, index) {
34                return item.id === fundDriverId;
35            })[0];
36
37            if (oldFundDriver && oldFundDriver.unlockBalance > $rootScope.gameData.cash.counters[0].value) {
38                return;
39            }
40
41            gdCameApiService.buyFundDriver(fundDriverId)
42                .then(function (value) {
43                    if (value.data == undefined) return;
44                    var itemIndex;
45                    var oldFundDriver = $scope.items.filter(function (item, index) {
46                        itemIndex = index;
47                        return item.id === value.data.itemBuyInfo.id;
48                    })[0];
49
50                    if (oldFundDriver != undefined) {
51                        oldFundDriver.bought = value.data.itemBuyInfo.bought;
52                        oldFundDriver.price = value.data.itemBuyInfo.price;
53
54                        if (value.data.modifiedCountersInfo != undefined) {
55                            $rootScope.$broadcast("counters.update", value.data.modifiedCountersInfo);
56                        }
57                    }
58                });
59        };
60    }
61]);

Source: itemsController.js

angular.module("gdCameApp").controller("ItemsController",
[
    "$rootScope", "$scope", "gameData", "gdCameApiService",
    function ($rootScope, $scope, gameData, gdCameApiService) {
        $scope.items = [];
        $scope.itemsGroups = [];

        gameData.then(function (data) {
            $scope.items = data.items;
            var indexInGroup = 0;
            var itemsGroup = [];
            $scope.items.forEach(function (value, index) {
                if (indexInGroup === 4) {
                    $scope.itemsGroups.push(itemsGroup);
                    itemsGroup = [];
                    indexInGroup = 0;
                }
                itemsGroup.push(value);
                indexInGroup++;
            });
            if (itemsGroup.length > 0) {
                itemsGroup.push(new Array(4 - itemsGroup.length));
                $scope.itemsGroups.push(itemsGroup);
            }
        });

        $scope.$on("update.items",
            function (event, value) {
                $scope.items = value.items;
            });

        $scope.buyFundDriver = function (fundDriverId) {
            var oldFundDriver = $scope.items.filter(function (item, index) {
                return item.id === fundDriverId;
            })[0];

            if (oldFundDriver && oldFundDriver.unlockBalance > $rootScope.gameData.cash.counters[0].value) {
                return;
            }

            gdCameApiService.buyFundDriver(fundDriverId)
                .then(function (value) {
                    if (value.data == undefined) return;
                    var itemIndex;
                    var oldFundDriver = $scope.items.filter(function (item, index) {
                        itemIndex = index;
                        return item.id === value.data.itemBuyInfo.id;
                    })[0];

                    if (oldFundDriver != undefined) {
                        oldFundDriver.bought = value.data.itemBuyInfo.bought;
                        oldFundDriver.price = value.data.itemBuyInfo.price;

                        if (value.data.modifiedCountersInfo != undefined) {
                            $rootScope.$broadcast("counters.update", value.data.modifiedCountersInfo);
                        }
                    }
                });
        };
    }
]);

1/**
2 * (C) Copyright 2015 Manuel Martins.
3 *
4 * This module is inspired by json_file_system.
5 * (json_file_system is Copyright (c) 2014 Jalal Hejazi,
6 *  Licensed under the MIT license.)
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 *     http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 * Created by: ManuelMartins
21 * Created on: 26-01-2016
22 *
23 */
24
25'use strict';
26
27var Memory = require('./memory');
28var Disk = require('./disk');
29
30/**
31 * Provides the most common I/O operations.
32 *
33 * @param {object} options
34 * @param {object} options.db
35 * @param {object} options.db._
36 * @param {string} options.db._._driver
37 * @constructor
38 */
39function DataHandler(options) {
40  options = options || {};
41  var dataHandler = options.db._db._driver || 'disk';
42  switch (dataHandler) {
43    // load the driver to be used just once
44    case 'memory':
45      this.dataHandlerDriver = new Memory(options);
46      break;
47    case 'disk':
48    default:
49      this.dataHandlerDriver = new Disk(options);
50  }
51}
52
53/**
54 * Writes a list of objects to the data driver
55 *
56 * @param content the content to write
57 * @param callback
58 */
59DataHandler.prototype.set = function write(content, callback) {
60  return this.dataHandlerDriver.set(content, callback);
61};
62
63/**
64 * Reads a list of objects from the data driver
65 *
66 * @param callback
67 */
68DataHandler.prototype.get = function read(callback) {
69  return this.dataHandlerDriver.get(callback);
70};
71
72/**
73 * Locks the data provider
74 *
75 * @param callback
76 */
77DataHandler.prototype.lock = function read(callback) {
78  return this.dataHandlerDriver.lock(callback);
79};
80
81/**
82 * Unlocks the data provider
83 *
84 * @param callback
85 */
86DataHandler.prototype.unlock = function read(callback) {
87  return this.dataHandlerDriver.unlock(callback);
88};
89
90
91module.exports = DataHandler;
92

Source: dataHandler.js

/**
 * (C) Copyright 2015 Manuel Martins.
 *
 * This module is inspired by json_file_system.
 * (json_file_system is Copyright (c) 2014 Jalal Hejazi,
 *  Licensed under the MIT license.)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Created by: ManuelMartins
 * Created on: 26-01-2016
 *
 */

'use strict';

var Memory = require('./memory');
var Disk = require('./disk');

/**
 * Provides the most common I/O operations.
 *
 * @param {object} options
 * @param {object} options.db
 * @param {object} options.db._
 * @param {string} options.db._._driver
 * @constructor
 */
function DataHandler(options) {
  options = options || {};
  var dataHandler = options.db._db._driver || 'disk';
  switch (dataHandler) {
    // load the driver to be used just once
    case 'memory':
      this.dataHandlerDriver = new Memory(options);
      break;
    case 'disk':
    default:
      this.dataHandlerDriver = new Disk(options);
  }
}

/**
 * Writes a list of objects to the data driver
 *
 * @param content the content to write
 * @param callback
 */
DataHandler.prototype.set = function write(content, callback) {
  return this.dataHandlerDriver.set(content, callback);
};

/**
 * Reads a list of objects from the data driver
 *
 * @param callback
 */
DataHandler.prototype.get = function read(callback) {
  return this.dataHandlerDriver.get(callback);
};

/**
 * Locks the data provider
 *
 * @param callback
 */
DataHandler.prototype.lock = function read(callback) {
  return this.dataHandlerDriver.lock(callback);
};

/**
 * Unlocks the data provider
 *
 * @param callback
 */
DataHandler.prototype.unlock = function read(callback) {
  return this.dataHandlerDriver.unlock(callback);
};


module.exports = DataHandler;