diff --git a/bundle.json b/bundle.json index 56af83c360e4363ef94f882cb48c1a8da7d37fc8..f291e64f5bfa1dd4e3c6e69fd14ff2047792719a 100644 --- a/bundle.json +++ b/bundle.json @@ -87,6 +87,7 @@ "safwk", "samgr", "sensor", + "runtime_core", "device_standby", "window_manager", "miscdevice", @@ -108,6 +109,7 @@ ], "fwk_group": [ "//base/powermgr/power_manager/frameworks:power_napi", + "//base/powermgr/power_manager/frameworks/ets/taihe:power_manager_taihe", "//base/powermgr/power_manager/interfaces/inner_api:powermgr_client" ], "service_group": [ @@ -208,6 +210,9 @@ ], "header_base": "//base/powermgr/power_manager/frameworks/cj/power/include" } + }, + { + "name": "//base/powermgr/power_manager/frameworks/ets/taihe/ability_delegator:copy_power_manager" } ], "test": [ diff --git a/frameworks/ets/taihe/BUILD.gn b/frameworks/ets/taihe/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..e8eda33d1b2c20efb37fc35c592beb13eff1c1b4 --- /dev/null +++ b/frameworks/ets/taihe/BUILD.gn @@ -0,0 +1,6 @@ +group("power_manager_taihe") { + deps = [ + "ability_delegator:power_abc_etc", + "ability_delegator:power_manager_taihe_native", + ] +} \ No newline at end of file diff --git a/frameworks/ets/taihe/ability_delegator/BUILD.gn b/frameworks/ets/taihe/ability_delegator/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..2c15fce8cbc15b3d75d84e06756f5d7699bcdcdb --- /dev/null +++ b/frameworks/ets/taihe/ability_delegator/BUILD.gn @@ -0,0 +1,64 @@ +import("//build/config/components/ets_frontend/ets2abc_config.gni") +import("//build/ohos.gni") +import("//build/ohos/taihe_idl/taihe.gni") +import("../../../../powermgr.gni") + +copy_taihe_idl("copy_power_manager") { + sources = [ "idl/ohos.power.taihe" ] +} + +subsystem_name = "powermgr" +part_name = "power_manager" +taihe_generated_file_path = "$taihe_file_path/out/$subsystem_name/$part_name" + +ohos_taihe("run_taihe") { + taihe_generated_file_path = "$taihe_generated_file_path" + deps = [ ":copy_power_manager" ] + outputs = [ + "$taihe_generated_file_path/src/ohos.power.ani.cpp", + "$taihe_generated_file_path/src/ohos.power.abi.c", + ] +} + +taihe_shared_library("power_manager_taihe_native") { + branch_protector_ret = "pac_ret" + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + taihe_generated_file_path = "$taihe_generated_file_path" + part_name = "$part_name" + subsystem_name = "$subsystem_name" + sources = get_target_outputs(":run_taihe") + include_dirs = [ "./include" ] + configs = [ + "${powermgr_utils_path}:utils_config", + "${powermgr_utils_path}:coverage_flags", + ] + sources += [ + "src/ani_constructor.cpp", + "src/ohos.power.impl.cpp", + ] + deps = [ + ":run_taihe", + "${powermgr_inner_api}:powermgr_client", + "${powermgr_utils_path}/appmgr:power_appmgr", + ] +} + +generate_static_abc("power_abc") { + base_url = "$taihe_generated_file_path" + files = [ "$taihe_generated_file_path/@ohos.power.ets" ] + is_boot_abc = "True" + device_dst_file = "/system/framework/power_abc.abc" + dependencies = [ ":run_taihe" ] +} + +ohos_prebuilt_etc("power_abc_etc") { + source = "$target_out_dir/power_abc.abc" + module_install_dir = "framework" + part_name = "$part_name" + subsystem_name = "$subsystem_name" + deps = [ ":power_abc" ] +} \ No newline at end of file diff --git a/frameworks/ets/taihe/ability_delegator/idl/ohos.power.taihe b/frameworks/ets/taihe/ability_delegator/idl/ohos.power.taihe new file mode 100644 index 0000000000000000000000000000000000000000..633734753b675edbb2cc56510d6fd02d919be3bc --- /dev/null +++ b/frameworks/ets/taihe/ability_delegator/idl/ohos.power.taihe @@ -0,0 +1,30 @@ +@!namespace("@ohos.power", "power") + +function shutdown(reason: String): void; + +function reboot(reason: String): void; + +function isActive(): bool; + +function wakeup(detail: String): void; + +function suspend(isImmediate: Optional): void; + +function getPowerMode(): DevicePowerMode; + +@gen_async("setPowerMode") +@gen_promise("setPowerMode") +function setPowerModeSync(mode: DevicePowerMode): void; + +function isStandby(): bool; + +function hibernate(clearMemory: bool): void; + +function setScreenOffTime(timeout: i64): void; + +enum DevicePowerMode : i32 { + MODE_NORMAL = 600, + MODE_POWER_SAVE, + MODE_PERFORMANCE, + MODE_EXTREME_POWER_SAVE +} \ No newline at end of file diff --git a/frameworks/ets/taihe/ability_delegator/src/ani_constructor.cpp b/frameworks/ets/taihe/ability_delegator/src/ani_constructor.cpp new file mode 100644 index 0000000000000000000000000000000000000000..edc4d9d57f47d1bc614da20484db1b94d491701d --- /dev/null +++ b/frameworks/ets/taihe/ability_delegator/src/ani_constructor.cpp @@ -0,0 +1,15 @@ +#include "power.ani.hpp" +#include "hello_ani.ani.hpp" +#include "batteryInfo.ani.hpp" +ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result) { + ani_env *env; + if (ANI_OK != vm->GetEnv(ANI_VERSION_1, &env)) { + return ANI_ERROR; + } + if (ANI_OK != power::ANIRegister(env)) { + std::cerr << "Error from power::ANIRegister" << std::endl; + return ANI_ERROR; + } + *result = ANI_VERSION_1; + return ANI_OK; +} diff --git a/frameworks/ets/taihe/ability_delegator/src/ohos.power.impl.cpp b/frameworks/ets/taihe/ability_delegator/src/ohos.power.impl.cpp new file mode 100644 index 0000000000000000000000000000000000000000..329e2548aeb46bbbd1e1ddb7d4fb94c1dfccf15a --- /dev/null +++ b/frameworks/ets/taihe/ability_delegator/src/ohos.power.impl.cpp @@ -0,0 +1,158 @@ +#include "power.proj.hpp" +#include "power.impl.hpp" +#include "taihe/runtime.hpp" +#include "stdexcept" +#include "power_common.h" +#include "power_log.h" +#include "power_mgr_client.h" +#include +#include +#include +#include "app_manager_utils.h" + +#define SET_REBOOT _IOW(BOOT_DETECTOR_IOCTL_BASE, 109, int) + +using namespace taihe; +using namespace power; +using namespace OHOS::PowerMgr; + +namespace { +std::map errorTable = { + {PowerErrors::ERR_CONNECTION_FAIL, "Failed to connect to the service."}, + {PowerErrors::ERR_PERMISSION_DENIED, "Permission is denied" }, + {PowerErrors::ERR_SYSTEM_API_DENIED, "System permission is denied" }, + {PowerErrors::ERR_PARAM_INVALID, "Invalid input parameter." } +}; +static PowerMgrClient& g_powerMgrClient = PowerMgrClient::GetInstance(); + +static void SetFrameworkBootStage(bool isReboot) +{ + int fd = open("/dev/bbox", O_WRONLY); + if (fd < 0) { + POWER_HILOGE(FEATURE_SHUTDOWN, "open /dev/bbox failed!"); + return; + } + int rebootFlag = isReboot ? 1 : 0; + int ret = ioctl(fd, SET_REBOOT, &rebootFlag); + if (ret < 0) { + POWER_HILOGE(FEATURE_SHUTDOWN, "set reboot flag failed!"); + close(fd); + return; + } + int stage = SHUT_STAGE_FRAMEWORK_START; + ret = ioctl(fd, SET_SHUT_STAGE, &stage); + if (ret < 0) { + POWER_HILOGE(FEATURE_SHUTDOWN, "set shut stage failed!"); + } + close(fd); + return; +} + +void shutdown(string_view reason) { + SetFrameworkBootStage(false); + POWER_HILOGD(FEATURE_SHUTDOWN, "reboot: %{public}d, reason: %{public}s", false, reason.c_str()); + PowerErrors code = g_powerMgrClient.ShutDownDevice(std::string(reason)); + if (code != PowerErrors::ERR_OK) { + taihe::set_business_error(static_cast(code), errorTable[code]); + } +} + +void reboot(string_view reason) { + SetFrameworkBootStage(true); + POWER_HILOGD(FEATURE_SHUTDOWN, "reboot: %{public}d, reason: %{public}s", true, reason.c_str()); + PowerErrors code = g_powerMgrClient.RebootDevice(std::string(reason)); + if (code != PowerErrors::ERR_OK) { + taihe::set_business_error(static_cast(code), errorTable[code]); + } +} + +bool isActive() { + return g_powerMgrClient.IsScreenOn(); +} + +void wakeup(string_view detail) { + POWER_HILOGD(FEATURE_WAKEUP, "Wakeup type: APPLICATION, reason: %{public}s", detail.c_str()); + int32_t apiVersion = AppManagerUtils::GetApiTargetVersion(); + PowerErrors code = g_powerMgrClient.WakeupDevice( + WakeupDeviceType::WAKEUP_DEVICE_APPLICATION, std::string(detail), std::to_string(apiVersion)); + if (code != PowerErrors::ERR_OK) { + taihe::set_business_error(static_cast(code), errorTable[code]); + } +} + +void suspend(optional_view isImmediate) { + bool isForce = isImmediate.value_or(false); + + PowerErrors code; + int32_t apiVersion = AppManagerUtils::GetApiTargetVersion(); + if (isForce) { + code = g_powerMgrClient.ForceSuspendDevice(std::to_string(apiVersion)); + } else { + code = g_powerMgrClient.SuspendDevice( + SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false, std::to_string(apiVersion)); + } + if (code != PowerErrors::ERR_OK) { + POWER_HILOGE(FEATURE_SUSPEND, "Suspend Device fail, isForce:%{public}d", isForce); + taihe::set_business_error(static_cast(code), errorTable[code]); + } +} + +DevicePowerMode getPowerMode() { + PowerMode mode = g_powerMgrClient.GetDeviceMode(); + return DevicePowerMode(static_cast(mode)); +} + +void setPowerModeSync(DevicePowerMode mode) { + g_powerMgrClient.SetDeviceMode(PowerMode(static_cast(mode))); +} + +bool isStandby() { + bool isStandby = false; + PowerErrors code = g_powerMgrClient.IsStandby(isStandby); + if (code == PowerErrors::ERR_OK) { + return isStandby; + } + taihe::set_business_error(static_cast(code), errorTable[code]); + return isStandby; +} + +void hibernate(bool clearMemory) { + int32_t apiVersion = AppManagerUtils::GetApiTargetVersion(); + PowerErrors code = g_powerMgrClient.Hibernate(clearMemory, std::to_string(apiVersion)); + if (code != PowerErrors::ERR_OK) { + POWER_HILOGE(FEATURE_WAKEUP, "Hibernate failed."); + taihe::set_business_error(static_cast(code), errorTable[code]); + } +} + +void setScreenOffTime(int32_t timeout) { + if (timeout == 0 || (timeout < 0 && timeout != RESTORE_DEFAULT_SCREENOFF_TIME)) { + POWER_HILOGE(FEATURE_WAKEUP, "timeout is not right."); + taihe::set_business_error( + static_cast(PowerErrors::ERR_PARAM_INVALID), errorTable[PowerErrors::ERR_PARAM_INVALID]); + } + + PowerErrors code; + int32_t apiVersion = AppManagerUtils::GetApiTargetVersion(); + if (timeout == RESTORE_DEFAULT_SCREENOFF_TIME) { + code = g_powerMgrClient.RestoreScreenOffTime(std::to_string(apiVersion)); + } else { + code = g_powerMgrClient.OverrideScreenOffTime(timeout, std::to_string(apiVersion)); + } + if (code != PowerErrors::ERR_OK) { + POWER_HILOGE(FEATURE_WAKEUP, "SetScreenOffTime failed."); + taihe::set_business_error(static_cast(code), errorTable[code]); + } +} +} // namespace + +TH_EXPORT_CPP_API_shutdown(shutdown); +TH_EXPORT_CPP_API_reboot(reboot); +TH_EXPORT_CPP_API_isActive(isActive); +TH_EXPORT_CPP_API_wakeup(wakeup); +TH_EXPORT_CPP_API_suspend(suspend); +TH_EXPORT_CPP_API_getPowerMode(getPowerMode); +TH_EXPORT_CPP_API_setPowerModeSync(setPowerModeSync); +TH_EXPORT_CPP_API_isStandby(isStandby); +TH_EXPORT_CPP_API_hibernate(hibernate); +TH_EXPORT_CPP_API_setScreenOffTime(setScreenOffTime);