diff --git a/powermgr/BUILD.gn b/powermgr/BUILD.gn index 4eff12d1d331e2fedf07169104bfcdb77ea54e9a..9e5ea1c3c0f65aa0d8a72d96272db0509c9b91d2 100755 --- a/powermgr/BUILD.gn +++ b/powermgr/BUILD.gn @@ -13,8 +13,13 @@ import("//build/ohos_var.gni") group("powermgr") { testonly = true - - if (is_standard_system) { - deps = [ "powermgrbattery:powermgr_battery_test" ] + if (device_name == "rk3568") { + if (is_standard_system) { + deps = [ "powermgrbattery_rk3568:powermgr_battery_test_rk3568" ] + } + } else { + if (is_standard_system) { + deps = [ "powermgrbattery:powermgr_battery_test" ] + } } } diff --git a/powermgr/powermgrbattery_rk3568/BUILD.gn b/powermgr/powermgrbattery_rk3568/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..b5104b4f2d20f435bfe526085a1432a89c50e2a2 --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/BUILD.gn @@ -0,0 +1,31 @@ +# Copyright (C) 2021 Huawei Device Co., Ltd. +# 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. + +import("//test/xts/tools/build/suite.gni") + +ohos_js_hap_suite("powermgr_battery_test_rk3568") { + hap_profile = "./src/main/config.json" + deps = [ + ":powermgr_battery_js_assets", + ":powermgr_battery_resources", + ] + certificate_profile = "./signature/openharmony_sx.p7b" + hap_name = "ActsPowerMgrBatteryTest" +} +ohos_js_assets("powermgr_battery_js_assets") { + source_dir = "./src/main/js/default" +} +ohos_resources("powermgr_battery_resources") { + sources = [ "./src/main/resources" ] + hap_profile = "./src/main/config.json" +} diff --git a/powermgr/powermgrbattery_rk3568/Test.json b/powermgr/powermgrbattery_rk3568/Test.json new file mode 100755 index 0000000000000000000000000000000000000000..b7ac14baa0bfe07ecb410328a63c5db264bfac39 --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/Test.json @@ -0,0 +1,19 @@ +{ + "description": "Configuration for powermgr battery Tests", + "driver": { + "type": "JSUnitTest", + "test-timeout": "60000", + "package": "com.example.mybatteryapp", + "shell-timeout": "60000" + }, + "kits": [ + { + "test-file-name": [ + "ActsPowerMgrBatteryTest.hap" + ], + "type": "AppInstallKit", + "cleanup-apps": true + } + ] +} + diff --git a/powermgr/powermgrbattery_rk3568/signature/openharmony_sx.p7b b/powermgr/powermgrbattery_rk3568/signature/openharmony_sx.p7b new file mode 100755 index 0000000000000000000000000000000000000000..9be1e98fa4c0c28ca997ed660112fa16b194f0f5 Binary files /dev/null and b/powermgr/powermgrbattery_rk3568/signature/openharmony_sx.p7b differ diff --git a/powermgr/powermgrbattery_rk3568/src/main/config.json b/powermgr/powermgrbattery_rk3568/src/main/config.json new file mode 100755 index 0000000000000000000000000000000000000000..45115324edc81c7cb27ee33c47e004b1be4f5d66 --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/src/main/config.json @@ -0,0 +1,60 @@ +{ + "app": { + "bundleName": "com.example.mybatteryapp", + "vendor": "example", + "version": { + "code": 1, + "name": "1.0" + }, + "apiVersion": { + "compatible": 4, + "target": 5 + } + }, + "deviceConfig": {}, + "module": { + "package": "com.example.mybatteryapp", + "name": ".MyApplication", + "deviceType": [ + "phone" + ], + "distro": { + "deliveryWithInstall": true, + "moduleName": "entry", + "moduleType": "entry" + }, + "abilities": [ + { + "visible": true, + "skills": [ + { + "entities": [ + "entity.system.home" + ], + "actions": [ + "action.system.home" + ] + } + ], + "name": "com.example.mybatteryapp.MainAbility", + "icon": "$media:icon", + "description": "$string:mainability_description", + "label": "$string:app_name", + "type": "page", + "launchType": "standard" + } + ], + "js": [ + { + "pages": [ + "pages/index/index" + ], + "name": "default", + "window": { + "designWidth": 720, + "autoDesignWidth": false + } + } + ] + } +} diff --git a/powermgr/powermgrbattery_rk3568/src/main/js/default/app.js b/powermgr/powermgrbattery_rk3568/src/main/js/default/app.js new file mode 100755 index 0000000000000000000000000000000000000000..f796f6a0d8dde8b67d055b283776f27d4d06ac0f --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/src/main/js/default/app.js @@ -0,0 +1,24 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * 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. + */ +import device from '@system.device'; + +export default { + onCreate() { + console.info('AceApplication onCreate'); + }, + onDestroy() { + console.info('AceApplication onDestroy'); + } +}; diff --git a/powermgr/powermgrbattery_rk3568/src/main/js/default/i18n/en-US.json b/powermgr/powermgrbattery_rk3568/src/main/js/default/i18n/en-US.json new file mode 100755 index 0000000000000000000000000000000000000000..e63c70d978a3a53be988388c87182f81785e170c --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/src/main/js/default/i18n/en-US.json @@ -0,0 +1,6 @@ +{ + "strings": { + "hello": "Hello", + "world": "World" + } +} \ No newline at end of file diff --git a/powermgr/powermgrbattery_rk3568/src/main/js/default/i18n/zh-CN.json b/powermgr/powermgrbattery_rk3568/src/main/js/default/i18n/zh-CN.json new file mode 100755 index 0000000000000000000000000000000000000000..de6ee5748322f44942c1b003319d8e66c837675f --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/src/main/js/default/i18n/zh-CN.json @@ -0,0 +1,6 @@ +{ + "strings": { + "hello": "您好", + "world": "世界" + } +} \ No newline at end of file diff --git a/powermgr/powermgrbattery_rk3568/src/main/js/default/pages/index/index.css b/powermgr/powermgrbattery_rk3568/src/main/js/default/pages/index/index.css new file mode 100755 index 0000000000000000000000000000000000000000..6fda792753f2e15f22b529c7b90a82185b2770bf --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/src/main/js/default/pages/index/index.css @@ -0,0 +1,9 @@ +.container { + flex-direction: column; + justify-content: center; + align-items: center; +} + +.title { + font-size: 100px; +} diff --git a/powermgr/powermgrbattery_rk3568/src/main/js/default/pages/index/index.hml b/powermgr/powermgrbattery_rk3568/src/main/js/default/pages/index/index.hml new file mode 100755 index 0000000000000000000000000000000000000000..f64b040a5ae394dbaa5e185e1ecd4f4556b92184 --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/src/main/js/default/pages/index/index.hml @@ -0,0 +1,5 @@ +
+ + {{ $t('strings.hello') }} {{ title }} + +
diff --git a/powermgr/powermgrbattery_rk3568/src/main/js/default/pages/index/index.js b/powermgr/powermgrbattery_rk3568/src/main/js/default/pages/index/index.js new file mode 100755 index 0000000000000000000000000000000000000000..16c1ea4618cfa03c970f0b84b4fd366e0cf86ac9 --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/src/main/js/default/pages/index/index.js @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * 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. + */ +import app from '@system.app' + +import {Core, ExpectExtend} from 'deccjsunit/index' + +export default { + data: { + title: "" + }, + onInit() { + this.title = this.$t('strings.world'); + }, + onShow() { + console.info('onShow finish') + const core = Core.getInstance() + const expectExtend = new ExpectExtend({ + 'id': 'extend' + }) + core.addService('expect', expectExtend) +// core.addService('report', instrumentLog) + core.init() +// core.subscribeEvent('spec', instrumentLog) +// core.subscribeEvent('suite', instrumentLog) +// core.subscribeEvent('task', instrumentLog) + + const configService = core.getDefaultService('config') + configService.setConfig(this) + + require('../../test/List.test') + core.execute() + }, + onReady() { + }, +} \ No newline at end of file diff --git a/powermgr/powermgrbattery_rk3568/src/main/js/default/test/List.test.js b/powermgr/powermgrbattery_rk3568/src/main/js/default/test/List.test.js new file mode 100755 index 0000000000000000000000000000000000000000..227b8ccb5cfedfab6d7c84caf7965f74f58b0fd2 --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/src/main/js/default/test/List.test.js @@ -0,0 +1,16 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * 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. + */ +require('./battery_unit.test.js') +require('./power_manager_running_lock.test.js') \ No newline at end of file diff --git a/powermgr/powermgrbattery_rk3568/src/main/js/default/test/battery_unit.test.js b/powermgr/powermgrbattery_rk3568/src/main/js/default/test/battery_unit.test.js new file mode 100755 index 0000000000000000000000000000000000000000..fe6f759244250a7fd494b0e471b772eaee6ee917 --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/src/main/js/default/test/battery_unit.test.js @@ -0,0 +1,282 @@ ++137/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * 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. + */ + +import app from '@system.app' +import Context from '@ohos.napi_context' +import batteryInfo from '@ohos.batteryInfo'; +import brightness from '@ohos.brightness'; +import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' + +describe('appInfoTest', function () { + console.log("*************Battery Unit Test Begin*************"); + + /** + * @tc.number battery_manager_js_0100 + * @tc.name battery_soc_test + * @tc.desc Battery acquisition kit + */ + it('battery_soc_test', 0, function () { + var batterySoc = batteryInfo.batterySOC; + console.info('batterySoc = ' + batterySoc); + expect(batterySoc >= -1 && batterySoc <= 100).assertTrue() + }) + + /** + * @tc.number battery_manager_js_0200 + * @tc.name charging_status_test + * @tc.desc Battery charging kit + */ + it('charging_status_test', 0, function () { + var chargingStatus = batteryInfo.chargingStatus; + console.info('chargingStatus = ' + chargingStatus); + expect(chargingStatus >= 0 && chargingStatus <= 4).assertTrue() + }) + + /** + * @tc.number battery_manager_js_0300 + * @tc.name health_status_test + * @tc.desc Get Battery Health Get KIT + */ + it('health_status_test', 0, function () { + var healthStatus = batteryInfo.healthStatus; + console.info('healthStatus = ' + healthStatus); + expect(healthStatus >= 0 && healthStatus <= 6).assertTrue() + }) + + /** + * @tc.number battery_manager_js_0400 + * @tc.name plugged_type_test + * @tc.desc Obtaining the USB Connection Type KIT + */ + it('plugged_type_test', 0, function () { + var pluggedType = batteryInfo.pluggedType; + console.info('pluggedType = ' + pluggedType); + expect(pluggedType >= 0 && pluggedType <= 4).assertTrue() + }) + + /** + * @tc.number battery_manager_js_0500 + * @tc.name voltage_test + * @tc.desc Obtaining the Voltage Interface KIT + */ + it('voltage_test', 0, function () { + var voltage = batteryInfo.voltage; + console.info('voltage = ' + voltage); + expect(voltage >= -1).assertTrue() + }) + + /** + * @tc.number battery_manager_js_0600 + * @tc.name technology_test + * @tc.desc Obtaining the Battery Technology Interface KIT + */ + it('technology_test', 0, function () { + var technology = batteryInfo.technology; + console.info('technology = ' + technology); + expect(technology !== null).assertTrue() + }) + + /** + * @tc.number battery_manager_js_0700 + * @tc.name battery_temperature_test + * @tc.desc BatteryTemperature values Interface Test + */ + it('battery_temperature_test', 0, function () { + var batteryTemperature = batteryInfo.batteryTemperature; + console.info('batteryTemperature = ' + batteryTemperature); + expect(batteryTemperature <= 700).assertTrue() + }) + + /** + * @tc.number battery_manager_js_0800 + * @tc.name enum_health_state_test_unknown + * @tc.desc BatteryHealthState values Interface Test + */ + it('enum_health_state_test_unknown', 0, function () { + var batteryHealthState = batteryInfo.BatteryHealthState.UNKNOWN; + console.info('batteryHealthState = ' + batteryHealthState); + expect(batteryHealthState == 0).assertTrue() + }) + + /** + * @tc.number battery_manager_js_0900 + * @tc.name enum_health_state_test_good + * @tc.desc BatteryHealthState values Interface Test + */ + it('enum_health_state_test_good', 0, function () { + var batteryHealthState = batteryInfo.BatteryHealthState.GOOD; + console.info('batteryHealthState = ' + batteryHealthState); + expect(batteryHealthState == 1).assertTrue() + }) + + /** + * @tc.number battery_manager_js_1000 + * @tc.name enum_health_state_test_overheat + * @tc.desc BatteryHealthState values Interface Test + */ + it('enum_health_state_test_overheat', 0, function () { + var batteryHealthState = batteryInfo.BatteryHealthState.OVERHEAT; + console.info('batteryHealthState = ' + batteryHealthState); + expect(batteryHealthState == 2).assertTrue() + }) + + /** + * @tc.number battery_manager_js_1100 + * @tc.name enum_health_state_test_overvoltage + * @tc.desc BatteryHealthState values Interface Test + */ + it('enum_health_state_test_overvoltage', 0, function () { + var batteryHealthState = batteryInfo.BatteryHealthState.OVERVOLTAGE; + console.info('batteryHealthState = ' + batteryHealthState); + expect(batteryHealthState == 3).assertTrue() + }) + + /** + * @tc.number battery_manager_js_1200 + * @tc.name enum_health_state_test_cold + * @tc.desc BatteryHealthState values Interface Test + */ + it('enum_health_state_test_cold', 0, function () { + var batteryHealthState = batteryInfo.BatteryHealthState.COLD; + console.info('batteryHealthState = ' + batteryHealthState); + expect(batteryHealthState == 4).assertTrue() + }) + + /** + * @tc.number battery_manager_js_1300 + * @tc.name enum_health_state_test_dead + * @tc.desc BatteryHealthState values Interface Test + */ + it('enum_health_state_test_dead', 0, function () { + var batteryHealthState = batteryInfo.BatteryHealthState.DEAD; + console.info('batteryHealthState = ' + batteryHealthState); + expect(batteryHealthState == 5).assertTrue() + }) + + /** + * @tc.number battery_manager_js_1400 + * @tc.name enum_charge_state_test_none + * @tc.desc BatteryChargeState values Interface Test + */ + it('enum_charge_state_test_none', 0, function () { + var batteryChargeState = batteryInfo.BatteryChargeState.NONE; + console.info('batteryChargeState = ' + batteryChargeState); + expect(batteryChargeState == 0).assertTrue() + }) + + /** + * @tc.number battery_manager_js_1500 + * @tc.name enum_charge_state_test_enable + * @tc.desc BatteryChargeState values Interface Test + */ + it('enum_charge_state_test_enable', 0, function () { + var batteryChargeState = batteryInfo.BatteryChargeState.ENABLE; + console.info('batteryChargeState = ' + batteryChargeState); + expect(batteryChargeState == 1).assertTrue() + }) + + /** + * @tc.number battery_manager_js_1600 + * @tc.name enum_charge_state_test_disable + * @tc.desc BatteryChargeState values Interface Test + */ + it('enum_charge_state_test_disable', 0, function () { + var batteryChargeState = batteryInfo.BatteryChargeState.DISABLE; + console.info('batteryChargeState = ' + batteryChargeState); + expect(batteryChargeState == 2).assertTrue() + }) + + /** + * @tc.number battery_manager_js_1700 + * @tc.name enum_charge_state_test_full + * @tc.desc BatteryChargeState values Interface Test + */ + it('enum_charge_state_test_full', 0, function () { + var batteryChargeState = batteryInfo.BatteryChargeState.FULL; + console.info('batteryChargeState = ' + batteryChargeState); + expect(batteryChargeState == 3).assertTrue() + }) + + /** + * @tc.number battery_manager_js_1800 + * @tc.name enum_plugged_type_test_none + * @tc.desc BatteryPluggedType values Interface Test + */ + it('enum_plugged_type_test_none', 0, function () { + var batteryPluggedType = batteryInfo.BatteryPluggedType.NONE; + console.info('batteryPluggedType = ' + batteryPluggedType); + expect(batteryPluggedType == 0).assertTrue() + }) + + /** + * @tc.number battery_manager_js_1900 + * @tc.name enum_plugged_type_test_ac + * @tc.desc BatteryPluggedType values Interface Test + */ + it('enum_plugged_type_test_ac', 0, function () { + var batteryPluggedType = batteryInfo.BatteryPluggedType.AC; + console.info('batteryPluggedType = ' + batteryPluggedType); + expect(batteryPluggedType == 1).assertTrue() + }) + + /** + * @tc.number battery_manager_js_2000 + * @tc.name enum_plugged_type_test_usb + * @tc.desc BatteryPluggedType values Interface Test + */ + it('enum_plugged_type_test_usb', 0, function () { + var batteryPluggedType = batteryInfo.BatteryPluggedType.USB; + console.info('batteryPluggedType = ' + batteryPluggedType); + expect(batteryPluggedType == 2).assertTrue() + }) + + /** + * @tc.number battery_manager_js_2100 + * @tc.name enum_plugged_type_test_wireless + * @tc.desc BatteryPluggedType values Interface Test + */ + it('enum_plugged_type_test_wireless', 0, function () { + var batteryPluggedType = batteryInfo.BatteryPluggedType.WIRELESS; + console.info('batteryPluggedType = ' + batteryPluggedType); + expect(batteryPluggedType == 3).assertTrue() + }) + + /** + * @tc.number battery_manager_js_2200 + * @tc.name brightness_test + * @tc.desc Set Value Interface Test + */ + it('brightness_test', 0, function () { + brightness.setValue(10); + brightness.setValue(0); + brightness.setValue(255); + expect(0 == 0).assertTrue(); + }) + + /** + * @tc.number battery_manager_js_2300 + * @tc.name is_battery_present_test + * @tc.desc Battry Present Interface Test + */ + it('is_battery_present_test', 0, function () { + var isBatteryPresent = batteryInfo.isBatteryPresent; + console.info('isBatteryPresent = ' + isBatteryPresent); + if (isBatteryPresent) { + expect(isBatteryPresent).assertTrue(); + }else{ + expect(isBatteryPresent).assertFalse(); + } + }) +}) \ No newline at end of file diff --git a/powermgr/powermgrbattery_rk3568/src/main/js/default/test/power_manager_running_lock.test.js b/powermgr/powermgrbattery_rk3568/src/main/js/default/test/power_manager_running_lock.test.js new file mode 100755 index 0000000000000000000000000000000000000000..6811e036d51c7efc70a04b7736b84fae35b6c4b0 --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/src/main/js/default/test/power_manager_running_lock.test.js @@ -0,0 +1,213 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * 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. + */ + +import app from '@system.app' +import Context from '@ohos.napi_context' +import runningLock from '@ohos.runningLock'; +import power from '@ohos.power'; +import '@ohos.permission.RUNNING_LOCK' + +import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' + +describe('appInfoTest', function () { + console.log("*************Power Unit Test Begin*************"); + //createRunningLock(name: string, type: RunningLockType): Promise + it('create_running_lock_promise_test', 0, async function (done) { + runningLock.createRunningLock("running_lock_test_1", runningLock.RunningLockType.BACKGROUND) + .then(runninglock => { + expect(runninglock !== null).assertTrue(); + console.info('create_running_lock_promise_test success'); + done(); + }) + .catch(error => { + console.log('create_running_lock_promise_test error: ' + error); + expect().assertFail(); + done(); + }) + }) + //createRunningLock(name: string, type: RunningLockType, callback: AsyncCallback) + it('create_running_lock_callback_test', 0, async function (done) { + runningLock.createRunningLock("running_lock_test_2", runningLock.RunningLockType.BACKGROUND, + (error, runninglock) => { + if (typeof error === "undefined") { + console.info('create_running_lock_callback_test: runningLock is ' + runninglock); + expect(runninglock !== null).assertTrue(); + var used = runninglock.isUsed(); + console.info('create_running_lock_callback_test is used: ' + used); + expect(used).assertFalse(); + runninglock.lock(500); + used = runninglock.isUsed(); + console.info('after lock create_running_lock_callback_test is used: ' + used); + expect(used).assertTrue(); + console.info('create_running_lock_callback_test success'); + done(); + } else { + console.log('create_running_lock_callback_test: ' + error); + expect().assertFail(); + done(); + } + }) + }) + //lock(timeout: number) + it('running_lock_lock_test', 0, async function (done) { + runningLock.createRunningLock("running_lock_test_3", runningLock.RunningLockType.BACKGROUND) + .then(runninglock => { + expect(runninglock !== null).assertTrue(); + var used = runninglock.isUsed(); + console.info('running_lock_lock_test is used: ' + used); + expect(used).assertFalse(); + runninglock.lock(500); + used = runninglock.isUsed(); + console.info('after lock running_lock_lock_test is used: ' + used); + expect(used).assertTrue(); + console.info('running_lock_lock_test success'); + done(); + }) + .catch(error => { + console.log('running_lock_lock_test error: ' + error); + expect().assertFail(); + done(); + }) + }) + //isUsed() + it('running_lock_isused_test', 0, async function (done) { + runningLock.createRunningLock("running_lock_test_4", runningLock.RunningLockType.BACKGROUND) + .then(runninglock => { + expect(runninglock !== null).assertTrue(); + var used = runninglock.isUsed(); + console.info('running_lock_isused_test used: ' + used); + expect(used).assertFalse(); + console.info('running_lock_isused_test success'); + done(); + }) + .catch(error => { + console.log('running_lock_isused_test error: ' + error); + expect().assertFail(); + done(); + }) + }) + //unlock() + it('running_lock_unlock_test', 0, async function (done) { + runningLock.createRunningLock("running_lock_test_5", runningLock.RunningLockType.BACKGROUND) + .then(runninglock => { + expect(runninglock !== null).assertTrue(); + var used = runninglock.isUsed(); + console.info('running_lock_unlock_test is used: ' + used); + expect(used).assertFalse(); + runninglock.lock(500); + used = runninglock.isUsed(); + console.info('after lock running_lock_unlock_test is used: ' + used); + expect(used).assertTrue(); + runninglock.unlock(); + used = runninglock.isUsed(); + console.info('after unlock running_lock_unlock_test is used: ' + used); + expect(used).assertFalse(); + console.info('running_lock_unlock_test success'); + done(); + }) + .catch(error => { + console.log('running_lock_unlock_test error: ' + error); + expect().assertFail(); + done(); + }) + }) + //Runninglock锁的类型为BACKGROUND + it('enum_runningLock_type_background_test', 0, function () { + var runningLockType = runningLock.RunningLockType.BACKGROUND; + console.info('runningLockType = ' + runningLockType); + expect(runningLockType == 1).assertTrue(); + console.info('enum_runningLock_type_background_test success'); + }) + //Runninglock锁的类型为PROXIMITY_SCREEN_CONTROL + it('enum_runningLock_type_proximityscreencontrol_test', 0, function () { + var runningLockType = runningLock.RunningLockType.PROXIMITY_SCREEN_CONTROL; + console.info('runningLockType = ' + runningLockType); + expect(runningLockType == 2).assertTrue(); + console.info('enum_runningLock_type_proximityscreencontrol_test success'); + }) + //isRunningLockTypeSupported(type: RunningLockType): Promise + it('is_runninglock_type_supported_promise_test_1', 0, async function (done) { + runningLock.isRunningLockTypeSupported(runningLock.RunningLockType.PROXIMITY_SCREEN_CONTROL) + .then(supported => { + console.info('is_runninglock_type_supported_test_1 PROXIMITY_SCREEN_CONTROL supported is ' + supported); + expect(supported).assertTrue(); + console.info('is_runninglock_type_supported_test_1 success'); + done(); + }) + .catch(error => { + console.log('is_runninglock_type_supported_test_1 error: ' + error); + expect().assertFail(); + done(); + }) + }) + //isRunningLockTypeSupported(type: RunningLockType) 多余 + it('is_runninglock_type_supported_promise_test_2', 0, async function (done) { + runningLock.isRunningLockTypeSupported(runningLock.RunningLockType.BACKGROUND) + .then(supported => { + console.info('is_runninglock_type_supported_promise_test_2 BACKGROUND supported is ' + supported); + expect(supported).assertTrue(); + console.info('is_runninglock_type_supported_promise_test_2 success'); + done(); + }) + .catch(error => { + console.log('is_runninglock_type_supported_promise_test_2 error: ' + error); + expect().assertFail(); + done(); + }) + }) + //isRunningLockTypeSupported(type: RunningLockType, callback: AsyncCallback) + it('is_runninglock_type_supported_callback_test_3', 0, async function (done) { + runningLock.isRunningLockTypeSupported(runningLock.RunningLockType.BACKGROUND, (error, supported) => { + if (typeof error === "undefined") { + console.info('is_runninglock_type_supported_callback_test_3 BACKGROUND supported is ' + supported); + expect(supported).assertTrue(); + console.info('is_runninglock_type_supported_callback_test_3 success'); + done(); + } else { + console.log('is_runninglock_type_supported_callback_test_3: ' + error); + expect().assertFail(); + done(); + } + }) + }) + it('power_is_screen_on_promise_test', 0, async function (done) {//isScreenOn(): Promise + power.isScreenOn() + .then(screenOn => { + console.info('power_is_screen_on_promise_test screenOn is ' + screenOn); + expect(screenOn).assertTrue(); + console.info('power_is_screen_on_promise_test success'); + done(); + }) + .catch(error => { + console.log('power_is_screen_on_promise_test error: ' + error); + expect().assertFail(); + done(); + }) + }) + it('power_is_screen_on_callback_test', 0, async function (done) {//isScreenOn(callback: AsyncCallback) + power.isScreenOn((error, screenOn) => { + if (typeof error === "undefined") { + console.info('power_is_screen_on_callback_test screenOn is ' + screenOn); + expect(screenOn).assertTrue(); + console.info('power_is_screen_on_callback_test success'); + done(); + } else { + console.log('power_is_screen_on_callback_test: ' + error); + expect().assertFail(); + done(); + } + }) + }) +}) diff --git a/powermgr/powermgrbattery_rk3568/src/main/resources/base/element/string.json b/powermgr/powermgrbattery_rk3568/src/main/resources/base/element/string.json new file mode 100755 index 0000000000000000000000000000000000000000..128f809780629b1f43c9bed19002fd9240021d84 --- /dev/null +++ b/powermgr/powermgrbattery_rk3568/src/main/resources/base/element/string.json @@ -0,0 +1,12 @@ +{ + "string": [ + { + "name": "app_name", + "value": "MyBatteryApp" + }, + { + "name": "mainability_description", + "value": "JS_Phone_Empty Feature Ability" + } + ] +} \ No newline at end of file diff --git a/powermgr/powermgrbattery_rk3568/src/main/resources/base/media/icon.png b/powermgr/powermgrbattery_rk3568/src/main/resources/base/media/icon.png new file mode 100755 index 0000000000000000000000000000000000000000..ce307a8827bd75456441ceb57d530e4c8d45d36c Binary files /dev/null and b/powermgr/powermgrbattery_rk3568/src/main/resources/base/media/icon.png differ