From fca8d89eb136eab1048bc7755fc8ff269b6c1943 Mon Sep 17 00:00:00 2001 From: zhanglei Date: Fri, 8 Aug 2025 16:12:33 +0800 Subject: [PATCH] add camera transfer code Signed-off-by: zhanglei --- .../src/input/camera_input_napi.cpp | 17 + .../src/mode/photo_session_napi.cpp | 40 ++ .../src/mode/secure_camera_session_napi.cpp | 43 ++ .../src/mode/video_session_napi.cpp | 41 ++ .../src/output/metadata_output_napi.cpp | 42 ++ .../js/camera_napi/src/output/photo_napi.cpp | 34 ++ .../src/output/photo_output_napi.cpp | 37 ++ .../src/output/preview_output_napi.cpp | 43 ++ .../src/output/video_output_napi.cpp | 41 ++ frameworks/taihe/BUILD.gn | 4 + .../taihe/idl/ohos.multimedia.camera.taihe | 95 ++- .../taihe/include/mode/photo_session_taihe.h | 9 + .../taihe/include/mode/secure_session_taihe.h | 9 + .../taihe/include/mode/video_session_taihe.h | 9 + .../include/output/metadata_output_taihe.h | 5 + .../include/output/preview_output_taihe.h | 5 + .../taihe/include/output/video_output_taihe.h | 5 + frameworks/taihe/include/photo_taihe.h | 5 + .../transfer/camera_lib_manager_taihe.h | 99 ++++ .../include/transfer/camera_transfer_taihe.h | 58 ++ .../src/transfer/camera_transfer_taihe.cpp | 555 ++++++++++++++++++ interfaces/kits/js/camera_napi/BUILD.gn | 2 +- .../include/mode/photo_session_napi.h | 1 + .../include/mode/secure_camera_session_napi.h | 1 + .../include/mode/video_session_napi.h | 1 + .../include/output/metadata_output_napi.h | 1 + .../camera_napi/include/output/photo_napi.h | 13 + .../include/output/photo_output_napi.h | 1 + .../include/output/preview_output_napi.h | 1 + .../include/output/video_output_napi.h | 1 + .../kits/js/camera_napi/libcamera_napi.map | 22 +- 31 files changed, 1237 insertions(+), 3 deletions(-) create mode 100644 frameworks/taihe/include/transfer/camera_lib_manager_taihe.h create mode 100644 frameworks/taihe/include/transfer/camera_transfer_taihe.h create mode 100644 frameworks/taihe/src/transfer/camera_transfer_taihe.cpp diff --git a/frameworks/js/camera_napi/src/input/camera_input_napi.cpp b/frameworks/js/camera_napi/src/input/camera_input_napi.cpp index 8ad034ae8..8bdd35319 100644 --- a/frameworks/js/camera_napi/src/input/camera_input_napi.cpp +++ b/frameworks/js/camera_napi/src/input/camera_input_napi.cpp @@ -645,5 +645,22 @@ napi_value CameraInputNapi::ControlAuxiliary(napi_env env, napi_callback_info in static_cast(auxiliaryStatus)); return CameraNapiUtils::GetUndefinedValue(env); } + +extern "C" { +napi_value GetCameraInputNapi(napi_env env, sptr cameraInput) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + return CameraInputNapi::CreateCameraInput(env, cameraInput); +} + +bool GetNativeCameraInput(void *cameraInputNapiPtr, sptr &nativeCameraInput) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(cameraInputNapiPtr == nullptr, + false, "%{public}s cameraInputNapiPtr is nullptr", __func__); + nativeCameraInput = reinterpret_cast(cameraInputNapiPtr)->GetCameraInput(); + return true; +} +} } // namespace CameraStandard } // namespace OHOS diff --git a/frameworks/js/camera_napi/src/mode/photo_session_napi.cpp b/frameworks/js/camera_napi/src/mode/photo_session_napi.cpp index b84d11aed..b4d28a662 100644 --- a/frameworks/js/camera_napi/src/mode/photo_session_napi.cpp +++ b/frameworks/js/camera_napi/src/mode/photo_session_napi.cpp @@ -90,6 +90,31 @@ napi_value PhotoSessionNapi::CreateCameraSession(napi_env env) return result; } +napi_value PhotoSessionNapi::CreatePhotoSessionForTransfer(napi_env env, sptr photoSession) +{ + MEDIA_INFO_LOG("CreatePhotoSessionForTransfer is called"); + CHECK_ERROR_RETURN_RET_LOG(photoSession == nullptr, nullptr, + "CreatePhotoSessionForTransfer photoSession is nullptr"); + napi_status status; + napi_value result = nullptr; + napi_value constructor; + status = napi_get_reference_value(env, sConstructor_, &constructor); + if (status == napi_ok) { + sCameraSession_ = photoSession; + status = napi_new_instance(env, constructor, 0, nullptr, &result); + sCameraSession_ = nullptr; + if (status == napi_ok && result != nullptr) { + MEDIA_INFO_LOG("CreatePhotoSessionForTransfer success to create napi instance for transfer"); + return result; + } else { + MEDIA_ERR_LOG("CreatePhotoSessionForTransfer Failed to create napi instance for transfer"); + } + } + MEDIA_ERR_LOG("CreatePhotoSessionForTransfer Failed"); + napi_get_undefined(env, &result); + return result; +} + napi_value PhotoSessionNapi::PhotoSessionNapiConstructor(napi_env env, napi_callback_info info) { MEDIA_DEBUG_LOG("PhotoSessionNapiConstructor is called"); @@ -142,5 +167,20 @@ void PhotoSessionNapi::UnregisterPressureStatusCallbackListener( pressureCallback_->RemoveCallbackRef(eventName, callback); } +extern "C" { +napi_value GetPhotoSessionNapi(napi_env env, sptr photoSession) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + return PhotoSessionNapi::CreatePhotoSessionForTransfer(env, photoSession); +} +bool GetNativePhotoSession(void *photoSessionNapiPtr, sptr &nativeSession) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(photoSessionNapiPtr == nullptr, + false, "%{public}s photoSessionNapiPtr is nullptr", __func__); + nativeSession = reinterpret_cast(photoSessionNapiPtr)->cameraSession_; + return true; +} +} } // namespace CameraStandard } // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/camera_napi/src/mode/secure_camera_session_napi.cpp b/frameworks/js/camera_napi/src/mode/secure_camera_session_napi.cpp index 94c95a941..bc39a862c 100644 --- a/frameworks/js/camera_napi/src/mode/secure_camera_session_napi.cpp +++ b/frameworks/js/camera_napi/src/mode/secure_camera_session_napi.cpp @@ -92,6 +92,32 @@ napi_value SecureCameraSessionNapi::CreateCameraSession(napi_env env) return result; } +napi_value SecureCameraSessionNapi::CreateSecureSessionForTransfer(napi_env env, + sptr secureCameraSession) +{ + MEDIA_INFO_LOG("CreateSecureSessionForTransfer is called"); + CHECK_ERROR_RETURN_RET_LOG(secureCameraSession == nullptr, nullptr, + "CreateSecureSessionForTransfer secureCameraSession is nullptr"); + napi_status status; + napi_value result = nullptr; + napi_value constructor; + status = napi_get_reference_value(env, sConstructor_, &constructor); + if (status == napi_ok) { + sCameraSession_ = secureCameraSession; + status = napi_new_instance(env, constructor, 0, nullptr, &result); + sCameraSession_ = nullptr; + if (status == napi_ok && result != nullptr) { + MEDIA_INFO_LOG("success to create Camera session napi instance for transfer"); + return result; + } else { + MEDIA_ERR_LOG("Failed to create Camera session napi instance for transfer"); + } + } + MEDIA_ERR_LOG("CreateSecureSessionForTransfer Failed"); + napi_get_undefined(env, &result); + return result; +} + napi_value SecureCameraSessionNapi::AddSecureOutput(napi_env env, napi_callback_info info) { MEDIA_INFO_LOG("AddSecureOutput is called"); @@ -148,5 +174,22 @@ napi_value SecureCameraSessionNapi::SecureCameraSessionNapiConstructor(napi_env MEDIA_ERR_LOG("SecureCameraSessionNapi call Failed!"); return result; } + +extern "C" { +napi_value GetSecureCameraSessionNapi(napi_env env, sptr secureCameraSession) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + return SecureCameraSessionNapi::CreateSecureSessionForTransfer(env, secureCameraSession); +} + +bool GetNativeSecureCameraSession(void *secureCameraSessionNapiPtr, sptr &nativeSession) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(secureCameraSessionNapiPtr == nullptr, + false, "%{public}s secureCameraSessionNapiPtr is nullptr", __func__); + nativeSession = reinterpret_cast(secureCameraSessionNapiPtr)->cameraSession_; + return true; +} +} } // namespace CameraStandard } // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/camera_napi/src/mode/video_session_napi.cpp b/frameworks/js/camera_napi/src/mode/video_session_napi.cpp index fd96aa756..7b8b21ba1 100644 --- a/frameworks/js/camera_napi/src/mode/video_session_napi.cpp +++ b/frameworks/js/camera_napi/src/mode/video_session_napi.cpp @@ -91,6 +91,31 @@ napi_value VideoSessionNapi::CreateCameraSession(napi_env env) return result; } +napi_value VideoSessionNapi::CreateVideoSessionForTransfer(napi_env env, sptr videoSession) +{ + MEDIA_INFO_LOG("CreateVideoSessionForTransfer is called"); + CHECK_ERROR_RETURN_RET_LOG(videoSession == nullptr, nullptr, + "CreateVideoSessionForTransfer videoSession is nullptr"); + napi_status status; + napi_value result = nullptr; + napi_value constructor; + status = napi_get_reference_value(env, sConstructor_, &constructor); + if (status == napi_ok) { + sCameraSession_ = videoSession; + status = napi_new_instance(env, constructor, 0, nullptr, &result); + sCameraSession_ = nullptr; + if (status == napi_ok && result != nullptr) { + MEDIA_INFO_LOG("CreateVideoSessionForTransfer success to create napi instance for transfer"); + return result; + } else { + MEDIA_ERR_LOG("CreateVideoSessionForTransfer Failed to create napi instance for transfer"); + } + } + MEDIA_ERR_LOG("CreateVideoSessionForTransfer Failed"); + napi_get_undefined(env, &result); + return result; +} + napi_value VideoSessionNapi::VideoSessionNapiConstructor(napi_env env, napi_callback_info info) { MEDIA_DEBUG_LOG("VideoSessionNapiConstructor is called"); @@ -143,5 +168,21 @@ void VideoSessionNapi::UnregisterPressureStatusCallbackListener( pressureCallback_->RemoveCallbackRef(eventName, callback); } +extern "C" { +napi_value GetVideoSessionNapi(napi_env env, sptr videoSession) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + return VideoSessionNapi::CreateVideoSessionForTransfer(env, videoSession); +} + +bool GetNativeVideoSession(void *videoSessionNapiPtr, sptr &nativeSession) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(videoSessionNapiPtr == nullptr, + false, "%{public}s videoSessionNapiPtr is nullptr", __func__); + nativeSession = reinterpret_cast(videoSessionNapiPtr)->cameraSession_; + return true; +} +} } // namespace CameraStandard } // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/camera_napi/src/output/metadata_output_napi.cpp b/frameworks/js/camera_napi/src/output/metadata_output_napi.cpp index 80fa04809..e4918ab05 100644 --- a/frameworks/js/camera_napi/src/output/metadata_output_napi.cpp +++ b/frameworks/js/camera_napi/src/output/metadata_output_napi.cpp @@ -378,6 +378,31 @@ napi_value MetadataOutputNapi::CreateMetadataOutput(napi_env env, std::vector metadataOutput) +{ + MEDIA_INFO_LOG("CreateMetadataOutputForTransfer is called"); + CHECK_ERROR_RETURN_RET_LOG(metadataOutput == nullptr, nullptr, + "CreateMetadataOutputForTransfer metadataOutput is nullptr"); + napi_status status; + napi_value result = nullptr; + napi_value constructor; + + status = napi_get_reference_value(env, sConstructor_, &constructor); + if (status == napi_ok) { + sMetadataOutput_ = metadataOutput; + status = napi_new_instance(env, constructor, 0, nullptr, &result); + sMetadataOutput_ = nullptr; + if (status == napi_ok && result != nullptr) { + return result; + } else { + MEDIA_ERR_LOG("Failed to create metadata output instance for transfer"); + } + } + MEDIA_ERR_LOG("CreateMetadataOutputForTransfer call Failed!"); + napi_get_undefined(env, &result); + return result; +} + napi_value MetadataOutputNapi::AddMetadataObjectTypes(napi_env env, napi_callback_info info) { MEDIA_INFO_LOG("AddMetadataObjectTypes is called"); @@ -609,5 +634,22 @@ napi_value MetadataOutputNapi::Off(napi_env env, napi_callback_info info) { return ListenerTemplate::Off(env, info); } + +extern "C" { +napi_value GetMetadataOutputNapi(napi_env env, sptr metadataOutput) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + return MetadataOutputNapi::CreateMetadataOutputForTransfer(env, metadataOutput); +} + +bool GetNativeMetadataOutput(void *metadataOutputNapiPtr, sptr &nativeMetadataOutput) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(metadataOutputNapiPtr == nullptr, + false, "%{public}s metadataOutputNapiPtr is nullptr", __func__); + nativeMetadataOutput = reinterpret_cast(metadataOutputNapiPtr)->GetMetadataOutput(); + return true; +} +} } // namespace CameraStandard } // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/camera_napi/src/output/photo_napi.cpp b/frameworks/js/camera_napi/src/output/photo_napi.cpp index 2de298cc8..ad71506a0 100644 --- a/frameworks/js/camera_napi/src/output/photo_napi.cpp +++ b/frameworks/js/camera_napi/src/output/photo_napi.cpp @@ -255,5 +255,39 @@ napi_value PhotoNapi::Release(napi_env env, napi_callback_info info) } return result; } + +extern "C" { +napi_value GetPhotoNapi(napi_env env, std::shared_ptr nativeImage, bool isRaw) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + napi_value result = nullptr; + napi_value image = Media::ImageNapi::Create(env, nativeImage); + CHECK_ERROR_RETURN_RET_LOG(image == nullptr, nullptr, "%{public}s ImageNapi Create failed", __func__); + if (!isRaw) { + result = PhotoNapi::CreatePhoto(env, image); + } else { + result = PhotoNapi::CreateRawPhoto(env, image); + } + return result; +} + +bool GetNativeImage(void *photoNapiPtr, std::shared_ptr &nativeImage) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(photoNapiPtr == nullptr, false, "%{public}s photoNapiPtr is nullptr", __func__); + auto photoNapi = reinterpret_cast(photoNapiPtr); + napi_value mainImageNapi = photoNapi->GetMainForTransfer(); + napi_value rawImageNapi = photoNapi->GetRawForTransfer(); + if (mainImageNapi != nullptr) { + nativeImage = Media::ImageNapi::GetNativeImage(photoNapi->GetEnv(), mainImageNapi); + return true; + } else if (rawImageNapi != nullptr) { + nativeImage = Media::ImageNapi::GetNativeImage(photoNapi->GetEnv(), rawImageNapi); + return true; + } + MEDIA_ERR_LOG("%{public}s mainImage and rawImage in photoNapi are both nullptr", __func__); + return false; +} +} } // namespace CameraStandard } // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/camera_napi/src/output/photo_output_napi.cpp b/frameworks/js/camera_napi/src/output/photo_output_napi.cpp index 2f7311142..83a7c9a8b 100644 --- a/frameworks/js/camera_napi/src/output/photo_output_napi.cpp +++ b/frameworks/js/camera_napi/src/output/photo_output_napi.cpp @@ -2185,6 +2185,26 @@ napi_value PhotoOutputNapi::CreatePhotoOutput(napi_env env, std::string surfaceI return result; } +napi_value PhotoOutputNapi::CreatePhotoOutputForTransfer(napi_env env, sptr photoOutput) +{ + MEDIA_INFO_LOG("CreatePhotoOutputForTransfer is called"); + CHECK_ERROR_RETURN_RET_LOG(photoOutput == nullptr, nullptr, "CreatePhotoOutputForTransfer photoOutput is nullptr"); + napi_status status; + napi_value result = nullptr; + napi_value constructor; + napi_get_undefined(env, &result); + status = napi_get_reference_value(env, sConstructor_, &constructor); + if (status == napi_ok) { + sPhotoOutput_ = photoOutput; + status = napi_new_instance(env, constructor, 0, nullptr, &result); + sPhotoOutput_ = nullptr; + CHECK_ERROR_RETURN_RET_LOG(status == napi_ok && result != nullptr, result, + "Success to create photo output instance for transfer"); + } + MEDIA_ERR_LOG("CreatePhotoOutputForTransfer call Failed!"); + return result; +} + bool ParseCaptureSettings(napi_env env, napi_callback_info info, PhotoOutputAsyncContext* asyncContext, std::shared_ptr& asyncFunction, bool isSettingOptional) { @@ -3367,5 +3387,22 @@ napi_value PhotoOutputNapi::EnableOfflinePhoto(napi_env env, napi_callback_info } return result; } + +extern "C" { +napi_value GetPhotoOutputNapi(napi_env env, sptr photoOutput) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + return PhotoOutputNapi::CreatePhotoOutputForTransfer(env, photoOutput); +} + +bool GetNativePhotoOutput(void *photoOutputNapiPtr, sptr &nativePhotoOutput) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(photoOutputNapiPtr == nullptr, + false, "%{public}s photoOutputNapiPtr is nullptr", __func__); + nativePhotoOutput = reinterpret_cast(photoOutputNapiPtr)->GetPhotoOutput(); + return true; +} +} } // namespace CameraStandard } // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/camera_napi/src/output/preview_output_napi.cpp b/frameworks/js/camera_napi/src/output/preview_output_napi.cpp index 4dd951987..d9d1b3ad1 100644 --- a/frameworks/js/camera_napi/src/output/preview_output_napi.cpp +++ b/frameworks/js/camera_napi/src/output/preview_output_napi.cpp @@ -379,6 +379,32 @@ napi_value PreviewOutputNapi::CreatePreviewOutput(napi_env env, std::string surf return result; } +napi_value PreviewOutputNapi::CreatePreviewOutputForTransfer(napi_env env, sptr previewOutput) +{ + MEDIA_INFO_LOG("CreatePreviewOutputForTransfer is called"); + CHECK_ERROR_RETURN_RET_LOG(previewOutput == nullptr, nullptr, + "CreatePreviewOutputForTransfer previewOutput is nullptr"); + napi_status status; + napi_value result = nullptr; + napi_value constructor; + + status = napi_get_reference_value(env, sConstructor_, &constructor); + if (status == napi_ok) { + sPreviewOutput_ = previewOutput; + status = napi_new_instance(env, constructor, 0, nullptr, &result); + sPreviewOutput_ = nullptr; + + if (status == napi_ok && result != nullptr) { + return result; + } else { + MEDIA_ERR_LOG("Failed to create preview output instance for transfer"); + } + } + MEDIA_ERR_LOG("CreatePreviewOutputForTransfer call Failed!"); + napi_get_undefined(env, &result); + return result; +} + sptr PreviewOutputNapi::GetPreviewOutput() { return previewOutput_; @@ -882,5 +908,22 @@ napi_value PreviewOutputNapi::Off(napi_env env, napi_callback_info info) { return ListenerTemplate::Off(env, info); } + +extern "C" { +napi_value GetPreviewOutputNapi(napi_env env, sptr previewOutput) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + return PreviewOutputNapi::CreatePreviewOutputForTransfer(env, previewOutput); +} + +bool GetNativePreviewOutput(void *previewOutputNapiPtr, sptr &nativePreviewOutput) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(previewOutputNapiPtr == nullptr, + false, "%{public}s previewOutputNapiPtr is nullptr", __func__); + nativePreviewOutput = reinterpret_cast(previewOutputNapiPtr)->GetPreviewOutput(); + return true; +} +} } // namespace CameraStandard } // namespace OHOS diff --git a/frameworks/js/camera_napi/src/output/video_output_napi.cpp b/frameworks/js/camera_napi/src/output/video_output_napi.cpp index a4176b5fa..5617093b8 100644 --- a/frameworks/js/camera_napi/src/output/video_output_napi.cpp +++ b/frameworks/js/camera_napi/src/output/video_output_napi.cpp @@ -452,6 +452,30 @@ napi_value VideoOutputNapi::CreateVideoOutput(napi_env env, std::string surfaceI return result; } +napi_value VideoOutputNapi::CreateVideoOutputForTransfer(napi_env env, sptr videoOutput) +{ + MEDIA_DEBUG_LOG("CreateVideoOutputForTransfer is called"); + CHECK_ERROR_RETURN_RET_LOG(videoOutput == nullptr, nullptr, "CreateVideoOutputForTransfer videoOutput is nullptr"); + napi_status status; + napi_value result = nullptr; + napi_value constructor; + + status = napi_get_reference_value(env, sConstructor_, &constructor); + if (status == napi_ok) { + sVideoOutput_ = videoOutput; + status = napi_new_instance(env, constructor, 0, nullptr, &result); + sVideoOutput_ = nullptr; + if (status == napi_ok && result != nullptr) { + return result; + } else { + MEDIA_ERR_LOG("Failed to create video output instance for transfer"); + } + } + napi_get_undefined(env, &result); + MEDIA_ERR_LOG("CreateVideoOutputForTransfer call Failed!"); + return result; +} + napi_value VideoOutputNapi::Start(napi_env env, napi_callback_info info) { MEDIA_INFO_LOG("Start is called"); @@ -1055,5 +1079,22 @@ napi_value VideoOutputNapi::EnableAutoVideoFrameRate(napi_env env, napi_callback } return result; } + +extern "C" { +napi_value GetVideoOutputNapi(napi_env env, sptr videoOutput) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + return VideoOutputNapi::CreateVideoOutputForTransfer(env, videoOutput); +} + +bool GetNativeVideoOutput(void *videoOutputNapiPtr, sptr &nativeVideoOutput) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(videoOutputNapiPtr == nullptr, + false, "%{public}s videoOutputNapiPtr is nullptr", __func__); + nativeVideoOutput = reinterpret_cast(videoOutputNapiPtr)->GetVideoOutput(); + return true; +} +} } // namespace CameraStandard } // namespace OHOS diff --git a/frameworks/taihe/BUILD.gn b/frameworks/taihe/BUILD.gn index cc28a49b4..1f4f4422d 100644 --- a/frameworks/taihe/BUILD.gn +++ b/frameworks/taihe/BUILD.gn @@ -52,6 +52,7 @@ taihe_shared_library("camera_taihe") { "include/session", "include/mode", "include/picker", + "include/transfer", "${multimedia_camera_framework_path}/interfaces/inner_api/native/camera/include", ] @@ -84,6 +85,7 @@ taihe_shared_library("camera_taihe") { "src/mode/night_photo_session_taihe.cpp", "src/mode/slow_motion_video_session_taihe.cpp", "src/photo_taihe.cpp", + "src/transfer/camera_transfer_taihe.cpp", ] deps = [ @@ -108,6 +110,8 @@ taihe_shared_library("camera_taihe") { "ipc:ipc_core", "media_library:media_library", "media_library:medialibrary_ani_utils", + "napi:ace_napi", + "runtime_core:ani_helpers", ] sanitize = { diff --git a/frameworks/taihe/idl/ohos.multimedia.camera.taihe b/frameworks/taihe/idl/ohos.multimedia.camera.taihe index cc76fabdd..3fe978a25 100644 --- a/frameworks/taihe/idl/ohos.multimedia.camera.taihe +++ b/frameworks/taihe/idl/ohos.multimedia.camera.taihe @@ -421,6 +421,8 @@ interface DeferredPhotoProxy { } interface Photo { + GetSpecificImplPtr(): i64; + @set SetMain(main: Image): void; @get GetMain(): Image; @set SetRaw(raw: Optional): void; @@ -751,6 +753,8 @@ interface PhotoSession : Session, Flash, Zoom, AutoExposure, AutoDeviceSwitch, C GetSessionFunctions(outputCapability: CameraOutputCapability): Array; GetSessionConflictFunctions(): Array; + + GetSpecificImplPtr(): i64; } interface PhotoConflictFunctions : ZoomQuery, MacroQuery { @@ -920,6 +924,8 @@ interface VideoSession : Session, Flash, Zoom, Stabilization, ColorManagement, A SetQualityPrioritization(quality : QualityPrioritization) : void; GetSessionFunctions(outputCapability: CameraOutputCapability): Array; GetSessionConflictFunctions(): Array; + + GetSpecificImplPtr(): i64; } interface VideoConflictFunctions : ZoomQuery, MacroQuery { @@ -1753,6 +1759,8 @@ interface SecureSession : Session, Flash, AutoExposure, Focus, Zoom { OnFocusStateChange(callback: (err: @sts_type("BusinessError") Opaque, data: FocusState)=> void): void; OffFocusStateChange(callback: Optional<(err: @sts_type("BusinessError") Opaque, data: FocusState)=> void>): void; + + GetSpecificImplPtr(): i64; } interface ProfessionalPhotoSession : Session, AutoExposure, ManualExposure, Focus, ManualFocus, WhiteBalance, ManualIso, Flash, Zoom, ColorEffect, Aperture { @@ -2457,4 +2465,89 @@ struct MetadataCatBodyObject { struct MetadataHumanBodyObject { @extends base: MetadataObject; -} \ No newline at end of file +} + +// transfer functions +function CameraInputTransferStaticImpl(input: @sts_type("ESValue") Opaque): CameraInput; +function CameraInputTransferDynamicImpl(input: CameraInput): @sts_type("Any") Opaque; +function PhotoOutputTransferStaticImpl(input: @sts_type("ESValue") Opaque): PhotoOutput; +function PhotoOutputTransferDynamicImpl(input: PhotoOutput): @sts_type("Any") Opaque; +function PreviewOutputTransferStaticImpl(input: @sts_type("ESValue") Opaque): PreviewOutput; +function PreviewOutputTransferDynamicImpl(input: PreviewOutput): @sts_type("Any") Opaque; +function VideoOutputTransferStaticImpl(input: @sts_type("ESValue") Opaque): VideoOutput; +function VideoOutputTransferDynamicImpl(input: VideoOutput): @sts_type("Any") Opaque; +function MetadataOutputTransferStaticImpl(input: @sts_type("ESValue") Opaque): MetadataOutput; +function MetadataOutputTransferDynamicImpl(input: MetadataOutput): @sts_type("Any") Opaque; +function VideoSessionTransferStaticImpl(input: @sts_type("ESValue") Opaque): VideoSession; +function VideoSessionTransferDynamicImpl(input: VideoSession): @sts_type("Any") Opaque; +function SecureSessionTransferStaticImpl(input: @sts_type("ESValue") Opaque): SecureSession; +function SecureSessionTransferDynamicImpl(input: SecureSession): @sts_type("Any") Opaque; +function PhotoSessionTransferStaticImpl(input: @sts_type("ESValue") Opaque): PhotoSession; +function PhotoSessionTransferDynamicImpl(input: PhotoSession): @sts_type("Any") Opaque; +function PhotoTransferStaticImpl(input: @sts_type("ESValue") Opaque): Photo; +function PhotoTransferDynamicImpl(input: Photo): @sts_type("Any") Opaque; + +@!sts_inject(""" +export function cameraInputTransferStatic(input: Any): Object { + return cameraInputTransferStaticImpl(ESValue.wrap(input)); +} +export function cameraInputTransferDynamic(input: Object): Any { + return cameraInputTransferDynamicImpl(input as CameraInput); +} + +export function photoOutputTransferStatic(input: Any): Object { + return photoOutputTransferStaticImpl(ESValue.wrap(input)); +} +export function photoOutputTransferDynamic(input: Object): Any { + return photoOutputTransferDynamicImpl(input as PhotoOutput); +} + +export function previewOutputTransferStatic(input: Any): Object { + return previewOutputTransferStaticImpl(ESValue.wrap(input)); +} +export function previewOutputTransferDynamic(input: Object): Any { + return previewOutputTransferDynamicImpl(input as PreviewOutput); +} + +export function videoOutputTransferStatic(input: Any): Object { + return videoOutputTransferStaticImpl(ESValue.wrap(input)); +} +export function videoOutputTransferDynamic(input: Object): Any { + return videoOutputTransferDynamicImpl(input as VideoOutput); +} + +export function metadataOutputTransferStatic(input: Any): Object { + return metadataOutputTransferStaticImpl(ESValue.wrap(input)); +} +export function metadataOutputTransferDynamic(input: Object): Any { + return metadataOutputTransferDynamicImpl(input as MetadataOutput); +} + +export function videoSessionTransferStatic(input: Any): Object { + return videoSessionTransferStaticImpl(ESValue.wrap(input)); +} +export function videoSessionTransferDynamic(input: Object): Any { + return videoSessionTransferDynamicImpl(input as VideoSession); +} + +export function secureSessionTransferStatic(input: Any): Object { + return secureSessionTransferStaticImpl(ESValue.wrap(input)); +} +export function secureSessionTransferDynamic(input: Object): Any { + return secureSessionTransferDynamicImpl(input as SecureSession); +} + +export function photoSessionTransferStatic(input: Any): Object { + return photoSessionTransferStaticImpl(ESValue.wrap(input)); +} +export function photoSessionTransferDynamic(input: Object): Any { + return photoSessionTransferDynamicImpl(input as PhotoSession); +} + +export function photoTransferStatic(input: Any): Object { + return photoTransferStaticImpl(ESValue.wrap(input)); +} +export function photoTransferDynamic(input: Object): Any { + return photoTransferDynamicImpl(input as Photo); +} +""") \ No newline at end of file diff --git a/frameworks/taihe/include/mode/photo_session_taihe.h b/frameworks/taihe/include/mode/photo_session_taihe.h index 8fb88ebe4..5df8acb5a 100644 --- a/frameworks/taihe/include/mode/photo_session_taihe.h +++ b/frameworks/taihe/include/mode/photo_session_taihe.h @@ -41,6 +41,15 @@ public: bool CanPreconfig(PreconfigType preconfigType, optional_view preconfigRatio); taihe::array GetSessionFunctions(CameraOutputCapability const& outputCapability); taihe::array GetSessionConflictFunctions(); + inline int64_t GetSpecificImplPtr() + { + return reinterpret_cast(this); + } + + sptr GetPhotoSession() + { + return photoSession_; + } protected: sptr photoSession_ = nullptr; }; diff --git a/frameworks/taihe/include/mode/secure_session_taihe.h b/frameworks/taihe/include/mode/secure_session_taihe.h index 2a94c62e0..dfb024cfc 100644 --- a/frameworks/taihe/include/mode/secure_session_taihe.h +++ b/frameworks/taihe/include/mode/secure_session_taihe.h @@ -38,6 +38,15 @@ public: } ~SecureSessionImpl() = default; void AddSecureOutput(weak::PreviewOutput previewOutput) {} + inline int64_t GetSpecificImplPtr() + { + return reinterpret_cast(this); + } + + sptr GetSecureCameraSession() + { + return secureCameraSession_; + } private: sptr secureCameraSession_ = nullptr; }; diff --git a/frameworks/taihe/include/mode/video_session_taihe.h b/frameworks/taihe/include/mode/video_session_taihe.h index d57a75548..91a253578 100644 --- a/frameworks/taihe/include/mode/video_session_taihe.h +++ b/frameworks/taihe/include/mode/video_session_taihe.h @@ -43,6 +43,15 @@ public: bool CanPreconfig(PreconfigType preconfigType, optional_view preconfigRatio); taihe::array GetSessionFunctions(CameraOutputCapability const& outputCapability); taihe::array GetSessionConflictFunctions(); + inline int64_t GetSpecificImplPtr() + { + return reinterpret_cast(this); + } + + sptr GetVideoSession() + { + return videoSession_; + } protected: sptr videoSession_ = nullptr; }; diff --git a/frameworks/taihe/include/output/metadata_output_taihe.h b/frameworks/taihe/include/output/metadata_output_taihe.h index 2d786973b..22930cb31 100644 --- a/frameworks/taihe/include/output/metadata_output_taihe.h +++ b/frameworks/taihe/include/output/metadata_output_taihe.h @@ -68,6 +68,11 @@ public: void AddMetadataObjectTypes(array_view types); std::shared_ptr metadataOutputCallback_; std::shared_ptr metadataObjectsAvailableCallback_; + + sptr GetMetadataOutput() + { + return metadataOutput_; + } private: sptr metadataOutput_ = nullptr; static const EmitterFunctions fun_map_; diff --git a/frameworks/taihe/include/output/preview_output_taihe.h b/frameworks/taihe/include/output/preview_output_taihe.h index 2f2783cc0..b747ab03e 100644 --- a/frameworks/taihe/include/output/preview_output_taihe.h +++ b/frameworks/taihe/include/output/preview_output_taihe.h @@ -80,6 +80,11 @@ public: void OnSketchStatusChanged(callback_view callback); void OffSketchStatusChanged(optional_view> callback); + OHOS::sptr GetPreviewOutput() + { + return previewOutput_; + } + static uint32_t previewOutputTaskId_; private: void RegisterErrorCallbackListener(const std::string& eventName, std::shared_ptr callback, bool isOnce); diff --git a/frameworks/taihe/include/output/video_output_taihe.h b/frameworks/taihe/include/output/video_output_taihe.h index 0cd886a28..e4cd1e82e 100644 --- a/frameworks/taihe/include/output/video_output_taihe.h +++ b/frameworks/taihe/include/output/video_output_taihe.h @@ -97,6 +97,11 @@ public: void OnFrameEnd(callback_view callback); void OffFrameEnd(optional_view> callback); static uint32_t videoOutputTaskId_; + + sptr GetVideoOutput() + { + return videoOutput_; + } private: void RegisterVideoOutputErrorCallbackListener( const std::string& eventName, std::shared_ptr callback, bool isOnce); diff --git a/frameworks/taihe/include/photo_taihe.h b/frameworks/taihe/include/photo_taihe.h index 2ff030275..d0717117f 100644 --- a/frameworks/taihe/include/photo_taihe.h +++ b/frameworks/taihe/include/photo_taihe.h @@ -38,6 +38,11 @@ public: void SetCaptureId(int32_t captureId); int32_t GetCaptureId(); void ReleaseSync(); + + inline int64_t GetSpecificImplPtr() + { + return reinterpret_cast(this); + } private: ImageTaihe::Image mainImage_ = make_holder(); ImageTaihe::Image rawImage_ = make_holder(); diff --git a/frameworks/taihe/include/transfer/camera_lib_manager_taihe.h b/frameworks/taihe/include/transfer/camera_lib_manager_taihe.h new file mode 100644 index 000000000..bffcde044 --- /dev/null +++ b/frameworks/taihe/include/transfer/camera_lib_manager_taihe.h @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2025 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. + */ + +#ifndef FRAMEWORKS_TAIHE_INCLUDE_CAMERA_LIB_MANAGER_TAIHE_H +#define FRAMEWORKS_TAIHE_INCLUDE_CAMERA_LIB_MANAGER_TAIHE_H +#include +#include +#include +#include + +#include "camera_log.h" + +namespace Ani { +namespace Camera { +const std::string LIB_CAMERA_NAPI_SO = "libcamera_napi.z.so"; + +class LibHandle { +public: + explicit LibHandle(const std::string& lib_name) : lib_name_(lib_name) + { + handle_ = dlopen(lib_name.c_str(), RTLD_LAZY | RTLD_LOCAL); + if (!handle_) { + MEDIA_ERR_LOG("%{public}s dlopen failed, lib: %{public}s, error: %{public}s", __func__, + LIB_CAMERA_NAPI_SO.c_str(), dlerror()); + } + } + + ~LibHandle() + { + if (handle_) { + dlclose(handle_); + } + } + + bool IsValid() const { return handle_ != nullptr; } + void* GetHandlePtr() const { return handle_; } + + LibHandle(const LibHandle&) = delete; + LibHandle& operator=(const LibHandle&) = delete; + +private: + std::string lib_name_; + void* handle_; +}; + +class LibManager { +public: + static std::shared_ptr GetCameraNapiLibHandle() + { + std::lock_guard lock(mutex_); + if (!instance_) { + instance_ = std::make_shared(LIB_CAMERA_NAPI_SO); + if (!instance_->IsValid()) { + instance_.reset(); + } + } + return instance_; + } + + template + static bool GetSymbol(const char* name, Func& outFunc) + { + auto lib = GetCameraNapiLibHandle(); + if (!lib || !lib->IsValid()) { + MEDIA_ERR_LOG("%{public}s Library not loaded when getting symbol: %{public}s", __func__, name); + return false; + } + + void* symbol = dlsym(lib->GetHandlePtr(), name); + if (!symbol) { + MEDIA_ERR_LOG("%{public}s Failed to find symbol: %{public}s", __func__, name); + return false; + } + + outFunc = reinterpret_cast(symbol); + return true; + } + +private: + static std::mutex mutex_; + static std::shared_ptr instance_; +}; + +} // namespace Camera +} // namespace Ani + +#endif // FRAMEWORKS_TAIHE_INCLUDE_CAMERA_TRANSFER_TAIHE_H \ No newline at end of file diff --git a/frameworks/taihe/include/transfer/camera_transfer_taihe.h b/frameworks/taihe/include/transfer/camera_transfer_taihe.h new file mode 100644 index 000000000..95676debc --- /dev/null +++ b/frameworks/taihe/include/transfer/camera_transfer_taihe.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2025 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. + */ + +#ifndef FRAMEWORKS_TAIHE_INCLUDE_CAMERA_TRANSFER_TAIHE_H +#define FRAMEWORKS_TAIHE_INCLUDE_CAMERA_TRANSFER_TAIHE_H + +#include "ohos.multimedia.camera.proj.hpp" +#include "ohos.multimedia.camera.impl.hpp" +#include "taihe/runtime.hpp" + +namespace Ani { +namespace Camera { +using namespace taihe; +using namespace ohos::multimedia::camera; + +CameraInput CameraInputTransferStaticImpl(uintptr_t input); +uintptr_t CameraInputTransferDynamicImpl(CameraInput input); + +PhotoOutput PhotoOutputTransferStaticImpl(uintptr_t input); +uintptr_t PhotoOutputTransferDynamicImpl(PhotoOutput input); + +PreviewOutput PreviewOutputTransferStaticImpl(uintptr_t input); +uintptr_t PreviewOutputTransferDynamicImpl(PreviewOutput input); + +VideoOutput VideoOutputTransferStaticImpl(uintptr_t input); +uintptr_t VideoOutputTransferDynamicImpl(VideoOutput input); + +MetadataOutput MetadataOutputTransferStaticImpl(uintptr_t input); +uintptr_t MetadataOutputTransferDynamicImpl(MetadataOutput input); + +VideoSession VideoSessionTransferStaticImpl(uintptr_t input); +uintptr_t VideoSessionTransferDynamicImpl(VideoSession input); + +SecureSession SecureSessionTransferStaticImpl(uintptr_t input); +uintptr_t SecureSessionTransferDynamicImpl(SecureSession input); + +PhotoSession PhotoSessionTransferStaticImpl(uintptr_t input); +uintptr_t PhotoSessionTransferDynamicImpl(PhotoSession input); + +Photo PhotoTransferStaticImpl(uintptr_t input); +uintptr_t PhotoTransferDynamicImpl(Photo input); + +} // namespace Camera +} // namespace Ani + +#endif // FRAMEWORKS_TAIHE_INCLUDE_CAMERA_TRANSFER_TAIHE_H \ No newline at end of file diff --git a/frameworks/taihe/src/transfer/camera_transfer_taihe.cpp b/frameworks/taihe/src/transfer/camera_transfer_taihe.cpp new file mode 100644 index 000000000..87915790c --- /dev/null +++ b/frameworks/taihe/src/transfer/camera_transfer_taihe.cpp @@ -0,0 +1,555 @@ +/* + * Copyright (C) 2025 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. + */ + +#include "camera_transfer_taihe.h" + +#include "camera_lib_manager_taihe.h" +#include "camera_log.h" +#include "image_taihe.h" +#include "camera_input_taihe.h" +#include "photo_output_taihe.h" +#include "preview_output_taihe.h" +#include "video_output_taihe.h" +#include "metadata_output_taihe.h" +#include "video_session_taihe.h" +#include "secure_session_taihe.h" +#include "photo_session_taihe.h" +#include "photo_taihe.h" +#include "interop_js/arkts_esvalue.h" +#include "interop_js/arkts_interop_js_api.h" + +using namespace Ani::Camera; +using GetCameraInputNapiFn = napi_value (*)(napi_env, sptr); +using GetPhotoSessionNapiFn = napi_value (*)(napi_env, sptr); +using GetSecureCameraSessionNapiFn = napi_value (*)(napi_env, sptr); +using GetVideoSessionNapiFn = napi_value (*)(napi_env, sptr); +using GetMetadataOutputNapiFn = napi_value (*)(napi_env, sptr); +using GetPhotoNapiFn = napi_value (*)(napi_env, std::shared_ptr, bool); +using GetPhotoOutputNapiFn = napi_value (*)(napi_env, sptr); +using GetPreviewOutputNapiFn = napi_value (*)(napi_env, sptr); +using GetVideoOutputNapiFn = napi_value (*)(napi_env, sptr); + +using GetNativeCameraInputFn = bool (*)(void*, sptr&); +using GetNativePhotoSessionFn = bool (*)(void*, sptr&); +using GetNativeSecureCameraSessionFn = bool (*)(void*, sptr&); +using GetNativeVideoSessionFn = bool (*)(void*, sptr&); +using GetNativeMetadataOutputFn = bool (*)(void*, sptr&); +using GetNativeImageFn = bool (*)(void*, std::shared_ptr&); +using GetNativePhotoOutputFn = bool (*)(void*, sptr&); +using GetNativePreviewOutputFn = bool (*)(void*, sptr&); +using GetNativeVideoOutputFn = bool (*)(void*, sptr&); +namespace ImageTaihe = ohos::multimedia::image::image; + +namespace Ani { +namespace Camera { +std::mutex LibManager::mutex_; +std::shared_ptr LibManager::instance_ = nullptr; + +CameraInput CameraInputTransferStaticImpl(uintptr_t input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + ani_object esValue = reinterpret_cast(input); + CameraInput cameraInputTH = make_holder(nullptr); + void *nativePtr = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr, + cameraInputTH, "%{public}s unwrap esValue failed", __func__); + GetNativeCameraInputFn funcHandle = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!LibManager::GetSymbol("GetNativeCameraInput", funcHandle), + cameraInputTH, "%{public}s Get GetNativeCameraInput symbol failed", __func__); + sptr nativeCameraInput = nullptr; + bool ret = funcHandle(nativePtr, nativeCameraInput); + CHECK_ERROR_RETURN_RET_LOG(!ret || nativeCameraInput == nullptr, + cameraInputTH, "%{public}s GetNativeCameraInput failed", __func__); + MEDIA_INFO_LOG("%{public}s End", __func__); + return make_holder(nativeCameraInput); +} + +uintptr_t CameraInputTransferDynamicImpl(weak::CameraInput input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(input.is_error(), 0, "%{public}s input is nullptr", __func__); + CameraInputImpl *implPtr = reinterpret_cast(input->GetSpecificImplPtr()); + CHECK_ERROR_RETURN_RET_LOG(implPtr == nullptr, 0, "%{public}s implPtr is nullptr", __func__); + napi_env jsEnv; + CHECK_ERROR_RETURN_RET_LOG(!arkts_napi_scope_open(get_env(), &jsEnv), 0, + "%{public}s arkts_napi_scope_open failed", __func__); + GetCameraInputNapiFn funcHandle = nullptr; + if (!LibManager::GetSymbol("GetCameraInputNapi", funcHandle)) { + MEDIA_ERR_LOG("%{public}s Get GetCameraInputNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value instance = funcHandle(jsEnv, implPtr->GetCameraInput()); + if (instance == nullptr) { + MEDIA_ERR_LOG("%{public}s Get GetCameraInputNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t result = 0; + arkts_napi_scope_close_n(jsEnv, 1, &instance, reinterpret_cast(&result)); + MEDIA_INFO_LOG("%{public}s End", __func__); + return result; +} + +PhotoOutput PhotoOutputTransferStaticImpl(uintptr_t input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + ani_object esValue = reinterpret_cast(input); + PhotoOutput photoOutputTH = make_holder(nullptr); + void *nativePtr = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr, + photoOutputTH, "%{public}s unwrap esValue failed", __func__); + GetNativePhotoOutputFn funcHandle = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!LibManager::GetSymbol("GetNativePhotoOutput", funcHandle), + photoOutputTH, "%{public}s Get GetNativePhotoOutput symbol failed", __func__); + sptr nativePhotoOutput = nullptr; + bool ret = funcHandle(nativePtr, nativePhotoOutput); + CHECK_ERROR_RETURN_RET_LOG(!ret || nativePhotoOutput == nullptr, + photoOutputTH, "%{public}s GetNativePhotoOutput failed", __func__); + MEDIA_INFO_LOG("%{public}s End", __func__); + return make_holder(nativePhotoOutput); +} + +uintptr_t PhotoOutputTransferDynamicImpl(weak::PhotoOutput input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(input.is_error(), 0, "%{public}s input is nullptr", __func__); + PhotoOutputImpl *implPtr = + reinterpret_cast(CameraOutput(PhotoOutput(input))->GetSpecificImplPtr()); + CHECK_ERROR_RETURN_RET_LOG(implPtr == nullptr, 0, "%{public}s implPtr is nullptr", __func__); + napi_env jsEnv; + CHECK_ERROR_RETURN_RET_LOG(!arkts_napi_scope_open(get_env(), &jsEnv), 0, + "%{public}s arkts_napi_scope_open failed", __func__); + GetPhotoOutputNapiFn funcHandle = nullptr; + if (!LibManager::GetSymbol("GetPhotoOutputNapi", funcHandle)) { + MEDIA_ERR_LOG("%{public}s Get GetPhotoOutputNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value instance = funcHandle(jsEnv, implPtr->GetPhotoOutput()); + if (instance == nullptr) { + MEDIA_ERR_LOG("%{public}s Get GetPhotoOutputNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t result = 0; + arkts_napi_scope_close_n(jsEnv, 1, &instance, reinterpret_cast(&result)); + MEDIA_INFO_LOG("%{public}s End", __func__); + return result; +} + +PreviewOutput PreviewOutputTransferStaticImpl(uintptr_t input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + ani_object esValue = reinterpret_cast(input); + PreviewOutput previewOutputTH = make_holder(nullptr); + void *nativePtr = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr, + previewOutputTH, "%{public}s unwrap esValue failed", __func__); + GetNativePreviewOutputFn funcHandle = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!LibManager::GetSymbol("GetNativePreviewOutput", funcHandle), + previewOutputTH, "%{public}s Get GetNativePreviewOutput symbol failed", __func__); + sptr nativePreviewOutput = nullptr; + bool ret = funcHandle(nativePtr, nativePreviewOutput); + CHECK_ERROR_RETURN_RET_LOG(!ret || nativePreviewOutput == nullptr, + previewOutputTH, "%{public}s GetNativePreviewOutput failed", __func__); + MEDIA_INFO_LOG("%{public}s End", __func__); + return make_holder(nativePreviewOutput); +} + +uintptr_t PreviewOutputTransferDynamicImpl(weak::PreviewOutput input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(input.is_error(), 0, "%{public}s input is nullptr", __func__); + PreviewOutputImpl *implPtr = + reinterpret_cast(CameraOutput(PreviewOutput(input))->GetSpecificImplPtr()); + CHECK_ERROR_RETURN_RET_LOG(implPtr == nullptr, 0, "%{public}s implPtr is nullptr", __func__); + napi_env jsEnv; + CHECK_ERROR_RETURN_RET_LOG(!arkts_napi_scope_open(get_env(), &jsEnv), 0, + "%{public}s arkts_napi_scope_open failed", __func__); + GetPreviewOutputNapiFn funcHandle = nullptr; + if (!LibManager::GetSymbol("GetPreviewOutputNapi", funcHandle)) { + MEDIA_ERR_LOG("%{public}s Get GetPreviewOutputNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value instance = funcHandle(jsEnv, implPtr->GetPreviewOutput()); + if (instance == nullptr) { + MEDIA_ERR_LOG("%{public}s Get GetPreviewOutputNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t result = 0; + arkts_napi_scope_close_n(jsEnv, 1, &instance, reinterpret_cast(&result)); + MEDIA_INFO_LOG("%{public}s End", __func__); + return result; +} + +VideoOutput VideoOutputTransferStaticImpl(uintptr_t input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + ani_object esValue = reinterpret_cast(input); + VideoOutput videoOutputTH = make_holder(nullptr); + void *nativePtr = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr, + videoOutputTH, "%{public}s unwrap esValue failed", __func__); + GetNativeVideoOutputFn funcHandle = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!LibManager::GetSymbol("GetNativeVideoOutput", funcHandle), + videoOutputTH, "%{public}s Get GetNativeVideoOutput symbol failed", __func__); + sptr nativeVideoOutput = nullptr; + bool ret = funcHandle(nativePtr, nativeVideoOutput); + CHECK_ERROR_RETURN_RET_LOG(!ret || nativeVideoOutput == nullptr, + videoOutputTH, "%{public}s GetNativeVideoOutput failed", __func__); + MEDIA_INFO_LOG("%{public}s End", __func__); + return make_holder(nativeVideoOutput); +} + +uintptr_t VideoOutputTransferDynamicImpl(weak::VideoOutput input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(input.is_error(), 0, "%{public}s input is nullptr", __func__); + VideoOutputImpl *implPtr = + reinterpret_cast(CameraOutput(VideoOutput(input))->GetSpecificImplPtr()); + CHECK_ERROR_RETURN_RET_LOG(implPtr == nullptr, 0, "%{public}s implPtr is nullptr", __func__); + napi_env jsEnv; + CHECK_ERROR_RETURN_RET_LOG(!arkts_napi_scope_open(get_env(), &jsEnv), 0, + "%{public}s arkts_napi_scope_open failed", __func__); + GetVideoOutputNapiFn funcHandle = nullptr; + if (!LibManager::GetSymbol("GetVideoOutputNapi", funcHandle)) { + MEDIA_ERR_LOG("%{public}s Get GetVideoOutputNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value instance = funcHandle(jsEnv, implPtr->GetVideoOutput()); + if (instance == nullptr) { + MEDIA_ERR_LOG("%{public}s Get GetVideoOutputNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t result = 0; + arkts_napi_scope_close_n(jsEnv, 1, &instance, reinterpret_cast(&result)); + MEDIA_INFO_LOG("%{public}s End", __func__); + return result; +} + +MetadataOutput MetadataOutputTransferStaticImpl(uintptr_t input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + ani_object esValue = reinterpret_cast(input); + MetadataOutput metadataOutputTH = make_holder(nullptr); + void *nativePtr = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr, + metadataOutputTH, "%{public}s unwrap esValue failed", __func__); + GetNativeMetadataOutputFn funcHandle = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!LibManager::GetSymbol("GetNativeMetadataOutput", funcHandle), + metadataOutputTH, "%{public}s Get GetNativeMetadataOutput symbol failed", __func__); + sptr nativeMetadataOutput = nullptr; + bool ret = funcHandle(nativePtr, nativeMetadataOutput); + CHECK_ERROR_RETURN_RET_LOG(!ret || nativeMetadataOutput == nullptr, + metadataOutputTH, "%{public}s GetNativeMetadataOutput failed", __func__); + MEDIA_INFO_LOG("%{public}s End", __func__); + return make_holder(nativeMetadataOutput); +} + +uintptr_t MetadataOutputTransferDynamicImpl(weak::MetadataOutput input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(input.is_error(), 0, "%{public}s input is nullptr", __func__); + MetadataOutputImpl *implPtr = + reinterpret_cast(CameraOutput(MetadataOutput(input))->GetSpecificImplPtr()); + CHECK_ERROR_RETURN_RET_LOG(implPtr == nullptr, 0, "%{public}s implPtr is nullptr", __func__); + napi_env jsEnv; + CHECK_ERROR_RETURN_RET_LOG(!arkts_napi_scope_open(get_env(), &jsEnv), 0, + "%{public}s arkts_napi_scope_open failed", __func__); + GetMetadataOutputNapiFn funcHandle = nullptr; + if (!LibManager::GetSymbol("GetMetadataOutputNapi", funcHandle)) { + MEDIA_ERR_LOG("%{public}s Get GetMetadataOutputNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value instance = funcHandle(jsEnv, implPtr->GetMetadataOutput()); + if (instance == nullptr) { + MEDIA_ERR_LOG("%{public}s Get GetMetadataOutputNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t result = 0; + arkts_napi_scope_close_n(jsEnv, 1, &instance, reinterpret_cast(&result)); + MEDIA_INFO_LOG("%{public}s End", __func__); + return result; +} + +VideoSession VideoSessionTransferStaticImpl(uintptr_t input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + ani_object esValue = reinterpret_cast(input); + sptr sessionNullptr = nullptr; + VideoSession videoSessionTH = make_holder(sessionNullptr); + void *nativePtr = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr, + videoSessionTH, "%{public}s unwrap esValue failed", __func__); + GetNativeVideoSessionFn funcHandle = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!LibManager::GetSymbol("GetNativeVideoSession", funcHandle), + videoSessionTH, "%{public}s Get GetNativeVideoSession symbol failed", __func__); + sptr session = nullptr; + bool ret = funcHandle(nativePtr, session); + CHECK_ERROR_RETURN_RET_LOG(!ret || session == nullptr, + videoSessionTH, "%{public}s GetNativeVideoSession failed", __func__); + MEDIA_INFO_LOG("%{public}s End", __func__); + return make_holder(session); +} + +uintptr_t VideoSessionTransferDynamicImpl(weak::VideoSession input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(input.is_error(), 0, "%{public}s input is nullptr", __func__); + VideoSessionImpl *implPtr = + reinterpret_cast(input->GetSpecificImplPtr()); + CHECK_ERROR_RETURN_RET_LOG(implPtr == nullptr, 0, "%{public}s implPtr is nullptr", __func__); + napi_env jsEnv; + CHECK_ERROR_RETURN_RET_LOG(!arkts_napi_scope_open(get_env(), &jsEnv), 0, + "%{public}s arkts_napi_scope_open failed", __func__); + GetVideoSessionNapiFn funcHandle = nullptr; + if (!LibManager::GetSymbol("GetVideoSessionNapi", funcHandle)) { + MEDIA_ERR_LOG("%{public}s Get GetVideoSessionNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value instance = funcHandle(jsEnv, implPtr->GetVideoSession()); + if (instance == nullptr) { + MEDIA_ERR_LOG("%{public}s Get GetVideoSessionNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t result = 0; + arkts_napi_scope_close_n(jsEnv, 1, &instance, reinterpret_cast(&result)); + MEDIA_INFO_LOG("%{public}s End", __func__); + return result; +} + +SecureSession SecureSessionTransferStaticImpl(uintptr_t input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + ani_object esValue = reinterpret_cast(input); + sptr sessionNullptr = nullptr; + SecureSession secureSessionTH = make_holder(sessionNullptr); + void *nativePtr = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr, + secureSessionTH, "%{public}s unwrap esValue failed", __func__); + GetNativeSecureCameraSessionFn funcHandle = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!LibManager::GetSymbol("GetNativeSecureCameraSession", funcHandle), + secureSessionTH, "%{public}s Get GetNativeSecureCameraSession symbol failed", __func__); + sptr session = nullptr; + bool ret = funcHandle(nativePtr, session); + CHECK_ERROR_RETURN_RET_LOG(!ret || session == nullptr, + secureSessionTH, "%{public}s GetNativeSecureCameraSession failed", __func__); + MEDIA_INFO_LOG("%{public}s End", __func__); + return make_holder(session); +} + +uintptr_t SecureSessionTransferDynamicImpl(weak::SecureSession input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(input.is_error(), 0, "%{public}s input is nullptr", __func__); + SecureSessionImpl *implPtr = + reinterpret_cast(input->GetSpecificImplPtr()); + CHECK_ERROR_RETURN_RET_LOG(implPtr == nullptr, 0, "%{public}s implPtr is nullptr", __func__); + napi_env jsEnv; + CHECK_ERROR_RETURN_RET_LOG(!arkts_napi_scope_open(get_env(), &jsEnv), 0, + "%{public}s arkts_napi_scope_open failed", __func__); + GetSecureCameraSessionNapiFn funcHandle = nullptr; + if (!LibManager::GetSymbol("GetSecureCameraSessionNapi", funcHandle)) { + MEDIA_ERR_LOG("%{public}s Get GetSecureCameraSessionNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value instance = funcHandle(jsEnv, implPtr->GetSecureCameraSession()); + if (instance == nullptr) { + MEDIA_ERR_LOG("%{public}s Get GetSecureCameraSessionNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t result = 0; + arkts_napi_scope_close_n(jsEnv, 1, &instance, reinterpret_cast(&result)); + MEDIA_INFO_LOG("%{public}s End", __func__); + return result; +} + +PhotoSession PhotoSessionTransferStaticImpl(uintptr_t input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + ani_object esValue = reinterpret_cast(input); + sptr sessionNullptr = nullptr; + PhotoSession photoSessionTH = make_holder(sessionNullptr); + void *nativePtr = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr, + photoSessionTH, "%{public}s unwrap esValue failed", __func__); + GetNativePhotoSessionFn funcHandle = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!LibManager::GetSymbol("GetNativePhotoSession", funcHandle), + photoSessionTH, "%{public}s Get GetNativePhotoSession symbol failed", __func__); + sptr session = nullptr; + bool ret = funcHandle(nativePtr, session); + CHECK_ERROR_RETURN_RET_LOG(!ret || session == nullptr, + photoSessionTH, "%{public}s GetNativePhotoSession failed", __func__); + MEDIA_INFO_LOG("%{public}s End", __func__); + return make_holder(session); +} + +uintptr_t PhotoSessionTransferDynamicImpl(weak::PhotoSession input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(input.is_error(), 0, "%{public}s input is nullptr", __func__); + PhotoSessionImpl *implPtr = + reinterpret_cast(input->GetSpecificImplPtr()); + CHECK_ERROR_RETURN_RET_LOG(implPtr == nullptr, 0, "%{public}s implPtr is nullptr", __func__); + napi_env jsEnv; + CHECK_ERROR_RETURN_RET_LOG(!arkts_napi_scope_open(get_env(), &jsEnv), 0, + "%{public}s arkts_napi_scope_open failed", __func__); + GetPhotoSessionNapiFn funcHandle = nullptr; + if (!LibManager::GetSymbol("GetPhotoSessionNapi", funcHandle)) { + MEDIA_ERR_LOG("%{public}s Get GetPhotoSessionNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value instance = funcHandle(jsEnv, implPtr->GetPhotoSession()); + if (instance == nullptr) { + MEDIA_ERR_LOG("%{public}s Get GetPhotoSessionNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t result = 0; + arkts_napi_scope_close_n(jsEnv, 1, &instance, reinterpret_cast(&result)); + MEDIA_INFO_LOG("%{public}s End", __func__); + return result; +} + +Photo PhotoTransferStaticImpl(uintptr_t input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + ani_object esValue = reinterpret_cast(input); + ImageTaihe::Image mainImageEmpty = make_holder(); + Photo photoTHEmpty = make_holder(mainImageEmpty); + void *nativePtr = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!arkts_esvalue_unwrap(get_env(), esValue, &nativePtr) || nativePtr == nullptr, + photoTHEmpty, "%{public}s unwrap esValue failed", __func__); + GetNativeImageFn funcHandle = nullptr; + CHECK_ERROR_RETURN_RET_LOG(!LibManager::GetSymbol("GetNativeImage", funcHandle), + photoTHEmpty, "%{public}s Get GetNativeImage symbol failed", __func__); + std::shared_ptr nativeImage = nullptr; + bool ret = funcHandle(nativePtr, nativeImage); + CHECK_ERROR_RETURN_RET_LOG(!ret || nativeImage == nullptr, + photoTHEmpty, "%{public}s GetNativeImage failed", __func__); + ImageTaihe::Image image = ANI::Image::ImageImpl::Create(nativeImage); + CHECK_ERROR_RETURN_RET_LOG(image.is_error(), photoTHEmpty, + "%{public}s ImageTaihe Create failed", __func__); + MEDIA_INFO_LOG("%{public}s End", __func__); + return make_holder(image); +} + +std::shared_ptr GetNativeImageFromTH(PhotoImpl *photoImplPtr, bool &isRaw) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + ImageTaihe::Image mainImageTH = photoImplPtr->GetMain(); + std::shared_ptr nativeMainImage = nullptr; + if (!mainImageTH.is_error()) { + ANI::Image::ImageImpl *mainImageImplPtr = reinterpret_cast(mainImageTH->GetImplPtr()); + if (mainImageImplPtr != nullptr) { + nativeMainImage = mainImageImplPtr->GetIncrementalImage(); + } + } + optional rawImageTH = photoImplPtr->GetRaw(); + std::shared_ptr nativeRawImage = nullptr; + if (rawImageTH.has_value() && !rawImageTH.value().is_error()) { + ANI::Image::ImageImpl *rawImageImplPtr = + reinterpret_cast(rawImageTH.value()->GetImplPtr()); + if (rawImageImplPtr != nullptr) { + nativeRawImage = rawImageImplPtr->GetIncrementalImage(); + } + } + + if (nativeMainImage != nullptr) { + isRaw = false; + MEDIA_INFO_LOG("%{public}s End. isRaw is %{public}d", __func__, isRaw); + return nativeMainImage; + } else if (nativeRawImage != nullptr) { + isRaw = true; + MEDIA_INFO_LOG("%{public}s End. isRaw is %{public}d", __func__, isRaw); + return nativeRawImage; + } + MEDIA_ERR_LOG("%{public}s mainImage and rawImage in photoTaihe are both nullptr", __func__); + return nullptr; +} + +uintptr_t PhotoTransferDynamicImpl(weak::Photo input) +{ + MEDIA_INFO_LOG("%{public}s Called", __func__); + CHECK_ERROR_RETURN_RET_LOG(input.is_error(), 0, "%{public}s input is nullptr", __func__); + PhotoImpl *photoImplPtr = reinterpret_cast(input->GetSpecificImplPtr()); + CHECK_ERROR_RETURN_RET_LOG(photoImplPtr == nullptr, 0, "%{public}s photoImplPtr is nullptr", __func__); + bool isRaw = false; + std::shared_ptr nativeImage = GetNativeImageFromTH(photoImplPtr, isRaw); + CHECK_ERROR_RETURN_RET_LOG(nativeImage == nullptr, 0, "%{public}s GetNativeImageFromTH failed", __func__); + napi_env jsEnv; + CHECK_ERROR_RETURN_RET_LOG(!arkts_napi_scope_open(get_env(), &jsEnv), 0, + "%{public}s arkts_napi_scope_open failed", __func__); + GetPhotoNapiFn funcHandle = nullptr; + if (!LibManager::GetSymbol("GetPhotoNapi", funcHandle)) { + MEDIA_ERR_LOG("%{public}s Get GetPhotoNapi symbol failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + napi_value instance = nullptr; + instance = funcHandle(jsEnv, nativeImage, isRaw); + if (instance == nullptr) { + MEDIA_ERR_LOG("%{public}s GetPhotoNapi failed", __func__); + arkts_napi_scope_close_n(jsEnv, 0, nullptr, nullptr); + return 0; + } + + uintptr_t result = 0; + arkts_napi_scope_close_n(jsEnv, 1, &instance, reinterpret_cast(&result)); + MEDIA_INFO_LOG("%{public}s End", __func__); + return result; +} + +} // namespace Camera +} // namespace Ani + +TH_EXPORT_CPP_API_CameraInputTransferStaticImpl(CameraInputTransferStaticImpl); +TH_EXPORT_CPP_API_CameraInputTransferDynamicImpl(CameraInputTransferDynamicImpl); +TH_EXPORT_CPP_API_PhotoOutputTransferStaticImpl(PhotoOutputTransferStaticImpl); +TH_EXPORT_CPP_API_PhotoOutputTransferDynamicImpl(PhotoOutputTransferDynamicImpl); +TH_EXPORT_CPP_API_PreviewOutputTransferStaticImpl(PreviewOutputTransferStaticImpl); +TH_EXPORT_CPP_API_PreviewOutputTransferDynamicImpl(PreviewOutputTransferDynamicImpl); +TH_EXPORT_CPP_API_VideoOutputTransferStaticImpl(VideoOutputTransferStaticImpl); +TH_EXPORT_CPP_API_VideoOutputTransferDynamicImpl(VideoOutputTransferDynamicImpl); +TH_EXPORT_CPP_API_MetadataOutputTransferStaticImpl(MetadataOutputTransferStaticImpl); +TH_EXPORT_CPP_API_MetadataOutputTransferDynamicImpl(MetadataOutputTransferDynamicImpl); +TH_EXPORT_CPP_API_VideoSessionTransferStaticImpl(VideoSessionTransferStaticImpl); +TH_EXPORT_CPP_API_VideoSessionTransferDynamicImpl(VideoSessionTransferDynamicImpl); +TH_EXPORT_CPP_API_SecureSessionTransferStaticImpl(SecureSessionTransferStaticImpl); +TH_EXPORT_CPP_API_SecureSessionTransferDynamicImpl(SecureSessionTransferDynamicImpl); +TH_EXPORT_CPP_API_PhotoSessionTransferStaticImpl(PhotoSessionTransferStaticImpl); +TH_EXPORT_CPP_API_PhotoSessionTransferDynamicImpl(PhotoSessionTransferDynamicImpl); +TH_EXPORT_CPP_API_PhotoTransferStaticImpl(PhotoTransferStaticImpl); +TH_EXPORT_CPP_API_PhotoTransferDynamicImpl(PhotoTransferDynamicImpl); \ No newline at end of file diff --git a/interfaces/kits/js/camera_napi/BUILD.gn b/interfaces/kits/js/camera_napi/BUILD.gn index ff88303ad..42cec897d 100644 --- a/interfaces/kits/js/camera_napi/BUILD.gn +++ b/interfaces/kits/js/camera_napi/BUILD.gn @@ -215,4 +215,4 @@ if (gen_camera_picker) { part_name = "camera_framework" subsystem_name = "multimedia" } -} +} \ No newline at end of file diff --git a/interfaces/kits/js/camera_napi/include/mode/photo_session_napi.h b/interfaces/kits/js/camera_napi/include/mode/photo_session_napi.h index 184ad1d22..fa0508080 100644 --- a/interfaces/kits/js/camera_napi/include/mode/photo_session_napi.h +++ b/interfaces/kits/js/camera_napi/include/mode/photo_session_napi.h @@ -27,6 +27,7 @@ class PhotoSessionNapi : public CameraSessionNapi { public: static napi_value Init(napi_env env, napi_value exports); static napi_value CreateCameraSession(napi_env env); + static napi_value CreatePhotoSessionForTransfer(napi_env env, sptr photoSession); PhotoSessionNapi(); ~PhotoSessionNapi(); diff --git a/interfaces/kits/js/camera_napi/include/mode/secure_camera_session_napi.h b/interfaces/kits/js/camera_napi/include/mode/secure_camera_session_napi.h index e65a3e641..b93707900 100644 --- a/interfaces/kits/js/camera_napi/include/mode/secure_camera_session_napi.h +++ b/interfaces/kits/js/camera_napi/include/mode/secure_camera_session_napi.h @@ -29,6 +29,7 @@ class SecureCameraSessionNapi : public CameraSessionNapi { public: static napi_value Init(napi_env env, napi_value exports); static napi_value CreateCameraSession(napi_env env); + static napi_value CreateSecureSessionForTransfer(napi_env env, sptr secureCameraSession); SecureCameraSessionNapi(); ~SecureCameraSessionNapi(); diff --git a/interfaces/kits/js/camera_napi/include/mode/video_session_napi.h b/interfaces/kits/js/camera_napi/include/mode/video_session_napi.h index 17c398dd3..edb364395 100644 --- a/interfaces/kits/js/camera_napi/include/mode/video_session_napi.h +++ b/interfaces/kits/js/camera_napi/include/mode/video_session_napi.h @@ -27,6 +27,7 @@ class VideoSessionNapi : public CameraSessionNapi { public: static napi_value Init(napi_env env, napi_value exports); static napi_value CreateCameraSession(napi_env env); + static napi_value CreateVideoSessionForTransfer(napi_env env, sptr videoSession); VideoSessionNapi(); ~VideoSessionNapi(); diff --git a/interfaces/kits/js/camera_napi/include/output/metadata_output_napi.h b/interfaces/kits/js/camera_napi/include/output/metadata_output_napi.h index 45037fee0..9669d69fd 100644 --- a/interfaces/kits/js/camera_napi/include/output/metadata_output_napi.h +++ b/interfaces/kits/js/camera_napi/include/output/metadata_output_napi.h @@ -73,6 +73,7 @@ class MetadataOutputNapi : public CameraNapiEventEmitter { public: static napi_value Init(napi_env env, napi_value exports); static napi_value CreateMetadataOutput(napi_env env, std::vector metadataObjectTypes); + static napi_value CreateMetadataOutputForTransfer(napi_env env, sptr metadataOutput); static napi_value AddMetadataObjectTypes(napi_env env, napi_callback_info info); static napi_value RemoveMetadataObjectTypes(napi_env env, napi_callback_info info); MetadataOutputNapi(); diff --git a/interfaces/kits/js/camera_napi/include/output/photo_napi.h b/interfaces/kits/js/camera_napi/include/output/photo_napi.h index d5423bb52..0bae4fa87 100644 --- a/interfaces/kits/js/camera_napi/include/output/photo_napi.h +++ b/interfaces/kits/js/camera_napi/include/output/photo_napi.h @@ -34,6 +34,19 @@ public: static napi_value GetRaw(napi_env env, napi_callback_info info); static napi_value Release(napi_env env, napi_callback_info info); + napi_value GetMainForTransfer() + { + return mainImage_; + } + napi_value GetRawForTransfer() + { + return rawImage_; + } + napi_env GetEnv() + { + return env_; + } + private: static void PhotoNapiDestructor(napi_env env, void* nativeObject, void* finalize_hint); static napi_value PhotoNapiConstructor(napi_env env, napi_callback_info info); diff --git a/interfaces/kits/js/camera_napi/include/output/photo_output_napi.h b/interfaces/kits/js/camera_napi/include/output/photo_output_napi.h index 3a36248d1..a7f1f18a7 100644 --- a/interfaces/kits/js/camera_napi/include/output/photo_output_napi.h +++ b/interfaces/kits/js/camera_napi/include/output/photo_output_napi.h @@ -329,6 +329,7 @@ public: static napi_value Init(napi_env env, napi_value exports); static napi_value CreatePhotoOutput(napi_env env, Profile& profile, std::string surfaceId); static napi_value CreatePhotoOutput(napi_env env, std::string surfaceId); + static napi_value CreatePhotoOutputForTransfer(napi_env env, sptr photoOutput); static napi_value Capture(napi_env env, napi_callback_info info); static napi_value BurstCapture(napi_env env, napi_callback_info info); diff --git a/interfaces/kits/js/camera_napi/include/output/preview_output_napi.h b/interfaces/kits/js/camera_napi/include/output/preview_output_napi.h index ea86d6be4..d2307f761 100644 --- a/interfaces/kits/js/camera_napi/include/output/preview_output_napi.h +++ b/interfaces/kits/js/camera_napi/include/output/preview_output_napi.h @@ -96,6 +96,7 @@ public: static napi_value CreatePreviewOutput(napi_env env, Profile& profile, std::string surfaceId); static napi_value CreatePreviewOutput(napi_env env, std::string surfaceId); static napi_value CreateDeferredPreviewOutput(napi_env env, Profile& profile); + static napi_value CreatePreviewOutputForTransfer(napi_env env, sptr previewOutput); static bool IsPreviewOutput(napi_env env, napi_value obj); static napi_value AddDeferredSurface(napi_env env, napi_callback_info info); static napi_value Start(napi_env env, napi_callback_info info); diff --git a/interfaces/kits/js/camera_napi/include/output/video_output_napi.h b/interfaces/kits/js/camera_napi/include/output/video_output_napi.h index 8f8bb1139..bfe8e474e 100644 --- a/interfaces/kits/js/camera_napi/include/output/video_output_napi.h +++ b/interfaces/kits/js/camera_napi/include/output/video_output_napi.h @@ -87,6 +87,7 @@ public: static napi_value Init(napi_env env, napi_value exports); static napi_value CreateVideoOutput(napi_env env, VideoProfile& profile, std::string surfaceId); static napi_value CreateVideoOutput(napi_env env, std::string surfaceId); + static napi_value CreateVideoOutputForTransfer(napi_env env, sptr videoOutput); static bool IsVideoOutput(napi_env env, napi_value obj); static napi_value GetActiveProfile(napi_env env, napi_callback_info info); static napi_value SetFrameRate(napi_env env, napi_callback_info info); diff --git a/interfaces/kits/js/camera_napi/libcamera_napi.map b/interfaces/kits/js/camera_napi/libcamera_napi.map index 9e3803029..0785b332f 100644 --- a/interfaces/kits/js/camera_napi/libcamera_napi.map +++ b/interfaces/kits/js/camera_napi/libcamera_napi.map @@ -1,8 +1,28 @@ { global: + extern "C" { + GetCameraInputNapi; + GetNativeCameraInput; + GetPhotoSessionNapi; + GetNativePhotoSession; + GetSecureCameraSessionNapi; + GetNativeSecureCameraSession; + GetVideoSessionNapi; + GetNativeVideoSession; + GetMetadataOutputNapi; + GetNativeMetadataOutput; + GetPhotoNapi; + GetNativeImage; + GetPhotoOutputNapi; + GetNativePhotoOutput; + GetPreviewOutputNapi; + GetNativePreviewOutput; + GetVideoOutputNapi; + GetNativeVideoOutput + }; extern "C++" { OHOS::CameraStandard::Export*; }; local: *; -}; \ No newline at end of file +}; -- Gitee