From b97e6c3d9bba0ee244b58d947dfafee87b548617 Mon Sep 17 00:00:00 2001 From: travislgd Date: Mon, 1 Sep 2025 17:34:55 +0800 Subject: [PATCH] dms qiangji sanjieduan 0702 Signed-off-by: travislgd --- interfaces/kits/ani/display_runtime/BUILD.gn | 3 + .../display_ani/ets/@ohos.display.ets | 115 +++++++++ .../display_ani/include/display_ani.h | 1 + .../display_ani/include/display_ani_manager.h | 16 ++ .../display_ani/include/display_ani_utils.h | 7 + .../display_ani/src/display_ani.cpp | 43 ++++ .../display_ani/src/display_ani_manager.cpp | 228 ++++++++++++++++++ .../display_ani/src/display_ani_utils.cpp | 70 ++++++ .../screenshot_ani/ets/@ohos.screenshot.ets | 51 +++- .../include/screenshot_ani_manager.h | 7 +- .../include/screenshot_ani_utils.h | 7 + .../src/screenshot_ani_manager.cpp | 109 ++++++++- .../src/screenshot_ani_utils.cpp | 62 +++++ 13 files changed, 707 insertions(+), 12 deletions(-) diff --git a/interfaces/kits/ani/display_runtime/BUILD.gn b/interfaces/kits/ani/display_runtime/BUILD.gn index b1f7cc3344..d0029f40ed 100644 --- a/interfaces/kits/ani/display_runtime/BUILD.gn +++ b/interfaces/kits/ani/display_runtime/BUILD.gn @@ -76,6 +76,9 @@ ohos_shared_library("displayani_kit") { "runtime_core:ani", "napi:ace_napi", "runtime_core:ani_helpers", + "graphic_2d:librender_service_client", + "graphic_2d:librender_service_base", + "graphic_surface:surface" ] innerapi_tags = [ "platformsdk" ] diff --git a/interfaces/kits/ani/display_runtime/display_ani/ets/@ohos.display.ets b/interfaces/kits/ani/display_runtime/display_ani/ets/@ohos.display.ets index 9326760ee1..ebe1c219c4 100644 --- a/interfaces/kits/ani/display_runtime/display_ani/ets/@ohos.display.ets +++ b/interfaces/kits/ani/display_runtime/display_ani/ets/@ohos.display.ets @@ -109,6 +109,30 @@ export class FoldCreaseRegionImpl implements FoldCreaseRegion { readonly creaseRects: Array; } +export interface VirtualScreenConfig { + name: string; + + width: long; + + height: long; + + density: double; + + surfaceId: string; +} + +export class VirtualScreenConfigImpl implements VirtualScreenConfig { + name: string; + + width: long; + + height: long; + + density: double; + + surfaceId: string; +} + export enum FoldDisplayMode { FOLD_DISPLAY_MODE_UNKNOWN = 0, @@ -249,6 +273,8 @@ export interface Display { on(type: string, callback: Callback): void; off(type: string, callback?: Callback): void; + + getDisplayCapability(): string; } export class DisplayImpl implements Display { @@ -384,6 +410,11 @@ export class DisplayImpl implements Display { this.syncOff(type, callback); } + getDisplayCapability(): string { + let displayCapability: string = this.getDisplayCapabilityInternal(); + return displayCapability; + } + static transferStatic(input: Any): Object { let display = new DisplayImpl(); let display_input: ESValue = ESValue.wrap(input); @@ -405,6 +436,7 @@ export class DisplayImpl implements Display { native syncOff(type: string, callback?: object): void; native getAvailableAreaInternal(rect: Rect): void; native getCutoutInfoInternal(cutoutInfo: CutoutInfo): void; + native getDisplayCapabilityInternal(): string; native hasImmersiveWindowInternal(): boolean; native static nativeTransferStatic(input: ESValue, display: Object): boolean; @@ -432,6 +464,17 @@ export function getFoldDisplayMode(): FoldDisplayMode { export native function getFoldDisplayModeNative(): int; +export function setFoldDisplayMode(mode: FoldDisplayMode, reason: string): void { + setFoldDisplayModeReasonNative(mode as int, reason, displayMgrRef); +} + +export function setFoldDisplayMode(mode: FoldDisplayMode): void { + setFoldDisplayModeNative(mode as int, displayMgrRef); +} + +export native function setFoldDisplayModeReasonNative(mode: int, reason: string, nativeObj: long): void; +export native function setFoldDisplayModeNative(mode: int, nativeObj: long): void; + export function getFoldStatus(): FoldStatus{ let res = getFoldStatusNative(); return res as FoldStatus; @@ -461,6 +504,14 @@ function minusCreaseRects(foldCreaseRegionObj: FoldCreaseRegion): void { export native function getCurrentFoldCreaseRegionNative(foldCreaseRegion: object, nativeObj: long): void; +export function getPrimaryDisplaySync(): Display { + let display = new DisplayImpl(); + getPrimaryDisplaySyncNative(display as object); + return display; +} + +export native function getPrimaryDisplaySyncNative(obj: object): void; + // display sync interfaces export function getDisplayByIdSync(displayId: long): Display { let display = new DisplayImpl(); @@ -621,6 +672,70 @@ export class DisplayPhysicalResolutionImpl implements DisplayPhysicalResolution{ physicalHeight: long; } +export function makeUnique(screenId: long): Promise { + return new Promise((resolve: (value: undefined) => void, reject: (error: BusinessError) => void ) :void => { + taskpool.execute((): void => { + makeUniqueNative(screenId, displayMgrRef); + }).then((ret: NullishType) :void => { + resolve(undefined); + }).catch((err: NullishType) :void => { + reject(err as BusinessError); + }); + }); +} + +export native function makeUniqueNative(screenId: long, nativeObj: long): void; + +export function setFoldStatusLocked(locked: boolean): void { + setFoldStatusLockedNative(locked, displayMgrRef); +} + +export native function setFoldStatusLockedNative(locked: boolean, nativeObj: long):void; + +export function createVirtualScreen(config: VirtualScreenConfig): Promise { + return new Promise((resolve: (value: long) => void, reject: (error: BusinessError) => void ) :void => { + taskpool.execute((): long => { + let screenId: long; + screenId = createVirtualScreenNative(config as object, displayMgrRef); + return screenId; + }).then((ret: NullishType) :void => { + resolve(ret as long); + }).catch((err: NullishType) :void => { + reject(err as BusinessError); + }); + }); +} + +export native function createVirtualScreenNative(config: object, nativeObj: long): long; + +export function destroyVirtualScreen(screenId: long): Promise { + return new Promise((resolve: (value: undefined) => void, reject: (error: BusinessError) => void ) :void => { + taskpool.execute((): void => { + destroyVirtualScreenNative(screenId, displayMgrRef); + }).then((ret: NullishType) :void => { + resolve(undefined); + }).catch((err: NullishType) :void => { + reject(err as BusinessError); + }); + }); +} + +export native function destroyVirtualScreenNative(screenId: long, nativeObj: long): void; + +export function setVirtualScreenSurface(screenId: long, surfaceId: string): Promise { + return new Promise((resolve: (value: undefined) => void, reject: (error: BusinessError) => void ) :void => { + taskpool.execute((): void => { + setVirtualScreenSurfaceNative(screenId, surfaceId, displayMgrRef); + }).then((ret: NullishType) :void => { + resolve(undefined); + }).catch((err: NullishType) :void => { + reject(err as BusinessError); + }); + }); +} + +export native function setVirtualScreenSurfaceNative(screenId: long, surfaceId: string, nativeObj: long): void; + export function disposeDisplay(display: DisplayImpl): void { finalizerDisplayNative(display as object, displayMgrRef); } diff --git a/interfaces/kits/ani/display_runtime/display_ani/include/display_ani.h b/interfaces/kits/ani/display_runtime/display_ani/include/display_ani.h index d12fe8187b..8a15d0d439 100644 --- a/interfaces/kits/ani/display_runtime/display_ani/include/display_ani.h +++ b/interfaces/kits/ani/display_runtime/display_ani/include/display_ani.h @@ -27,6 +27,7 @@ public: explicit DisplayAni(const sptr& display); static void GetCutoutInfo(ani_env* env, ani_object obj, ani_object cutoutInfoObj); + static ani_string GetDisplayCapability(ani_env* env); static void GetAvailableArea(ani_env* env, ani_object obj, ani_object availableAreaObj); static ani_boolean HasImmersiveWindow(ani_env* env, ani_object obj); static void RegisterCallback(ani_env* env, ani_object obj, ani_string type, ani_ref aniCallback); diff --git a/interfaces/kits/ani/display_runtime/display_ani/include/display_ani_manager.h b/interfaces/kits/ani/display_runtime/display_ani/include/display_ani_manager.h index d1d1e7ed8c..320f94db4b 100644 --- a/interfaces/kits/ani/display_runtime/display_ani/include/display_ani_manager.h +++ b/interfaces/kits/ani/display_runtime/display_ani/include/display_ani_manager.h @@ -27,13 +27,17 @@ public: explicit DisplayManagerAni(); static ani_status InitDisplayManagerAni(ani_namespace displayNameSpace, ani_env* env); + static void SetFoldDisplayModeReasonAni(ani_env* env, ani_int mode, ani_string reason, ani_long nativeObj); + static void SetFoldDisplayModeAni(ani_env* env, ani_int mode, ani_long nativeObj); static ani_int GetFoldDisplayModeAni(ani_env* env); + static void SetFoldStatusLockedAni(ani_env* env, ani_boolean locked, ani_long nativeObj); static ani_boolean IsFoldableAni(ani_env* env); static ani_int GetFoldStatus(ani_env* env); static ani_boolean IsCaptured(ani_env* env); static void GetCurrentFoldCreaseRegion(ani_env* env, ani_object obj, ani_long nativeObj); static void GetAllDisplaysAni(ani_env* env, ani_object arrayObj); + static void GetPrimaryDisplaySyncAni(ani_env* env, ani_object obj); static void GetDisplayByIdSyncAni(ani_env* env, ani_object obj, ani_long displayId); static void GetDefaultDisplaySyncAni(ani_env* env, ani_object obj); @@ -47,12 +51,24 @@ public: sptr displayAniListener); static ani_boolean HasPrivateWindow(ani_env* env, ani_long displayId); static void GetAllDisplayPhysicalResolution(ani_env* env, ani_object arrayObj, ani_long nativeObj); + static void CreateVirtualScreen(ani_env* env, + ani_object virtualScreenConfig, ani_long screenId, ani_long nativeObj); + static void DestroyVirtualScreen(ani_env* env, ani_long screenId, ani_long nativeObj); + static void SetVirtualScreenSurface(ani_env* env, ani_long screenId, ani_string surfaceId, ani_long nativeObj); + static void MakeUnique(ani_env* env, ani_long screenId, ani_long nativeObj); static void FinalizerDisplay(ani_env* env, ani_object displayObj, ani_long nativeObj); private: void OnRegisterCallback(ani_env* env, ani_string type, ani_ref callback); void OnUnRegisterCallback(ani_env* env, ani_string type, ani_ref callback); + void OnSetFoldDisplayModeReasonAni(ani_env* env, ani_int mode, ani_string reason); + void OnSetFoldDisplayModeAni(ani_env* env, ani_int mode); void OnGetCurrentFoldCreaseRegion(ani_env* env, ani_object obj); void OnGetAllDisplayPhysicalResolution(ani_env* env, ani_object arrayObj); + void OnSetFoldStatusLockedAni(ani_env* env, ani_boolean locked); + ani_long OnCreateVirtualScreen(ani_env* env, ani_object virtualScreenConfig); + void OnDestroyVirtualScreen(ani_env* env, ani_long screenId); + void OnSetVirtualScreenSurface(ani_env* env, ani_long screenId, ani_string surfaceId); + void OnMakeUnique(ani_env* env, ani_long screenId); void OnFinalizerDisplay(ani_env* env, ani_object displayObj); bool IsCallbackRegistered(ani_env* env, const std::string& type, ani_ref callback); std::mutex mtx_; diff --git a/interfaces/kits/ani/display_runtime/display_ani/include/display_ani_utils.h b/interfaces/kits/ani/display_runtime/display_ani/include/display_ani_utils.h index 8a0c767488..185e6d3220 100644 --- a/interfaces/kits/ani/display_runtime/display_ani/include/display_ani_utils.h +++ b/interfaces/kits/ani/display_runtime/display_ani/include/display_ani_utils.h @@ -24,6 +24,8 @@ #include "refbase.h" #include "singleton_container.h" #include "window_manager_hilog.h" +#include "surface_utils.h" +#include "screen_manager.h" namespace OHOS { namespace Rosen { @@ -56,6 +58,11 @@ static void CreateAniArrayDouble(ani_env* env, ani_size size, ani_array_double * static ani_status GetAniString(ani_env* env, const std::string& str, ani_string* result); +static DmErrorCode GetVirtualScreenOptionFromAni( + ani_env* env, ani_object virtualScreenConfigObj, VirtualScreenOption& option); + +static bool GetSurfaceFromAni(ani_env* env, ani_string surfaceIdAniValue, sptr& surface); + static ani_status CallAniFunctionVoid(ani_env* env, const char* ns, const char* fn, const char* signature, ...); diff --git a/interfaces/kits/ani/display_runtime/display_ani/src/display_ani.cpp b/interfaces/kits/ani/display_runtime/display_ani/src/display_ani.cpp index 7f3d4313ba..7377735c04 100644 --- a/interfaces/kits/ani/display_runtime/display_ani/src/display_ani.cpp +++ b/interfaces/kits/ani/display_runtime/display_ani/src/display_ani.cpp @@ -77,6 +77,31 @@ void DisplayAni::GetCutoutInfo(ani_env* env, ani_object obj, ani_object cutoutIn DisplayAniUtils::ConvertWaterArea(waterfallDisplayAreaRects, static_cast(waterfallObj), env); } +ani_string DisplayAni::GetDisplayCapability(ani_env* env) +{ + TLOGI(WmsLogTag::DMS, "[ANI] Start"); + if (env == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] env is nullptr"); + return nullptr; + } + auto display = SingletonContainer::Get().GetDefaultDisplay(); + std::string capabilitInfo; + DmErrorCode ret = DM_JS_TO_ERROR_CODE_MAP.at(display->GetDisplayCapability(capabilitInfo)); + if (ret != DmErrorCode::DM_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] Display get capability failed."); + AniErrUtils::ThrowBusinessError(env, ret, "GetDisplayCapability failed."); + return nullptr; + } + TLOGI(WmsLogTag::DMS, "[ANI] GetDisplayCapability = %{public}s", capabilitInfo.c_str()); + ani_string capabilitInfoAni; + ani_status status = DisplayAniUtils::GetAniString(env, capabilitInfo, &capabilitInfoAni); + if (status != ANI_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] GetAniString failed, ani_status = %{public}d", status); + return nullptr; + } + return capabilitInfoAni; +} + void DisplayAni::GetAvailableArea(ani_env* env, ani_object obj, ani_object availableAreaObj) { TLOGI(WmsLogTag::DMS, "[ANI] begin"); @@ -388,11 +413,19 @@ ani_status DisplayAni::NspBindNativeFunctions(ani_env* env, ani_namespace nsp) { std::array funcs = { ani_native_function {"isFoldable", ":z", reinterpret_cast(DisplayManagerAni::IsFoldableAni)}, + ani_native_function {"setFoldDisplayModeReasonNative", nullptr, + reinterpret_cast(DisplayManagerAni::SetFoldDisplayModeReasonAni)}, + ani_native_function {"setFoldDisplayModeNative", nullptr, + reinterpret_cast(DisplayManagerAni::SetFoldDisplayModeAni)}, ani_native_function {"getFoldDisplayModeNative", ":i", reinterpret_cast(DisplayManagerAni::GetFoldDisplayModeAni)}, + ani_native_function {"setFoldStatusLockedNative", nullptr, + reinterpret_cast(DisplayManagerAni::SetFoldStatusLockedAni)}, ani_native_function {"getFoldStatusNative", ":i", reinterpret_cast(DisplayManagerAni::GetFoldStatus)}, ani_native_function {"getCurrentFoldCreaseRegionNative", "C{std.core.Object}l:", reinterpret_cast(DisplayManagerAni::GetCurrentFoldCreaseRegion)}, + ani_native_function {"getPrimaryDisplaySyncNative", "C{std.core.Object}:", + reinterpret_cast(DisplayManagerAni::GetPrimaryDisplaySyncAni)}, ani_native_function {"getDisplayByIdSyncNative", "C{std.core.Object}l:", reinterpret_cast(DisplayManagerAni::GetDisplayByIdSyncAni)}, ani_native_function {"getDefaultDisplaySyncNative", "C{std.core.Object}:", @@ -407,6 +440,14 @@ ani_status DisplayAni::NspBindNativeFunctions(ani_env* env, ani_namespace nsp) reinterpret_cast(DisplayManagerAni::HasPrivateWindow)}, ani_native_function {"getAllDisplayPhysicalResolutionNative", nullptr, reinterpret_cast(DisplayManagerAni::GetAllDisplayPhysicalResolution)}, + ani_native_function {"createVirtualScreenNative", nullptr, + reinterpret_cast(DisplayManagerAni::CreateVirtualScreen)}, + ani_native_function {"destroyVirtualScreenNative", nullptr, + reinterpret_cast(DisplayManagerAni::DestroyVirtualScreen)}, + ani_native_function {"setVirtualScreenSurfaceNative", nullptr, + reinterpret_cast(DisplayManagerAni::SetVirtualScreenSurface)}, + ani_native_function {"makeUniqueNative", nullptr, + reinterpret_cast(DisplayManagerAni::MakeUnique)}, ani_native_function {"isCaptured", nullptr, reinterpret_cast(DisplayManagerAni::IsCaptured)}, ani_native_function {"finalizerDisplayNative", nullptr, reinterpret_cast(DisplayManagerAni::FinalizerDisplay)}, @@ -424,6 +465,8 @@ ani_status DisplayAni::ClassBindNativeFunctions(ani_env* env, ani_class displayC std::array methods = { ani_native_function {"getCutoutInfoInternal", "C{@ohos.display.display.CutoutInfo}:", reinterpret_cast(DisplayAni::GetCutoutInfo)}, + ani_native_function {"getDisplayCapabilityInternal", nullptr, + reinterpret_cast(DisplayAni::GetDisplayCapability)}, ani_native_function {"getAvailableAreaInternal", "C{@ohos.display.display.Rect}:", reinterpret_cast(DisplayAni::GetAvailableArea)}, ani_native_function {"hasImmersiveWindowInternal", ":z", diff --git a/interfaces/kits/ani/display_runtime/display_ani/src/display_ani_manager.cpp b/interfaces/kits/ani/display_runtime/display_ani/src/display_ani_manager.cpp index 27c3a99778..9736f4322d 100644 --- a/interfaces/kits/ani/display_runtime/display_ani/src/display_ani_manager.cpp +++ b/interfaces/kits/ani/display_runtime/display_ani/src/display_ani_manager.cpp @@ -56,6 +56,80 @@ ani_status DisplayManagerAni::InitDisplayManagerAni(ani_namespace displayNameSpa return ret; } +void DisplayManagerAni::SetFoldDisplayModeReasonAni(ani_env* env, ani_int mode, ani_string reason, ani_long nativeObj) +{ + TLOGI(WmsLogTag::DMS, "[ANI]"); + if (env == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] env is nullptr"); + return; + } + DisplayManagerAni* displayManagerAni = reinterpret_cast(nativeObj); + if (displayManagerAni != nullptr) { + displayManagerAni->OnSetFoldDisplayModeReasonAni(env, mode, reason); + } else { + TLOGI(WmsLogTag::DMS, "[ANI] null ptr"); + } +} + +void DisplayManagerAni::OnSetFoldDisplayModeReasonAni(ani_env* env, ani_int mode, ani_string reason) +{ + TLOGI(WmsLogTag::DMS, "[ANI]"); + std::string reasonStr; + DisplayAniUtils::GetStdString(env, reason, reasonStr); + DmErrorCode errCode = DM_JS_TO_ERROR_CODE_MAP.at( + SingletonContainer::Get().SetFoldDisplayModeFromJs( + static_cast(mode), reasonStr)); + if (errCode != DmErrorCode::DM_OK) { + AniErrUtils::ThrowBusinessError(env, errCode, "SetFoldDisplayModeAni failed"); + } +} + +void DisplayManagerAni::SetFoldDisplayModeAni(ani_env* env, ani_int mode, ani_long nativeObj) +{ + TLOGI(WmsLogTag::DMS, "[ANI]"); + if (env == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] env is nullptr"); + return; + } + DisplayManagerAni* displayManagerAni = reinterpret_cast(nativeObj); + if (displayManagerAni != nullptr) { + displayManagerAni->OnSetFoldDisplayModeAni(env, mode); + } else { + TLOGI(WmsLogTag::DMS, "[ANI] null ptr"); + } +} + +void DisplayManagerAni::OnSetFoldDisplayModeAni(ani_env* env, ani_int mode) +{ + TLOGI(WmsLogTag::DMS, "[ANI] mode: %{public}d", static_cast(mode)); + SingletonContainer::Get().SetFoldDisplayMode(static_cast(mode)); +} + +void DisplayManagerAni::SetFoldStatusLockedAni(ani_env* env, ani_boolean locked, ani_long nativeObj) +{ + TLOGI(WmsLogTag::DMS, "[ANI]"); + if (env == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] env is nullptr"); + return; + } + DisplayManagerAni* displayManagerAni = reinterpret_cast(nativeObj); + if (displayManagerAni != nullptr) { + displayManagerAni->OnSetFoldStatusLockedAni(env, locked); + } else { + TLOGI(WmsLogTag::DMS, "[ANI] null ptr"); + } +} + +void DisplayManagerAni::OnSetFoldStatusLockedAni(ani_env* env, ani_boolean locked) +{ + TLOGI(WmsLogTag::DMS, "[ANI] locked: %{public}d", static_cast(locked)); + DmErrorCode errCode = DM_JS_TO_ERROR_CODE_MAP.at( + SingletonContainer::Get().SetFoldStatusLockedFromJs(static_cast(locked))); + if (errCode != DmErrorCode::DM_OK) { + AniErrUtils::ThrowBusinessError(env, errCode, "SetFoldDisplayModeAni failed"); + } +} + ani_int DisplayManagerAni::GetFoldDisplayModeAni(ani_env* env) { auto mode = SingletonContainer::Get().GetFoldDisplayMode(); @@ -156,6 +230,23 @@ void DisplayManagerAni::GetAllDisplaysAni(ani_env* env, ani_object arrayObj) TLOGI(WmsLogTag::DMS, "[ANI] GetAllDisplaysAni end"); } +void DisplayManagerAni::GetPrimaryDisplaySyncAni(ani_env* env, ani_object obj) +{ + TLOGI(WmsLogTag::DMS, "[ANI] begin"); + if (env == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] env is nullptr"); + return; + } + sptr display = SingletonContainer::Get().GetPrimaryDisplaySync(); + if (display == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] Display null"); + AniErrUtils::ThrowBusinessError(env, DmErrorCode::DM_ERROR_SYSTEM_INNORMAL, ""); + return; + } + DisplayAniUtils::CvtDisplay(display, env, obj); + DisplayAni::CreateDisplayAni(display, static_cast(obj), env); +} + void DisplayManagerAni::GetDisplayByIdSyncAni(ani_env* env, ani_object obj, ani_long displayId) { TLOGI(WmsLogTag::DMS, "[ANI] begin"); @@ -464,6 +555,143 @@ void DisplayManagerAni::OnGetAllDisplayPhysicalResolution(ani_env* env, ani_obje } } +void DisplayManagerAni::CreateVirtualScreen(ani_env* env, + ani_object virtualScreenConfig, ani_long screenId, ani_long nativeObj) +{ + TLOGI(WmsLogTag::DMS, "[ANI] begin"); + if (env == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] env is nullptr"); + return; + } + DisplayManagerAni* displayManagerAni = reinterpret_cast(nativeObj); + displayManagerAni->OnCreateVirtualScreen(env, virtualScreenConfig); +} + +ani_long DisplayManagerAni::OnCreateVirtualScreen(ani_env* env, ani_object virtualScreenConfig) +{ + ScreenId screenId = SCREEN_ID_INVALID; + TLOGI(WmsLogTag::DMS, "[ANI] begin"); + if (virtualScreenConfig == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] Invalid param"); + AniErrUtils::ThrowBusinessError(env, DmErrorCode::DM_ERROR_ILLEGAL_PARAM, "Invalid param"); + return static_cast(screenId); + } + VirtualScreenOption option; + DmErrorCode errCode = DisplayAniUtils::GetVirtualScreenOptionFromAni(env, virtualScreenConfig, option); + if (errCode == DmErrorCode::DM_ERROR_INVALID_PARAM) { + TLOGE(WmsLogTag::DMS, "[ANI] Get virtual screen option from ani failed"); + AniErrUtils::ThrowBusinessError(env, errCode, "Get virtual screen option from ani failed."); + return static_cast(screenId); + } + screenId = SingletonContainer::Get().CreateVirtualScreen(option); + auto screen = SingletonContainer::Get().GetScreenById(screenId); + if (screen == nullptr) { + DmErrorCode ret = DmErrorCode::DM_ERROR_INVALID_SCREEN; + if (screenId == ERROR_ID_NOT_SYSTEM_APP) { + ret = DmErrorCode::DM_ERROR_NO_PERMISSION; + } + AniErrUtils::ThrowBusinessError(env, ret, "Get screen by id failed."); + return static_cast(screenId); + } + return static_cast(screenId); +} + +void DisplayManagerAni::DestroyVirtualScreen(ani_env* env, ani_long screenId, ani_long nativeObj) +{ + TLOGI(WmsLogTag::DMS, "[ANI] begin"); + if (env == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] env is nullptr"); + return; + } + DisplayManagerAni* displayManagerAni = reinterpret_cast(nativeObj); + displayManagerAni->OnDestroyVirtualScreen(env, screenId); +} + +void DisplayManagerAni::OnDestroyVirtualScreen(ani_env* env, ani_long screenId) +{ + TLOGI(WmsLogTag::DMS, "[ANI] begin"); + if (static_cast(screenId) < 0) { + TLOGE(WmsLogTag::DMS, "[ANI] screenId is invalid: %{public}d", static_cast(screenId)); + AniErrUtils::ThrowBusinessError(env, DmErrorCode::DM_ERROR_ILLEGAL_PARAM, "Invalid screenId"); + return; + } + auto ret = DM_JS_TO_ERROR_CODE_MAP.at( + SingletonContainer::Get().DestroyVirtualScreen(static_cast(screenId))); + ret = (ret == DmErrorCode::DM_ERROR_NOT_SYSTEM_APP) ? DmErrorCode::DM_ERROR_NO_PERMISSION : ret; + if (ret != DmErrorCode::DM_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] Destroy virtual screen failed."); + AniErrUtils::ThrowBusinessError(env, ret, "Destroy virtual screen failed."); + } +} + +void DisplayManagerAni::SetVirtualScreenSurface( + ani_env* env, ani_long screenId, ani_string surfaceId, ani_long nativeObj) +{ + TLOGI(WmsLogTag::DMS, "[ANI] begin"); + if (env == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] env is nullptr"); + return; + } + DisplayManagerAni* displayManagerAni = reinterpret_cast(nativeObj); + displayManagerAni->OnSetVirtualScreenSurface(env, screenId, surfaceId); +} + +void DisplayManagerAni::OnSetVirtualScreenSurface(ani_env* env, ani_long screenId, ani_string surfaceId) +{ + TLOGI(WmsLogTag::DMS, "[ANI] begin"); + if (static_cast(screenId) < 0 || surfaceId == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] Invalid param"); + AniErrUtils::ThrowBusinessError(env, DmErrorCode::DM_ERROR_ILLEGAL_PARAM, "Invalid param"); + return; + } + std::vector screenIds; + screenIds.emplace_back(static_cast(screenId)); + sptr surface; + if (!DisplayAniUtils::GetSurfaceFromAni(env, surfaceId, surface)) { + TLOGE(WmsLogTag::DMS, "[ANI] Failed to convert surface."); + AniErrUtils::ThrowBusinessError(env, DmErrorCode::DM_ERROR_ILLEGAL_PARAM, "Failed to convert surface."); + return; + } + auto ret = DM_JS_TO_ERROR_CODE_MAP.at( + SingletonContainer::Get().SetVirtualScreenSurface(screenId, surface)); + ret = (ret == DmErrorCode::DM_ERROR_NOT_SYSTEM_APP) ? DmErrorCode::DM_ERROR_NO_PERMISSION : ret; + if (ret != DmErrorCode::DM_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] Set virtual screen surface failed."); + AniErrUtils::ThrowBusinessError(env, ret, "set virtual screen surface failed."); + } +} + +void DisplayManagerAni::MakeUnique(ani_env* env, ani_long screenId, ani_long nativeObj) +{ + TLOGI(WmsLogTag::DMS, "[ANI] begin"); + if (env == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] env is nullptr"); + return; + } + DisplayManagerAni* displayManagerAni = reinterpret_cast(nativeObj); + displayManagerAni->OnMakeUnique(env, screenId); +} + +void DisplayManagerAni::OnMakeUnique(ani_env* env, ani_long screenId) +{ + TLOGI(WmsLogTag::DMS, "[ANI] begin"); + if (static_cast(screenId) < 0) { + TLOGE(WmsLogTag::DMS, "[ANI] screenId is invalid: %{public}d", static_cast(screenId)); + AniErrUtils::ThrowBusinessError(env, DmErrorCode::DM_ERROR_ILLEGAL_PARAM, "Invalid screenId"); + return; + } + std::vector screenIds; + screenIds.emplace_back(static_cast(screenId)); + std::vector displayIds; + DmErrorCode ret = DM_JS_TO_ERROR_CODE_MAP.at( + SingletonContainer::Get().MakeUniqueScreen(screenIds, displayIds)); + ret = (ret == DmErrorCode::DM_ERROR_NOT_SYSTEM_APP) ? DmErrorCode::DM_ERROR_NO_PERMISSION : ret; + if (ret != DmErrorCode::DM_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] Make unique failed."); + AniErrUtils::ThrowBusinessError(env, ret, "MakeUnique failed."); + } +} + void DisplayManagerAni::FinalizerDisplay(ani_env* env, ani_object displayObj, ani_long nativeObj) { TLOGI(WmsLogTag::DMS, "[ANI] DMS FinalizerDisplayNative begin"); diff --git a/interfaces/kits/ani/display_runtime/display_ani/src/display_ani_utils.cpp b/interfaces/kits/ani/display_runtime/display_ani/src/display_ani_utils.cpp index bc59c998a6..158aeae3ee 100644 --- a/interfaces/kits/ani/display_runtime/display_ani/src/display_ani_utils.cpp +++ b/interfaces/kits/ani/display_runtime/display_ani/src/display_ani_utils.cpp @@ -261,6 +261,76 @@ ani_object DisplayAniUtils::CreateAniUndefined(ani_env* env) return static_cast(aniRef); } +DmErrorCode DisplayAniUtils::GetVirtualScreenOptionFromAni( + ani_env* env, ani_object virtualScreenConfigObj, VirtualScreenOption& option) +{ + ani_ref nameAni = nullptr; + std::string nameStr; + ani_long width = 0; + ani_long height = 0; + ani_double density = 0; + ani_ref surfaceId = nullptr; + env->Object_GetPropertyByName_Ref(virtualScreenConfigObj, "name", &nameAni); + if (DisplayAniUtils::GetStdString(env, static_cast(nameAni), option.name_) != ANI_OK) { + TLOGE(WmsLogTag::DMS, "Failed to convert parameter to name."); + return DmErrorCode::DM_ERROR_INVALID_PARAM; + } + if (env->Object_GetPropertyByName_Long(virtualScreenConfigObj, "width", &width) != ANI_OK) { + TLOGE(WmsLogTag::DMS, "Failed to convert parameter to width."); + return DmErrorCode::DM_ERROR_INVALID_PARAM; + } + if (env->Object_GetPropertyByName_Long(virtualScreenConfigObj, "height", &height) != ANI_OK) { + TLOGE(WmsLogTag::DMS, "Failed to convert parameter to height."); + return DmErrorCode::DM_ERROR_INVALID_PARAM; + } + if (env->Object_GetPropertyByName_Double(virtualScreenConfigObj, "density", &density) != ANI_OK) { + TLOGE(WmsLogTag::DMS, "Failed to convert parameter to density."); + return DmErrorCode::DM_ERROR_INVALID_PARAM; + } + option.width_ = static_cast(width); + option.height_ = static_cast(height); + option.density_ = static_cast(density); + + env->Object_GetPropertyByName_Ref(virtualScreenConfigObj, "surfaceId", &surfaceId); + if (!DisplayAniUtils::GetSurfaceFromAni(env, static_cast(surfaceId), option.surface_)) { + TLOGE(WmsLogTag::DMS, "[ANI] Failed to convert surface."); + return DmErrorCode::DM_ERROR_INVALID_PARAM; + } + return DmErrorCode::DM_OK; +} + +bool DisplayAniUtils::GetSurfaceFromAni(ani_env* env, ani_string surfaceIdAniValue, sptr& surface) +{ + if (surfaceIdAniValue == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] Failed to convert parameter to surface. Invalidate params."); + return false; + } + ani_size strSize; + ani_status ret = env->String_GetUTF8Size(surfaceIdAniValue, &strSize); + if (ret != ANI_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] Failed to get UTF8 size ret:%{public}d.", static_cast(ret)); + return false; + } + std::vector buffer(strSize + 1); + char* utf8_buffer = buffer.data(); + ani_size bytes_writen = 0; + ret = env->String_GetUTF8(surfaceIdAniValue, utf8_buffer, strSize + 1, &bytes_writen); + if (ret != ANI_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] Failed to get UTF8 ret:%{public}d.", static_cast(ret)); + return false; + } + utf8_buffer[bytes_writen] = '\0'; + std::string surfaceStr = std::string(utf8_buffer); + uint64_t surfaceId = 0; + std::istringstream inputStream(surfaceStr); + inputStream >> surfaceId; + surface = SurfaceUtils::GetInstance()->GetSurface(surfaceId); + if (surface == nullptr) { + TLOGI(WmsLogTag::DMS, "[ANI] GetSurfaceFromAni failed, surfaceId:%{public}" PRIu64"", surfaceId); + } + return true; +} + ani_status DisplayAniUtils::GetAniString(ani_env* env, const std::string& str, ani_string* result) { return env->String_NewUTF8(str.c_str(), static_cast(str.size()), result); diff --git a/interfaces/kits/ani/screenshot_runtime/screenshot_ani/ets/@ohos.screenshot.ets b/interfaces/kits/ani/screenshot_runtime/screenshot_ani/ets/@ohos.screenshot.ets index f9d4ae7a90..aa9290280d 100644 --- a/interfaces/kits/ani/screenshot_runtime/screenshot_ani/ets/@ohos.screenshot.ets +++ b/interfaces/kits/ani/screenshot_runtime/screenshot_ani/ets/@ohos.screenshot.ets @@ -57,6 +57,36 @@ export function save(options?: ScreenshotOptions): Promise { } native function saveSync(screenshotOptions?: ScreenshotOptions): image.PixelMap; + +export function capture(options?: CaptureOption): Promise { + return new Promise((resolve: (value: image.PixelMap) => void, reject: (error: BusinessError) => void ) => { + taskpool.execute((): image.PixelMap => { + let res: image.PixelMap = captureSync(options); + return res; + }).then((ret: NullishType) => { + resolve(ret as image.PixelMap); + }).catch((err: NullishType) => { + reject(err as BusinessError); + }); + }); +} + +native function captureSync(options?: CaptureOption): image.PixelMap; + +export function pick(): Promise { + return new Promise((resolve: (value: PickInfo) => void, reject: (error: BusinessError) => void ) => { + taskpool.execute((): PickInfo => { + let res: PickInfo = pickSync(); + return res; + }).then((ret: NullishType) => { + resolve(ret as PickInfo); + }).catch((err: NullishType) => { + reject(err as BusinessError); + }); + }); +} + +native function pickSync(): PickInfo; export interface ScreenshotOptions { screenRect?: Rect; @@ -72,7 +102,7 @@ export interface ScreenshotOptions { isCaptureFullOfScreen?: boolean; } -export class ScreenshotOptionsImpl implements ScreenshotOptions{ +export class ScreenshotOptionsImpl implements ScreenshotOptions { screenRect?: Rect; imageSize?: Size; @@ -117,5 +147,24 @@ export class RectImpl implements Rect { height: long; } + +export interface CaptureOption { + displayId?: Long; +} +export class CaptureOptionImpl implements CaptureOption { + displayId?: Long; +} + +export interface PickInfo { + pickRect: Rect; + + pixelMap: image.PixelMap; +} + +export class PickInfoImpl implements PickInfo { + pickRect: Rect; + + pixelMap: image.PixelMap; +} } \ No newline at end of file diff --git a/interfaces/kits/ani/screenshot_runtime/screenshot_ani/include/screenshot_ani_manager.h b/interfaces/kits/ani/screenshot_runtime/screenshot_ani/include/screenshot_ani_manager.h index 8a6ca3ed9e..232878af0c 100644 --- a/interfaces/kits/ani/screenshot_runtime/screenshot_ani/include/screenshot_ani_manager.h +++ b/interfaces/kits/ani/screenshot_runtime/screenshot_ani/include/screenshot_ani_manager.h @@ -30,6 +30,7 @@ struct Option { int rotation = 0; DisplayId displayId = 0; bool isNeedNotify = true; + bool isNeedPointer = true; bool isCaptureFullOfScreen = true; }; @@ -48,8 +49,12 @@ class ScreenshotManagerAni { public: explicit ScreenshotManagerAni(); static ani_object Save(ani_env* env, ani_object options); + static ani_object Capture(ani_env* env, ani_object options); + static ani_object Pick(ani_env* env); static void InitScreenshotManagerAni(ani_namespace nsp, ani_env* env); - static void GetScreenshot(ani_env *env, std::unique_ptr ¶m); + static void GetScreenshot(std::unique_ptr& param); + static void GetScreenshotCapture(std::unique_ptr& param); + static void GetScreenshotPick(std::unique_ptr& param); }; } #endif \ No newline at end of file diff --git a/interfaces/kits/ani/screenshot_runtime/screenshot_ani/include/screenshot_ani_utils.h b/interfaces/kits/ani/screenshot_runtime/screenshot_ani/include/screenshot_ani_utils.h index 99dad41043..47c1e5d5c5 100644 --- a/interfaces/kits/ani/screenshot_runtime/screenshot_ani/include/screenshot_ani_utils.h +++ b/interfaces/kits/ani/screenshot_runtime/screenshot_ani/include/screenshot_ani_utils.h @@ -20,6 +20,7 @@ #include "pixel_map.h" #include "singleton_container.h" #include "screenshot_ani_manager.h" +#include "pixel_map_taihe_ani.h" namespace OHOS::Rosen { @@ -28,6 +29,12 @@ public: static ani_status GetStdString(ani_env* env, ani_string ani_str, std::string& result); static ani_object CreateAniUndefined(ani_env* env); + +static ani_object CreateRectObject(ani_env* env); + +static void ConvertRect(ani_env* env, Media::Rect rect, ani_object rectObj); + +static ani_object CreateScreenshotPickInfo(ani_env* env, std::unique_ptr& param); static ani_status GetAniString(ani_env* env, const std::string& str, ani_string* result); diff --git a/interfaces/kits/ani/screenshot_runtime/screenshot_ani/src/screenshot_ani_manager.cpp b/interfaces/kits/ani/screenshot_runtime/screenshot_ani/src/screenshot_ani_manager.cpp index 08d80a7595..7d86040a34 100644 --- a/interfaces/kits/ani/screenshot_runtime/screenshot_ani/src/screenshot_ani_manager.cpp +++ b/interfaces/kits/ani/screenshot_runtime/screenshot_ani/src/screenshot_ani_manager.cpp @@ -22,7 +22,6 @@ #include "window_manager_hilog.h" #include "display_manager.h" #include "dm_common.h" -#include "pixel_map_taihe_ani.h" #include "refbase.h" #include "screenshot_ani_utils.h" #include "ani_err_utils.h" @@ -41,10 +40,6 @@ ani_object ScreenshotManagerAni::Save(ani_env* env, ani_object options) { TLOGI(WmsLogTag::DMS, "[ANI] begin"); auto param = std::make_unique(); - if (param == nullptr) { - TLOGI(WmsLogTag::DMS, "Create param failed."); - return nullptr; - } param->option.displayId = DisplayManager::GetInstance().GetDefaultDisplayId(); ani_boolean optionsUndefined = 0; env->Reference_IsUndefined(options, &optionsUndefined); @@ -58,7 +53,7 @@ ani_object ScreenshotManagerAni::Save(ani_env* env, ani_object options) } } param->isPick = false; - GetScreenshot(env, param); + GetScreenshot(param); if (param->wret != DmErrorCode::DM_OK) { if (param->wret == DmErrorCode::DM_ERROR_NO_PERMISSION || param->wret == DmErrorCode::DM_ERROR_INVALID_PARAM || @@ -68,14 +63,16 @@ ani_object ScreenshotManagerAni::Save(ani_env* env, ani_object options) } return ScreenshotAniUtils::CreateAniUndefined(env); } - if (param->image != nullptr) { - TLOGI(WmsLogTag::DMS, "save pixelMap, currentId = %{public}d", static_cast(param->image->currentId)); + if (param->image == nullptr) { + TLOGE(WmsLogTag::DMS, "save pixelMap failed"); + return ScreenshotAniUtils::CreateAniUndefined(env); } + TLOGI(WmsLogTag::DMS, "save pixelMap, currentId = %{public}d", static_cast(param->image->currentId)); auto nativePixelMap = Media::PixelMapTaiheAni::CreateEtsPixelMap(env, param->image); return nativePixelMap; } -void ScreenshotManagerAni::GetScreenshot(ani_env *env, std::unique_ptr ¶m) +void ScreenshotManagerAni::GetScreenshot(std::unique_ptr& param) { TLOGI(WmsLogTag::DMS, "[ANI] begin"); if (!param->validInputParam) { @@ -114,12 +111,100 @@ void ScreenshotManagerAni::GetScreenshot(ani_env *env, std::unique_ptr &p } } if (param->image == nullptr && param->wret == DmErrorCode::DM_OK) { - TLOGI(WmsLogTag::DMS, "Get Screenshot failed!"); + TLOGE(WmsLogTag::DMS, "Get Screenshot failed!"); param->wret = DmErrorCode::DM_ERROR_INVALID_SCREEN; param->errMessage = "Get Screenshot failed: Screenshot image is nullptr"; return; } } + +ani_object ScreenshotManagerAni::Capture(ani_env* env, ani_object options) +{ + TLOGI(WmsLogTag::DMS, "[ANI]"); + if (env == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] env is nullptr"); + return nullptr; + } + auto param = std::make_unique(); + param->option.displayId = DisplayManager::GetInstance().GetDefaultDisplayId(); + param->option.isNeedNotify = true; + param->option.isNeedPointer = true; + ani_boolean optionsUndefined = 0; + env->Reference_IsUndefined(options, &optionsUndefined); + if (!optionsUndefined) { + ani_long displayId = 0; + ani_status ret = ScreenshotAniUtils::ReadOptionalLongField(env, options, "displayId", displayId); + TLOGI(WmsLogTag::DMS, "[ANI] displayId %{public}llu", static_cast(displayId)); + if (ret != ANI_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] get displayId failed"); + return nullptr; + } + param->option.displayId = static_cast(displayId); + } + GetScreenshotCapture(param); + if (param->wret != DmErrorCode::DM_OK) { + AniErrUtils::ThrowBusinessError(env, param->wret, param->errMessage); + return ScreenshotAniUtils::CreateAniUndefined(env); + } + if (param->image == nullptr) { + TLOGE(WmsLogTag::DMS, "capture pixelMap failed"); + return ScreenshotAniUtils::CreateAniUndefined(env); + } + TLOGI(WmsLogTag::DMS, "capture pixelMap, currentId = %{public}d", static_cast(param->image->currentId)); + auto nativePixelMap = Media::PixelMapTaiheAni::CreateEtsPixelMap(env, param->image); + return nativePixelMap; +} + +void ScreenshotManagerAni::GetScreenshotCapture(std::unique_ptr& param) +{ + CaptureOption captureOption; + captureOption.displayId_ = param->option.displayId; + captureOption.isNeedNotify_ = param->option.isNeedNotify; + captureOption.isNeedPointer_ = param->option.isNeedPointer; + TLOGI(WmsLogTag::DMS, "capture option isNeedNotify=%{public}d isNeedPointer=%{public}d", + captureOption.isNeedNotify_, captureOption.isNeedPointer_); + param->image = DisplayManager::GetInstance().GetScreenCapture(captureOption, ¶m->wret); + if (param->image == nullptr && param->wret == DmErrorCode::DM_OK) { + TLOGE(WmsLogTag::DMS, "screen capture failed!"); + param->wret = DmErrorCode::DM_ERROR_SYSTEM_INNORMAL; + param->errMessage = "ScreenCapture failed: image is null."; + return; + } +} + +ani_object ScreenshotManagerAni::Pick(ani_env* env) +{ + TLOGI(WmsLogTag::DMS, "[ANI]"); + if (env == nullptr) { + TLOGE(WmsLogTag::DMS, "[ANI] env is nullptr"); + return nullptr; + } + auto param = std::make_unique(); + param->isPick = true; + GetScreenshotPick(param); + if (param->wret != DmErrorCode::DM_OK) { + AniErrUtils::ThrowBusinessError(env, param->wret, param->errMessage); + return ScreenshotAniUtils::CreateAniUndefined(env); + } + if (param->image == nullptr) { + TLOGE(WmsLogTag::DMS, "pick pixelMap failed"); + return ScreenshotAniUtils::CreateAniUndefined(env); + } + TLOGI(WmsLogTag::DMS, "pick pixelMap, currentId = %{public}d", static_cast(param->image->currentId)); + return ScreenshotAniUtils::CreateScreenshotPickInfo(env, param); +} + +void ScreenshotManagerAni::GetScreenshotPick(std::unique_ptr& param) +{ + TLOGI(WmsLogTag::DMS, "Start"); + param->image = DisplayManager::GetInstance().GetSnapshotByPicker(param->imageRect, ¶m->wret); + if (param->image == nullptr && param->wret == DmErrorCode::DM_OK) { + TLOGE(WmsLogTag::DMS, "screen pick failed!"); + param->wret = DmErrorCode::DM_ERROR_SYSTEM_INNORMAL; + param->errMessage = "ScreenshotPick failed: image is null."; + return; + } +} extern "C" { ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result) @@ -141,6 +226,10 @@ ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result) std::array funcs = { ani_native_function {"saveSync", nullptr, reinterpret_cast(ScreenshotManagerAni::Save)}, + ani_native_function {"captureSync", nullptr, + reinterpret_cast(ScreenshotManagerAni::Capture)}, + ani_native_function {"pickSync", nullptr, + reinterpret_cast(ScreenshotManagerAni::Pick)}, }; if ((ret = env->Namespace_BindNativeFunctions(nsp, funcs.data(), funcs.size()))) { TLOGE(WmsLogTag::DMS, "[ANI] bind namespace fail %{public}u", ret); diff --git a/interfaces/kits/ani/screenshot_runtime/screenshot_ani/src/screenshot_ani_utils.cpp b/interfaces/kits/ani/screenshot_runtime/screenshot_ani/src/screenshot_ani_utils.cpp index a0e38e2c80..d0a7bb5979 100644 --- a/interfaces/kits/ani/screenshot_runtime/screenshot_ani/src/screenshot_ani_utils.cpp +++ b/interfaces/kits/ani/screenshot_runtime/screenshot_ani/src/screenshot_ani_utils.cpp @@ -48,6 +48,68 @@ ani_object ScreenshotAniUtils::CreateAniUndefined(ani_env* env) env->GetUndefined(&aniRef); return static_cast(aniRef); } + +ani_object ScreenshotAniUtils::CreateRectObject(ani_env* env) +{ + ani_class aniClass{}; + ani_status status = env->FindClass("@ohos.screenshot.screenshot.RectImpl", &aniClass); + if (status != ANI_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] class not found, status:%{public}d", static_cast(status)); + return nullptr; + } + ani_method aniCtor; + auto ret = env->Class_FindMethod(aniClass, "", ":V", &aniCtor); + if (ret != ANI_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] Class_FindMethod failed"); + return nullptr; + } + ani_object rectObj; + status = env->Object_New(aniClass, aniCtor, &rectObj); + if (status != ANI_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] Object_New failed"); + return nullptr; + } + return rectObj; +} + +void ScreenshotAniUtils::ConvertRect(ani_env* env, Media::Rect rect, ani_object rectObj) +{ + TLOGI(WmsLogTag::DMS, "[ANI] rect area info: %{public}d, %{public}d, %{public}u, %{public}u", + rect.left, rect.width, rect.top, rect.height); + env->Object_SetFieldByName_Long(rectObj, "left", rect.left); + env->Object_SetFieldByName_Long(rectObj, "top", rect.top); + env->Object_SetFieldByName_Long(rectObj, "width", rect.width); + env->Object_SetFieldByName_Long(rectObj, "height", rect.height); +} + +ani_object ScreenshotAniUtils::CreateScreenshotPickInfo(ani_env* env, std::unique_ptr& param) +{ + ani_class aniClass{}; + ani_status status = env->FindClass("@ohos.screenshot.screenshot.PickInfoImpl", &aniClass); + if (status != ANI_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] class not found, status:%{public}d", static_cast(status)); + return nullptr; + } + ani_method aniCtor; + auto ret = env->Class_FindMethod(aniClass, "", ":V", &aniCtor); + if (ret != ANI_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] Class_FindMethod failed"); + return nullptr; + } + ani_object pickInfoObj; + status = env->Object_New(aniClass, aniCtor, &pickInfoObj); + if (status != ANI_OK) { + TLOGE(WmsLogTag::DMS, "[ANI] Object_New failed"); + return nullptr; + } + ani_object rectObj = ScreenshotAniUtils::CreateRectObject(env); + ScreenshotAniUtils::ConvertRect(env, param->imageRect, rectObj); + env->Object_SetFieldByName_Ref(pickInfoObj, "pickRect", static_cast(rectObj)); + + auto nativePixelMap = Media::PixelMapTaiheAni::CreateEtsPixelMap(env, param->image); + env->Object_SetFieldByName_Ref(pickInfoObj, "pixelMap", static_cast(nativePixelMap)); + return pickInfoObj; +} ani_status ScreenshotAniUtils::GetAniString(ani_env* env, const std::string& str, ani_string* result) { -- Gitee