From eaf33368599ad5fa06e7adbe31dece1bf5da31b3 Mon Sep 17 00:00:00 2001 From: xiangtongtong Date: Thu, 10 Jul 2025 11:36:19 +0800 Subject: [PATCH 1/4] privacy Signed-off-by: xiangtongtong --- .../avscreen_capture_napi.cpp | 54 ++- .../avscreen_capture/avscreen_capture_napi.h | 5 + frameworks/js/media/media_enum_napi.cpp | 1 + .../screen_capture_controller_impl.cpp | 16 + .../screen_capture_controller_impl.h | 1 + .../native/screen_capture_controller.h | 1 + services/BUILD.gn | 2 + services/etc/BUILD.gn | 14 + .../include/i_screen_capture_controller.h | 1 + .../screen_capture_controller_client.cpp | 10 + .../client/screen_capture_controller_client.h | 1 + .../i_standard_screen_capture_controller.h | 2 + .../ipc/screen_capture_controller_proxy.cpp | 23 ++ .../ipc/screen_capture_controller_proxy.h | 1 + .../ipc/screen_capture_controller_stub.cpp | 33 ++ .../ipc/screen_capture_controller_stub.h | 2 + .../screen_capture_controller_server.cpp | 7 + .../server/screen_capture_controller_server.h | 1 + .../server/screen_capture_server.cpp | 332 ++++++++++++++---- .../server/screen_capture_server.h | 26 +- 20 files changed, 470 insertions(+), 63 deletions(-) diff --git a/frameworks/js/avscreen_capture/avscreen_capture_napi.cpp b/frameworks/js/avscreen_capture/avscreen_capture_napi.cpp index bb20fac99..297c01dd6 100644 --- a/frameworks/js/avscreen_capture/avscreen_capture_napi.cpp +++ b/frameworks/js/avscreen_capture/avscreen_capture_napi.cpp @@ -20,6 +20,8 @@ #include "media_log.h" #ifndef CROSS_PLATFORM #include "display_manager.h" +#include "media_errors.h" +#include "recorder_napi_utils.h" #endif namespace { constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_SCREENCAPTURE, "AVScreenCaptureNapi"}; @@ -49,7 +51,9 @@ napi_value AVScreenCaptureNapi::Init(napi_env env, napi_value exports) { napi_property_descriptor staticProperty[] = { DECLARE_NAPI_STATIC_FUNCTION("createAVScreenCaptureRecorder", JsCreateAVScreenRecorder), - DECLARE_NAPI_STATIC_FUNCTION("reportAVScreenCaptureUserChoice", JsReportAVScreenCaptureUserChoice) + DECLARE_NAPI_STATIC_FUNCTION("reportAVScreenCaptureUserChoice", JsReportAVScreenCaptureUserChoice), + DECLARE_NAPI_STATIC_FUNCTION("getAVScreenCaptureConfigurableParameters", + JsGetAVScreenCaptureConfigurableParameters) }; napi_property_descriptor properties[] = { @@ -262,6 +266,54 @@ napi_value AVScreenCaptureNapi::JsReportAVScreenCaptureUserChoice(napi_env env, return result; } +napi_value AVScreenCaptureNapi::JsGetAVScreenCaptureConfigurableParameters(napi_env env, napi_callback_info info) +{ + MediaTrace trace("AVScreenCapture::JsGetAVScreenCaptureConfigurableParameters"); + const std::string &opt = AVScreenCapturegOpt::GET_CONFIG_PARAMS; + MEDIA_LOGI("Js %{public}s Start", opt.c_str()); + + const int32_t maxParam = 1; + size_t argCount = maxParam; + napi_value args[maxParam] = { nullptr }; + napi_value result = nullptr; + auto asyncCtx = std::make_unique(env); + CHECK_AND_RETURN_RET_LOG(asyncCtx != nullptr, result, "failed to get AsyncContext"); + napi_value jsThis = nullptr; + napi_status status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr); + CHECK_AND_RETURN_RET_LOG(status == napi_ok && jsThis != nullptr, nullptr, "failed to napi_get_cb_info"); + MEDIA_LOGI("argCount %{public}zu", argCount); + if (argCount < maxParam) { + CommonNapi::ThrowError(env, MSERR_EXT_API9_PERMISSION_DENIED, "parameter missing"); + } + napi_valuetype valueType = napi_undefined; + if (napi_typeof(env, args[0], &valueType) != napi_ok || valueType != napi_number) { + CommonNapi::ThrowError(env, MSERR_EXT_API9_PERMISSION_DENIED, "invalid parameter type"); + } + int32_t sessionId; + status = napi_get_value_int32(env, args[0], &sessionId); + if (status != napi_ok) { + CommonNapi::ThrowError(env, MSERR_EXT_API9_PERMISSION_DENIED, "invalid parameter type"); + } + if (!SystemPermission()) { + CommonNapi::ThrowError(env, MSERR_EXT_API9_PERMISSION_DENIED, "permission denied"); + } + std::string resultStr = ""; + asyncCtx->controller_ = ScreenCaptureControllerFactory::CreateScreenCaptureController(); + if (asyncCtx->controller_ == nullptr) { + CommonNapi::ThrowError(env, MSERR_EXT_API9_PERMISSION_DENIED, "failed to create controller"); + } + int32_t res = asyncCtx->controller_->GetAVScreenCaptureConfigurableParameters(sessionId, resultStr); + if (res != MSERR_OK) { + CommonNapi::ThrowError(env, MSERR_EXT_API20_SESSION_NOT_EXIST, "session dose not exist."); + } + napi_create_string_utf8(env, resultStr.c_str(), NAPI_AUTO_LENGTH, &result); + napi_value resource = nullptr; + napi_create_string_utf8(env, opt.c_str(), NAPI_AUTO_LENGTH, &resource); + asyncCtx.release(); + MEDIA_LOGI("Js %{public}s End", opt.c_str()); + return result; +} + void AVScreenCaptureNapi::AsyncJsReportAVScreenCaptureUserChoice(napi_env env, void* data) { AVScreenCaptureAsyncContext* asyncCtx = reinterpret_cast(data); diff --git a/frameworks/js/avscreen_capture/avscreen_capture_napi.h b/frameworks/js/avscreen_capture/avscreen_capture_napi.h index a4d0077c1..a7b68e999 100644 --- a/frameworks/js/avscreen_capture/avscreen_capture_napi.h +++ b/frameworks/js/avscreen_capture/avscreen_capture_napi.h @@ -29,6 +29,7 @@ namespace Media { namespace AVScreenCapturegOpt { const std::string INIT = "Init"; const std::string REPORT_USER_CHOICE = "ReportAVScreenCaptureUserChoice"; +const std::string GET_CONFIG_PARAMS = "GetAVScreenCaptureConfigurableParameters"; const std::string START_RECORDING = "StartRecording"; const std::string STOP_RECORDING = "StopRecording"; const std::string SKIP_PRIVACY_MODE = "SkipPrivacyMode"; @@ -75,6 +76,10 @@ private: * reportAVScreenCaptureUserChoice(sessionId: number, choice: string): Promise */ static napi_value JsReportAVScreenCaptureUserChoice(napi_env env, napi_callback_info info); + /** + * getAVScreenCaptureConfigurableParameters(sessionId: number): Promise + */ + static napi_value JsGetAVScreenCaptureConfigurableParameters(napi_env env, napi_callback_info info); /** * init(config: AVScreenCaptureRecordConfig): Promise */ diff --git a/frameworks/js/media/media_enum_napi.cpp b/frameworks/js/media/media_enum_napi.cpp index d7356a6b0..a9b053937 100644 --- a/frameworks/js/media/media_enum_napi.cpp +++ b/frameworks/js/media/media_enum_napi.cpp @@ -88,6 +88,7 @@ static const std::vector g_AVErrorCode = { { "AVERR_SUPER_RESOLUTION_UNSUPPORTED", MediaServiceExtErrCodeAPI9::MSERR_EXT_API16_SUPER_RESOLUTION_UNSUPPORTED }, { "AVERR_SUPER_RESOLUTION_NOT_ENABLED", MediaServiceExtErrCodeAPI9::MSERR_EXT_API16_SUPER_RESOLUTION_NOT_ENABLED }, { "AVERR_IO_CLEARTEXT_NOT_PERMITTED", MediaServiceExtErrCodeAPI9::MSERR_EXT_API20_IO_CLEARTEXT_NOT_PERMITTED }, + { "AVERR_SESSION_NOT_EXIST", MediaServiceExtErrCodeAPI9::MSERR_EXT_API20_SESSION_NOT_EXIST}, { "AVERR_PARAMETER_OUT_OF_RANGE", MediaServiceExtErrCodeAPI9::MSERR_EXT_API20_PARAM_ERROR_OUT_OF_RANGE }, }; diff --git a/frameworks/native/screen_capture/screen_capture_controller_impl.cpp b/frameworks/native/screen_capture/screen_capture_controller_impl.cpp index 435545dda..13d81e849 100644 --- a/frameworks/native/screen_capture/screen_capture_controller_impl.cpp +++ b/frameworks/native/screen_capture/screen_capture_controller_impl.cpp @@ -45,6 +45,22 @@ void ScreenCaptureControllerImpl::ReportAVScreenCaptureUserChoice(int32_t sessio controllerClient = nullptr; } +int32_t ScreenCaptureControllerImpl::GetAVScreenCaptureConfigurableParameters( + int32_t sessionId, std::string &resultStr) +{ + MEDIA_LOGI("ScreenCaptureController::GetAVScreenCaptureConfigurableParameters start"); + std::shared_ptr controllerClient = + MediaServiceFactory::GetInstance().CreateScreenCaptureControllerClient(); + CHECK_AND_RETURN_LOG(controllerClient != nullptr, MSREE_UNKNOWN, + "failed to CreateScreenCaptureControllerClient"); + int32_t ret = controllerClient->GetAVScreenCaptureConfigurableParameters(sessionId, resultStr); + MEDIA_LOGI("ScreenCaptureController::GetAVScreenCaptureConfigurableParameters Report result: %{public}d", ret); + + (void)MediaServiceFactory::GetInstance().DestroyScreenCaptureControllerClient(controllerClient); + controllerClient = nullptr; + return ret; +} + ScreenCaptureControllerImpl::ScreenCaptureControllerImpl() { MEDIA_LOGD("ScreenCaptureControllerImpl:0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this)); diff --git a/frameworks/native/screen_capture/screen_capture_controller_impl.h b/frameworks/native/screen_capture/screen_capture_controller_impl.h index d268f128f..b113d01bd 100644 --- a/frameworks/native/screen_capture/screen_capture_controller_impl.h +++ b/frameworks/native/screen_capture/screen_capture_controller_impl.h @@ -24,6 +24,7 @@ namespace Media { class ScreenCaptureControllerImpl : public ScreenCaptureController, public NoCopyable { public: void ReportAVScreenCaptureUserChoice(int32_t sessionId, std::string choice) override; + int32_t GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr) override; ScreenCaptureControllerImpl(); ~ScreenCaptureControllerImpl(); }; diff --git a/interfaces/inner_api/native/screen_capture_controller.h b/interfaces/inner_api/native/screen_capture_controller.h index c783680ff..ddccacc65 100644 --- a/interfaces/inner_api/native/screen_capture_controller.h +++ b/interfaces/inner_api/native/screen_capture_controller.h @@ -26,6 +26,7 @@ namespace Media { class ScreenCaptureController { public: virtual void ReportAVScreenCaptureUserChoice(int32_t sessionId, std::string choice) = 0; + virtual int32_t GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr) = 0; virtual ~ScreenCaptureController() = default; }; diff --git a/services/BUILD.gn b/services/BUILD.gn index 9177cb746..8ebbe68dd 100644 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -33,6 +33,8 @@ group("media_services_package") { "etc:screen_capture_notification_image", "etc:screen_capture_stop_dark_image", "etc:screen_capture_stop_image", + "etc:screen_capture_capsule_stop_live2_image", + "etc:screen_capture_light_image", ] } if (player_framework_support_screen_capture) { diff --git a/services/etc/BUILD.gn b/services/etc/BUILD.gn index 7ec625a2b..8939783ba 100644 --- a/services/etc/BUILD.gn +++ b/services/etc/BUILD.gn @@ -106,3 +106,17 @@ ohos_prebuilt_etc("screencapture_config_dac") { part_name = "player_framework" module_install_dir = "etc/param" } + +ohos_prebuilt_etc("screen_capture_capsule_stop_live2_image") { + source = "image/capsult_stop_live2.svg" + subsystem_name = "multimedia" + relative_install_dir = "screencapture" + part_name = "player_framework" +} + +ohos_prebuilt_etc("screen_capture_light_image") { + source = "image/light.svg" + subsystem_name = "multimedia" + relative_install_dir = "screencapture" + part_name = "player_framework" +} \ No newline at end of file diff --git a/services/include/i_screen_capture_controller.h b/services/include/i_screen_capture_controller.h index 143a45691..61da8b6f1 100644 --- a/services/include/i_screen_capture_controller.h +++ b/services/include/i_screen_capture_controller.h @@ -24,6 +24,7 @@ namespace Media { class IScreenCaptureController { public: virtual int32_t ReportAVScreenCaptureUserChoice(int32_t sessionId, std::string choice) = 0; + virtual int32_t GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr) = 0; }; } // namespace Media } // namespace OHOS diff --git a/services/services/screen_capture/client/screen_capture_controller_client.cpp b/services/services/screen_capture/client/screen_capture_controller_client.cpp index 358ae4b9d..de952d6dd 100644 --- a/services/services/screen_capture/client/screen_capture_controller_client.cpp +++ b/services/services/screen_capture/client/screen_capture_controller_client.cpp @@ -65,5 +65,15 @@ int32_t ScreenCaptureControllerClient::ReportAVScreenCaptureUserChoice(int32_t s return screenCaptureControllerProxy_->ReportAVScreenCaptureUserChoice(sessionId, choice); } +int32_t ScreenCaptureControllerClient::GetAVScreenCaptureConfigurableParameters(int32_t sessionId, + std::string &resultStr) +{ + MEDIA_LOGI("ScreenCaptureControllerClient::GetAVScreenCaptureConfigurableParameters start"); + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG(screenCaptureControllerProxy_ != nullptr, + MSERR_SERVICE_DIED, "proxy does not exist."); + return screenCaptureControllerProxy_->GetAVScreenCaptureConfigurableParameters(sessionId, resultStr); +} + } // namespace Media } // namespace OHOS \ No newline at end of file diff --git a/services/services/screen_capture/client/screen_capture_controller_client.h b/services/services/screen_capture/client/screen_capture_controller_client.h index 01666a157..b2e7c00b8 100644 --- a/services/services/screen_capture/client/screen_capture_controller_client.h +++ b/services/services/screen_capture/client/screen_capture_controller_client.h @@ -31,6 +31,7 @@ public: // ScreenCaptureControllerClient void MediaServerDied(); int32_t ReportAVScreenCaptureUserChoice(int32_t sessionId, std::string choice) override; + int32_t GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr) override; private: sptr screenCaptureControllerProxy_ = nullptr; diff --git a/services/services/screen_capture/ipc/i_standard_screen_capture_controller.h b/services/services/screen_capture/ipc/i_standard_screen_capture_controller.h index d2c4ca2e3..2febd600f 100644 --- a/services/services/screen_capture/ipc/i_standard_screen_capture_controller.h +++ b/services/services/screen_capture/ipc/i_standard_screen_capture_controller.h @@ -31,6 +31,7 @@ class IStandardScreenCaptureController : public IRemoteBroker { public: virtual ~IStandardScreenCaptureController() = default; virtual int32_t ReportAVScreenCaptureUserChoice(int32_t sessionId, std::string choice) = 0; + virtual int32_t GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr) = 0; virtual int32_t DestroyStub() = 0; /** @@ -38,6 +39,7 @@ public: */ enum ScreenCaptureControllerMsg { REPORT_USER_CHOICE, + GET_CONFIG_PARAM, DESTROY, }; diff --git a/services/services/screen_capture/ipc/screen_capture_controller_proxy.cpp b/services/services/screen_capture/ipc/screen_capture_controller_proxy.cpp index bd2069005..60f697986 100644 --- a/services/services/screen_capture/ipc/screen_capture_controller_proxy.cpp +++ b/services/services/screen_capture/ipc/screen_capture_controller_proxy.cpp @@ -75,6 +75,29 @@ int32_t ScreenCaptureControllerProxy::ReportAVScreenCaptureUserChoice(int32_t se return reply.ReadInt32(); } +int32_t ScreenCaptureControllerProxy::GetAVScreenCaptureConfigurableParameters(int32_t sessionId, + std::string &resultStr) +{ + MEDIA_LOGI("ScreenCaptureControllerProxy::GetAVScreenCaptureConfigurableParameters start"); + MessageParcel data; + MessageParcel reply; + MessageOption option; + + bool token = data.WriteInterfaceToken(ScreenCaptureControllerProxy::GetDescriptor()); + CHECK_AND_RETURN_RET_LOG(token, MSERR_INVALID_OPERATION, "Failed to write descriptor!"); + + token = data.WriteInt32(sessionId); + CHECK_AND_RETURN_RET_LOG(token, MSERR_INVALID_OPERATION, "Failed to write sessionId!"); + + int error = Remote()->SendRequest(GET_CONFIG_PARAM, data, reply, option); + CHECK_AND_RETURN_RET_LOG(error == MSERR_OK, MSERR_INVALID_OPERATION, + "GetAVScreenCaptureConfigurableParameters failed, error: %{public}d", error); + int ret = reply.ReadInt32(); + if (ret == MSERR_OK) { + resultStr = reply.ReadString(); + } + return ret; +} } // namespace Media } // namespace OHOS \ No newline at end of file diff --git a/services/services/screen_capture/ipc/screen_capture_controller_proxy.h b/services/services/screen_capture/ipc/screen_capture_controller_proxy.h index 1e40661aa..95db35349 100644 --- a/services/services/screen_capture/ipc/screen_capture_controller_proxy.h +++ b/services/services/screen_capture/ipc/screen_capture_controller_proxy.h @@ -26,6 +26,7 @@ public: virtual ~ScreenCaptureControllerProxy(); int32_t ReportAVScreenCaptureUserChoice(int32_t sessionId, std::string choice) override; + int32_t GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr) override; int32_t DestroyStub() override; private: diff --git a/services/services/screen_capture/ipc/screen_capture_controller_stub.cpp b/services/services/screen_capture/ipc/screen_capture_controller_stub.cpp index b8b754e2c..83c937b70 100644 --- a/services/services/screen_capture/ipc/screen_capture_controller_stub.cpp +++ b/services/services/screen_capture/ipc/screen_capture_controller_stub.cpp @@ -57,6 +57,8 @@ int32_t ScreenCaptureControllerStub::Init() "failed to create screenCaptureControllerServer Service"); screenCaptureControllerStubFuncs_[REPORT_USER_CHOICE] = &ScreenCaptureControllerStub::ReportAVScreenCaptureUserChoice; + screenCaptureControllerStubFuncs_[GET_CONFIG_PARAM] = + &ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters; screenCaptureControllerStubFuncs_[DESTROY] = &ScreenCaptureControllerStub::DestroyStub; return MSERR_OK; @@ -131,6 +133,37 @@ int32_t ScreenCaptureControllerStub::ReportAVScreenCaptureUserChoice(MessageParc return MSERR_OK; } +int32_t ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr) +{ + MEDIA_LOGI("ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters start 2"); + CHECK_AND_RETURN_RET_LOG(screenCaptureControllerServer_ != nullptr, false, + "screen capture controller server is nullptr"); + int32_t appUid = IPCSkeleton::GetCallingUid(); + std::string appName = GetClientBundleName(appUid); + if (GetScreenCaptureSystemParam()["const.multimedia.screencapture.screenrecorderbundlename"] + .compare(appName) != 0) { + MEDIA_LOGE("ScreenCaptureControllerStub called by app name %{public}s", appName.c_str()); + return MSERR_INVALID_OPERATION; + } + return screenCaptureControllerServer_->GetAVScreenCaptureConfigurableParameters(sessionId, resultStr); +} + +int32_t ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters(MessageParcel &data, MessageParcel &reply) +{ + MEDIA_LOGI("ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters start 1"); + CHECK_AND_RETURN_RET_LOG(screenCaptureControllerServer_ != nullptr, MSERR_INVALID_STATE, + "screen capture controller server is nullptr"); + (void)data; + int32_t sessionId = data.ReadInt32(); + std::string resultStr; + int32_t ret = GetAVScreenCaptureConfigurableParameters(sessionId, resultStr); + MEDIA_LOGI("ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters start 1 resultStr: %{public}s", + resultStr.c_str()); + reply.WriteInt32(ret); + reply.WriteString(resultStr); + return MSERR_OK; +} + } // namespace Media } // namespace OHOS \ No newline at end of file diff --git a/services/services/screen_capture/ipc/screen_capture_controller_stub.h b/services/services/screen_capture/ipc/screen_capture_controller_stub.h index c06dbcfbf..3e88e4ac5 100644 --- a/services/services/screen_capture/ipc/screen_capture_controller_stub.h +++ b/services/services/screen_capture/ipc/screen_capture_controller_stub.h @@ -29,6 +29,7 @@ public: virtual ~ScreenCaptureControllerStub(); int32_t ReportAVScreenCaptureUserChoice(int32_t sessionId, std::string choice) override; + int32_t GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr) override; int32_t DestroyStub() override; int OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override; @@ -36,6 +37,7 @@ private: ScreenCaptureControllerStub(); int32_t Init(); int32_t ReportAVScreenCaptureUserChoice(MessageParcel &data, MessageParcel &reply); + int32_t GetAVScreenCaptureConfigurableParameters(MessageParcel &data, MessageParcel &reply); int32_t DestroyStub(MessageParcel &data, MessageParcel &reply); std::mutex mutex_; diff --git a/services/services/screen_capture/server/screen_capture_controller_server.cpp b/services/services/screen_capture/server/screen_capture_controller_server.cpp index 88c0cf17e..a119f65bf 100644 --- a/services/services/screen_capture/server/screen_capture_controller_server.cpp +++ b/services/services/screen_capture/server/screen_capture_controller_server.cpp @@ -56,5 +56,12 @@ int32_t ScreenCaptureControllerServer::ReportAVScreenCaptureUserChoice(int32_t s return ret; } +int32_t ScreenCaptureControllerServer::GetAVScreenCaptureConfigurableParameters(int32_t sessionId, + std::string &resultStr) +{ + MEDIA_LOGI("ScreenCaptureControllerServer::GetAVScreenCaptureConfigurableParameters start"); + int32_t ret = ScreenCaptureServer::GetAVScreenCaptureConfigurableParameters(sessionId, resultStr); + return ret; +} } // namespace Media } // namespace OHOS \ No newline at end of file diff --git a/services/services/screen_capture/server/screen_capture_controller_server.h b/services/services/screen_capture/server/screen_capture_controller_server.h index bda62db6e..fc5c2fa21 100644 --- a/services/services/screen_capture/server/screen_capture_controller_server.h +++ b/services/services/screen_capture/server/screen_capture_controller_server.h @@ -34,6 +34,7 @@ public: ~ScreenCaptureControllerServer(); int32_t ReportAVScreenCaptureUserChoice(int32_t sessionId, std::string choice) override; + int32_t GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr) override; }; } // namespace Media diff --git a/services/services/screen_capture/server/screen_capture_server.cpp b/services/services/screen_capture/server/screen_capture_server.cpp index 36ab6e3d1..dd8ad2a71 100644 --- a/services/services/screen_capture/server/screen_capture_server.cpp +++ b/services/services/screen_capture/server/screen_capture_server.cpp @@ -45,6 +45,8 @@ #include #include "session_manager_lite.h" #include "window_manager_lite.h" +#include "want_agent_info.h" +#include "want_agent_helper.h" #ifdef PC_STANDARD #include #endif @@ -65,9 +67,11 @@ static const std::string M4A = "m4a"; static const std::string USER_CHOICE_ALLOW = "true"; static const std::string USER_CHOICE_DENY = "false"; static const std::string CHECK_BOX_SELECTED = "true"; +static const std::string JSON_VALUE_TRUE = "true"; static const std::string BUTTON_NAME_MIC = "mic"; static const std::string BUTTON_NAME_STOP = "stop"; static const std::string ICON_PATH_CAPSULE_STOP = "/etc/screencapture/capsule_stop.svg"; +static const std::string ICON_PATH_CAPSULE_STOP_2_0 = "/etc/screencapture/capsule_stop.svg"; static const std::string ICON_PATH_NOTIFICATION = "/etc/screencapture/notification.png"; static const std::string ICON_PATH_MIC = "/etc/screencapture/mic.svg"; static const std::string ICON_PATH_MIC_OFF = "/etc/screencapture/mic_off.svg"; @@ -830,23 +834,26 @@ void ScreenCaptureServer::GetChoiceFromJson(Json::Value &root, } } -void ScreenCaptureServer::GetBoxSelectedFromJson(Json::Value &root, - const std::string &content, std::string key, bool &checkBoxSelected) +void ScreenCaptureServer::GetValueFromJson(Json::Value &root, + const std::string &content, std::string key, bool &value) { + value = false; + Json::Reader reader; bool parsingSuccessful = reader.parse(content, root); - checkBoxSelected = false; if (!parsingSuccessful || root.type() != Json::objectValue) { MEDIA_LOGE("Error parsing the string"); return; } const Json::Value keyJson = root[key]; if (!keyJson.isNull() && keyJson.isString()) { - if (CHECK_BOX_SELECTED.compare(keyJson.asString()) == 0) { - checkBoxSelected = true; + if (JSON_VALUE_TRUE.compare(keyJson.asString()) == 0) { + value = true; + } else { + value = false; } } - MEDIA_LOGI("GetBoxSelectedFromJson checkBoxSelected: %{public}d", checkBoxSelected); + MEDIA_LOGI("GetValueFromJson value: %{public}d", value); } void ScreenCaptureServer::SetCaptureConfig(CaptureMode captureMode, int32_t missionId) @@ -891,39 +898,85 @@ int32_t ScreenCaptureServer::ReportAVScreenCaptureUserChoice(int32_t sessionId, std::shared_ptr server = GetScreenCaptureServerByIdWithLock(sessionId); CHECK_AND_RETURN_RET_LOG(server != nullptr, MSERR_UNKNOWN, "ReportAVScreenCaptureUserChoice failed to get instance, sessionId: %{public}d", sessionId); + Json::Value root; if (server->captureState_ == AVScreenCaptureState::POPUP_WINDOW) { - MEDIA_LOGI("ReportAVScreenCaptureUserChoice captureState is %{public}d", AVScreenCaptureState::POPUP_WINDOW); - Json::Value root; - std::string choice = "false"; - GetChoiceFromJson(root, content, std::string("choice"), choice); - - GetBoxSelectedFromJson(root, content, std::string("checkBoxSelected"), server->checkBoxSelected_); - MEDIA_LOGI("ReportAVScreenCaptureUserChoice checkBoxSelected: %{public}d", server->checkBoxSelected_); + return server->HandlePopupWindowCase(root, content, server); + } else if (server->GetSCServerDataType() == DataType::ORIGINAL_STREAM && + server->captureState_ == AVScreenCaptureState::STARTED) { + return server->HandleStreamDataCase(root, content, server); + } + return MSERR_UNKNOWN; +} - if (server->showShareSystemAudioBox_) { - GetBoxSelectedFromJson(root, content, std::string("isInnerAudioBoxSelected"), - server->isInnerAudioBoxSelected_); - } - MEDIA_LOGI("ReportAVScreenCaptureUserChoice showShareSystemAudioBox:%{public}d," - "isInnerAudioBoxSelected:%{public}d", server->showShareSystemAudioBox_, - server->isInnerAudioBoxSelected_); - - if (USER_CHOICE_ALLOW.compare(choice) == 0) { - PrepareSelectWindow(root, server); - int32_t ret = server->OnReceiveUserPrivacyAuthority(true); - CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, - "ReportAVScreenCaptureUserChoice user choice is true but start failed"); - MEDIA_LOGI("ReportAVScreenCaptureUserChoice user choice is true and start success"); - return MSERR_OK; - } else if (USER_CHOICE_DENY.compare(choice) == 0) { - return server->OnReceiveUserPrivacyAuthority(false); - } else { - MEDIA_LOGW("ReportAVScreenCaptureUserChoice user choice is not support"); - } +int32_t ScreenCaptureServer::HandlePopupWindowCase(Json::Value& root, const std::string &content, + std::shared_ptr& server) +{ + MEDIA_LOGI("ReportAVScreenCaptureUserChoice captureState is %{public}d", AVScreenCaptureState::POPUP_WINDOW); + std::string choice = "false"; + GetChoiceFromJson(root, content, std::string("choice"), choice); + GetValueFromJson(root, content, std::string("checkBoxSelected"), server->checkBoxSelected_); + + server->systemPrivacyProtectionSwitch_ = server->checkBoxSelected_; + server->appPrivacyProtectionSwitch_ = server->checkBoxSelected_; + MEDIA_LOGI("ReportAVScreenCaptureUserChoice checkBoxSelected: %{public}d", server->checkBoxSelected_); + + if (USER_CHOICE_ALLOW.compare(choice) == 0) { + PrepareSelectWindow(root, server); + int32_t ret = server->OnReceiveUserPrivacyAuthority(true); + CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, + "ReportAVScreenCaptureUserChoice user choice is true but start failed"); + MEDIA_LOGI("ReportAVScreenCaptureUserChoice user choice is true and start success"); + return MSERR_OK; + } else if (USER_CHOICE_DENY.compare(choice) == 0) { + return server->OnReceiveUserPrivacyAuthority(false); + } else { + MEDIA_LOGW("ReportAVScreenCaptureUserChoice user choice is not support"); } return MSERR_UNKNOWN; } +int32_t ScreenCaptureServer::HandleStreamDataCase(Json::Value& root, const std::string &content, + std::shared_ptr& server) +{ + bool stopRecord = false; + GetValueFromJson(root, content, std::string("stopRecording"), stopRecord); + if (stopRecord) { + server->StopScreenCaptureInner(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INVLID); + MEDIA_LOGI("ReportAVScreenCaptureUserChoice user stop record"); + return MSERR_OK; + } + + GetValueFromJson(root, content, std::string("appPrivacyProtectionSwitch"), + server->appPrivacyProtectionSwitch_); + GetValueFromJson(root, content, std::string("systemPrivacyProtectionSwitch"), + server->systemPrivacyProtectionSwitch_); + + server->SystemPrivacyProtected(server->virtualScreenId_, server->systemPrivacyProtectionSwitch_); + server->AppPrivacyProtected(server->virtualScreenId_, server->appPrivacyProtectionSwitch_); + + std::lock_guard lock(server->mutex_); + NotificationRequest request; + server->SetPublishRequest(server->GetLocalLiveViewContent(), server->notificationId_, request); + request.SetWantAgent(server->GetWantAgent(server->callingLabel_, server->sessionId_)); + return NotificationHelper::PublishNotification(request); +} + +int32_t ScreenCaptureServer::GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr) +{ + MEDIA_LOGI("GetAVScreenCaptureConfigurableParameters sessionId :%{public}d", + sessionId); + std::shared_ptr server = GetScreenCaptureServerByIdWithLock(sessionId); + CHECK_AND_RETURN_RET_LOG(server != nullptr, MSERR_UNKNOWN, + "GetAVScreenCaptureConfigurableParameters failed to get instance, sessionId: %{public}d", sessionId); + Json::Value root; + root["appPrivacyProtectionSwitch"] = server->appPrivacyProtectionSwitch_; + root["systemPrivacyProtectionSwitch"] = server->systemPrivacyProtectionSwitch_; + Json::FastWriter fastWriter; + resultStr = fastWriter.write(root); + MEDIA_LOGI("GetAVScreenCaptureConfigurableParameters res: %{public}s", resultStr.c_str()); + return MSERR_OK; +} + int32_t ScreenCaptureServer::GetAppPid() { return appInfo_.appPid; @@ -2377,6 +2430,11 @@ int32_t ScreenCaptureServer::StartNotification() request.SetRemoveAllowed(false); request.SetInProgress(true); + if (GetSCServerDataType() == DataType::ORIGINAL_STREAM) { + auto wantAgent = GetWantAgent(callingLabel_, sessionId_); + request.SetWantAgent(wantAgent); + } + MEDIA_LOGI("StartNotification, setWantAgent success"); std::shared_ptr pixelMapTotalSpr = GetPixelMap(ICON_PATH_NOTIFICATION); request.SetLittleIcon(pixelMapTotalSpr); request.SetBadgeIconStyle(NotificationRequest::BadgeStyle::LITTLE); @@ -2391,8 +2449,10 @@ std::string ScreenCaptureServer::GetStringByResourceName(const char* name) { std::string resourceContext; CHECK_AND_RETURN_RET_LOG(resourceManager_ != nullptr, resourceContext, "resourceManager is null"); - if (strcmp(name, NOTIFICATION_SCREEN_RECORDING_TITLE_ID) == 0) { - resourceManager_->GetStringByName(NOTIFICATION_SCREEN_RECORDING_TITLE_ID, resourceContext); + if (strcmp(name, NOTIFICATION_SCREEN_RECORDING_TITLE_ID) == 0 || + strcmp(name, NOTIFICATION_SCREEN_RECORDING_PRIVACY_ON_ID) == 0 || + strcmp(name, NOTIFICATION_SCREEN_RECORDING_PRIVACY_OFF_ID) == 0) { + resourceManager_->GetStringByName(name, resourceContext); MEDIA_LOGD("get NOTIFICATION_SCREEN_RECORDING_TITLE_ID: %{public}s", resourceContext.c_str()); } else { MEDIA_LOGE("resource name is error."); @@ -2442,26 +2502,30 @@ std::shared_ptr ScreenCaptureServer::GetLocalL liveViewText_ = recordingScreenTitleStr; } MEDIA_LOGD("GetLocalLiveViewContent liveViewText: %{public}s", liveViewText_.c_str()); - localLiveViewContent->SetText(liveViewText_); auto capsule = NotificationCapsule(); - capsule.SetBackgroundColor(BACK_GROUND_COLOR); - capsulePxSize_ = static_cast(capsuleVpSize_ * density_); - std::shared_ptr pixelMapCapSpr = GetPixelMapSvg(ICON_PATH_CAPSULE_STOP, capsulePxSize_, capsulePxSize_); - capsule.SetIcon(pixelMapCapSpr); + SetupCapsule(capsule); + if (GetSCServerDataType() == DataType::ORIGINAL_STREAM) { + localLiveViewContent->SetTitle(liveViewText_); + if (!systemPrivacyProtectionSwitch_ && !appPrivacyProtectionSwitch_) { + liveViewSubText_ = GetStringByResourceName(NOTIFICATION_SCREEN_RECORDING_PRIVACY_OFF_ID); + } else { + liveViewSubText_ = GetStringByResourceName(NOTIFICATION_SCREEN_RECORDING_PRIVACY_ON_ID); + } + localLiveViewContent->SetText(liveViewSubText_); + MEDIA_LOGI("GetLocalLiveViewContentc additionalText: %{public}s", liveViewSubText_.c_str()); + capsule.SetTitle(callingLabel_); + } else { + localLiveViewContent->SetText(liveViewText_); + auto countTime = CreateCountTime(); + countTime.SetInitialTime(1); + localLiveViewContent->SetTime(countTime); + localLiveViewContent->addFlag(NotificationLocalLiveViewContent::LiveViewContentInner::TIME); + } localLiveViewContent->SetCapsule(capsule); localLiveViewContent->addFlag(NotificationLocalLiveViewContent::LiveViewContentInner::CAPSULE); - auto countTime = NotificationTime(); - countTime.SetInitialTime(1); - countTime.SetIsCountDown(false); - countTime.SetIsPaused(false); - countTime.SetIsInTitle(true); - - localLiveViewContent->SetTime(countTime); - localLiveViewContent->addFlag(NotificationLocalLiveViewContent::LiveViewContentInner::TIME); - auto basicButton = NotificationLocalLiveViewButton(); basicButton.addSingleButtonName(BUTTON_NAME_STOP); std::shared_ptr pixelMapStopSpr = GetPixelMap(ICON_PATH_STOP); @@ -2472,6 +2536,20 @@ std::shared_ptr ScreenCaptureServer::GetLocalL return localLiveViewContent; } +void ScreenCaptureServer::SetupCapsule(NotificationCapsule& capsule) +{ + capsule.SetBackgroundColor(BACK_GROUND_COLOR); + capsulePxSize_ = static_cast(capsuleVpSize_ * density_); + + std::shared_ptr pixelMapCapSpr; + if (isSystemUI2_) { + pixelMapCapSpr = GetPixelMapSvg(ICON_PATH_CAPSULE_STOP_2_0, capsulePxSize_, capsulePxSize_); + } else { + pixelMapCapSpr = GetPixelMapSvg(ICON_PATH_CAPSULE_STOP, capsulePxSize_, capsulePxSize_); + } + capsule.SetIcon(pixelMapCapSpr); +} + std::shared_ptr ScreenCaptureServer::GetPixelMap(std::string path) { uint32_t errorCode = 0; @@ -2518,7 +2596,12 @@ void ScreenCaptureServer::UpdateMicrophoneEnabled() request.SetUnremovable(true); request.SetInProgress(true); - std::shared_ptr pixelMapTotalSpr = GetPixelMap(ICON_PATH_CAPSULE_STOP); + std::shared_ptr pixelMapTotalSpr; + if (isSystemUI2_) { + pixelMapTotalSpr = GetPixelMap(ICON_PATH_CAPSULE_STOP_2_0); + } else { + pixelMapTotalSpr = GetPixelMap(ICON_PATH_CAPSULE_STOP); + } request.SetLittleIcon(pixelMapTotalSpr); request.SetBadgeIconStyle(NotificationRequest::BadgeStyle::LITTLE); @@ -2531,24 +2614,31 @@ void ScreenCaptureServer::UpdateMicrophoneEnabled() void ScreenCaptureServer::UpdateLiveViewContent() { localLiveViewContent_->SetType(1); - localLiveViewContent_->SetText(liveViewText_); auto capsule = NotificationCapsule(); capsule.SetBackgroundColor(BACK_GROUND_COLOR); - std::shared_ptr pixelMapCapSpr = GetPixelMap(ICON_PATH_CAPSULE_STOP); + std::shared_ptr pixelMapCapSpr; + if (isSystemUI2_) { + pixelMapCapSpr = GetPixelMap(ICON_PATH_CAPSULE_STOP_2_0); + } else { + pixelMapCapSpr = GetPixelMap(ICON_PATH_CAPSULE_STOP); + } capsule.SetIcon(pixelMapCapSpr); + if (GetSCServerDataType() == DataType::ORIGINAL_STREAM) { + localLiveViewContent_->SetTitle(liveViewText_); + localLiveViewContent_->SetText(liveViewSubText_); + capsule.SetTitle(callingLabel_); + } else { + localLiveViewContent_->SetText(liveViewText_); + auto countTime = CreateCountTime(); + + localLiveViewContent_->SetTime(countTime); + localLiveViewContent_->addFlag(NotificationLocalLiveViewContent::LiveViewContentInner::TIME); + } localLiveViewContent_->SetCapsule(capsule); localLiveViewContent_->addFlag(NotificationLocalLiveViewContent::LiveViewContentInner::CAPSULE); - auto countTime = NotificationTime(); - countTime.SetIsCountDown(false); - countTime.SetIsPaused(false); - countTime.SetIsInTitle(true); - - localLiveViewContent_->SetTime(countTime); - localLiveViewContent_->addFlag(NotificationLocalLiveViewContent::LiveViewContentInner::TIME); - auto basicButton = NotificationLocalLiveViewButton(); basicButton.addSingleButtonName(BUTTON_NAME_MIC); if (micCount_.load() % MICROPHONE_STATE_COUNT == MICROPHONE_OFF) { @@ -2567,6 +2657,29 @@ void ScreenCaptureServer::UpdateLiveViewContent() localLiveViewContent_->addFlag(NotificationLocalLiveViewContent::LiveViewContentInner::BUTTON); } +NotificationTime ScreenCaptureServer::CreateCountTime() +{ + auto countTime = NotificationTime(); + countTime.SetIsCountDown(false); + countTime.SetIsPaused(false); + countTime.SetIsInTitle(true); + return countTime; +} + +void ScreenCaptureServer::GetSystemUIFlag() +{ + const std::string dumpTag = "persist.systemui.live2"; + std::string systemUI2; + int32_t systemUIRes = OHOS::system::GetStringParameter(dumpTag, systemUI2, "false"); + if (systemUIRes != 0) { + MEDIA_LOGI("Failed to get systemUI flag, Res: %{public}d", systemUIRes); + isSystemUI2_ = false; + } else { + isSystemUI2_ = (systemUI2 == "true"); + MEDIA_LOGI("get systemUI flag, Res: %{public}d, isSystemUI2_: %{public}d", systemUIRes, isSystemUI2_); + } +} + void ScreenCaptureServer::GetDumpFlag() { const std::string dumpTag = "sys.media.screenCapture.dump.enable"; @@ -2583,6 +2696,7 @@ int32_t ScreenCaptureServer::StartScreenCapture(bool isPrivacyAuthorityEnabled) startTime_ = GetCurrentMillisecond(); statisticalEventInfo_.enableMic = isMicrophoneSwitchTurnOn_; GetDumpFlag(); + GetSystemUIFlag(); MEDIA_LOGI("ScreenCaptureServer: 0x%{public}06" PRIXPTR " StartScreenCapture start, " "isPrivacyAuthorityEnabled:%{public}s, captureState:%{public}d.", FAKE_POINTER(this), isPrivacyAuthorityEnabled ? "true" : "false", captureState_); @@ -3829,6 +3943,7 @@ int32_t ScreenCaptureServer::StopScreenCaptureInner(AVScreenCaptureStateCode sta } CHECK_AND_RETURN_RET(captureState_ != AVScreenCaptureState::STOPPED, MSERR_OK); int32_t ret = MSERR_OK; + DestroyPrivacySheet(); if (captureConfig_.dataType == DataType::CAPTURE_FILE) { ret = StopScreenCaptureRecorder(); } else if (captureConfig_.dataType == DataType::ORIGINAL_STREAM) { @@ -3870,6 +3985,32 @@ void ScreenCaptureServer::StopNotStartedScreenCapture(AVScreenCaptureStateCode s SetErrorInfo(MSERR_OK, "normal stopped", StopReason::NORMAL_STOPPED, IsUserPrivacyAuthorityNeeded()); } +bool ScreenCaptureServer::DestroyPrivacySheet() +{ + // start ability, tell ability to destroy pop window + MEDIA_LOGI("DestroyPrivacySheet start."); + AAFwk::Want want; + + std::string bundleName = GetScreenCaptureCaptureSystemParam()["const.multimedia.screencapture.screenrecorderbundlename"]; + if (bundleName.empty()) { + MEDIA_LOGE("Failed to get screenrecorder bundlename."); + return false; + } + AppExecFwk::ElementName element("", bundleName, "com.huawei.hmos.screenrecorder.PrivacyControlAbility"); + + want.SetElement(element); + want.SetParam("appLabel", callingLabel_); + want.SetParam("sessionId", sessionId_); + want.SetParam("terminateSelf", true); + ErrCode ret = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want); + MEDIA_LOGI("DestroyPrivacySheet StartAbility end %{public}d", ret); + if (ret != ERR_OK) { + MEDIA_LOGE("Failed to start ability to destroy privacy sheet, error code : %{public}d", ret); + } + + return ret == ERR_OK; +} + bool ScreenCaptureServer::DestroyPopWindow() { if (captureState_ != AVScreenCaptureState::POPUP_WINDOW) { @@ -4027,6 +4168,77 @@ int32_t ScreenCaptureServer::SetScreenCaptureStrategy(ScreenCaptureStrategy stra return MSERR_OK; } +std::shared_ptr ScreenCaptureServer::GetWantAgent( + const std::string& callingLabel, + int32_t sessionId) +{ + MEDIA_LOGI("GetWantAgent, setWantAgent"); + auto want = std::make_shared(); + AppExecFwk::ElementName element("", + GetScreenCaptureSystemParam()["const.multimedia.screencapture.screenrecorderbundlename"], + "com.huawei.hmos.screenrecorder.PrivacyControlAbility"); //DeviceID + want.SetElement(element); + want.SetParam("appLabel", callingLabel); + want.SetParam("sessionId", sessionId); + std::vector> wants; + wants.push_back(want); + MEDIA_LOGI("GetWantAgent, setWantAgent set all params"); + std::vector flags; + flags.push_back(AbilityRuntime::WantAgent::WantAgentConstant::Flags::UPDATE_PRESENT_FLAG); + AbilityRuntime::WantAgent::WantAgentInfo wantAgentInfo(0, + AbilityRuntime::WantAgent::WantAgentConstant::OperationType::START_ABILITY, + flags, wants, nullptr); + MEDIA_LOGI("GetWantAgent, setWantAgent create wantAgentInfo"); + MEDIA_LOGI("GetWantAgent, setWantAgent get wantAgent"); + return OHOS::AbilityRuntime::WantAgent::WantAgentHelper::GetWantAgent(wantAgentInfo); +} + +void ScreenCaptureServer::SetPublishRequest( + const std::shared_ptr& localLiveViewContent, + int32_t notificationId, NotificationRequest& request) +{ + std::shared_ptr notificationContent = + std::make_shared(localLiveViewContent); + + request.SetSlotType(NotificationConstant::SlotType::LIVE_VIEW); + request.SetNotificationId(notificationId); + request.SetContent(notificationContent); + request.SetCreatorUid(AV_SCREEN_CAPTURE_SESSION_UID); + request.SetOwnerUid(AV_SCREEN_CAPTURE_SESSION_UID); + request.SetUnremovable(true); + request.SetInProgress(true); +} + +void ScreenCaptureServer::SystemPrivacyProtected(ScreenId& virtualScreenId, bool systemPrivacyProtectionSwitch) +{ + std::vector screenIds; + screenIds.push_back(virtualScreenId); + MEDIA_LOGI("SystemPrivacyProtected virtualScreenId_: %{public}lu", + virtualScreenId); + auto ret = ScreenManager::GetInstance().SetScreenSkipProtectedWindow(screenIds, systemPrivacyProtectionSwitch); + if (ret == DMError::DM_OK || ret == DMError::DM_ERROR_DEVICE_NOT_SUPPORT) { + MEDIA_LOGI("SystemPrivacyProtected SetScreenSkipProtectedWindow success"); + } else { + MEDIA_LOGI("SystemPrivacyProtected SetScreenSkipProtectedWindow failed, ret: %{public}d", ret); + } + +} + +void ScreenCaptureServer::AppPrivacyProtected(ScreenId& virtualScreenId, bool appPrivacyProtectionSwitch) +{ + std::vector screenIds; + screenIds.push_back(virtualScreenId); + MEDIA_LOGI("SystemPrivacyProtected virtualScreenId_: %{public}lu", + virtualScreenId); + auto ret = ScreenManager::GetInstance().SetScreenSkipProtectedWindow(screenIds, appPrivacyProtectionSwitch); + if (ret == DMError::DM_OK || ret == DMError::DM_ERROR_DEVICE_NOT_SUPPORT) { + MEDIA_LOGI("SystemPrivacyProtected SetScreenSkipProtectedWindow success"); + } else { + MEDIA_LOGI("SystemPrivacyProtected SetScreenSkipProtectedWindow failed, ret: %{public}d", ret); + } + +} + ScreenCaptureObserverCallBack::ScreenCaptureObserverCallBack( std::weak_ptr screenCaptureServer): taskQueObserverCb_("NotifyStopSc") { diff --git a/services/services/screen_capture/server/screen_capture_server.h b/services/services/screen_capture/server/screen_capture_server.h index b99f5ca99..f79187aab 100644 --- a/services/services/screen_capture/server/screen_capture_server.h +++ b/services/services/screen_capture/server/screen_capture_server.h @@ -44,9 +44,9 @@ public: static std::shared_ptr CreateScreenCaptureNewInstance(); static int32_t ReportAVScreenCaptureUserChoice(int32_t sessionId, const std::string &content); static int32_t GetRunningScreenCaptureInstancePid(std::list &pidList); + static int32_t GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr); static void GetChoiceFromJson(Json::Value &root, const std::string &content, std::string key, std::string &value); - static void GetBoxSelectedFromJson(Json::Value &root, const std::string &content, std::string key, - bool &checkBoxSelected); + static void GetValueFromJson(Json::Value &root, const std::string &content, std::string key, bool &value); static void PrepareSelectWindow(Json::Value &root, std::shared_ptr &server); static void AddScreenCaptureServerMap(int32_t sessionId, std::weak_ptr server); static void RemoveScreenCaptureServerMap(int32_t sessionId); @@ -104,6 +104,12 @@ public: void SetSessionId(int32_t sessionId); int32_t OnReceiveUserPrivacyAuthority(bool isAllowed); int32_t StopScreenCaptureByEvent(AVScreenCaptureStateCode stateCode); + std::shared_ptr GetWantAgent(const std::string& callingLabel, + int32_t sessionId); + void SetPublishRequest(const std::shared_ptr& localLiveViewContent, + int32_t notificationId, NotificationRequest& request); + void SystemPrivacyProtected(ScreenId& virtualScreenId, bool systemPrivacyProtectionSwitch); + void AppPrivacyProtected(ScreenId& virtualScreenId, bool appPrivacyProtectionSwitch); #ifdef SUPPORT_CALL int32_t TelCallStateUpdated(bool isInTelCall); int32_t TelCallAudioStateUpdated(bool isInTelCallAudio); @@ -188,6 +194,7 @@ private: void CloseFd(); void ReleaseInner(); void GetDumpFlag(); + void GetSystemUIFlag(); int32_t SetMicrophoneOn(); int32_t SetMicrophoneOff(); @@ -213,6 +220,10 @@ private: int32_t StartPrivacyWindow(); void SetCaptureConfig(CaptureMode captureMode, int32_t missionId = -1); // -1 invalid ScreenScaleMode GetScreenScaleMode(const AVScreenCaptureFillMode &fillMode); + int32_t HandlePopupWindowCase(Json::Value& root, const std::string &content, + std::shared_ptr& server); + int32_t HandleStreamDataCase(Json::Value& root, const std::string &content, + std::shared_ptr& server); #ifdef PC_STANDARD bool CheckCaptureSpecifiedWindowForSelectWindow(); void SendConfigToUIParams(AAFwk::Want& want); @@ -232,6 +243,7 @@ private: int32_t StartNotification(); std::shared_ptr GetLocalLiveViewContent(); void UpdateLiveViewContent(); + NotificationTime CreateCountTime(); std::shared_ptr GetPixelMap(std::string path); std::shared_ptr GetPixelMapSvg(std::string path, int32_t width, int32_t height); void ResSchedReportData(int64_t value, std::unordered_map payload); @@ -251,6 +263,7 @@ private: int32_t OnTelCallStop(); #endif bool DestroyPopWindow(); + bool DestroyPrivacySheet(); void StopNotStartedScreenCapture(AVScreenCaptureStateCode stateCode); int32_t RegisterWindowLifecycleListener(std::vector windowIdList); int32_t UnRegisterWindowLifecycleListener(); @@ -260,6 +273,7 @@ private: int32_t SetCaptureAreaInner(uint64_t displayId, OHOS::Rect area); bool CheckDisplayArea(uint64_t displayId, OHOS::Rect area); void PrepareUserSelectionInfo(ScreenCaptureUserSelectionInfo &selectionInfo); + void SetupCapsule(NotificationCapsule& capslue); private: std::mutex mutex_; @@ -275,6 +289,8 @@ private: bool checkBoxSelected_ = false; bool showShareSystemAudioBox_ = false; bool isInnerAudioBoxSelected_ = true; + bool appPrivacyProtectionSwitch_ = true; + bool systemPrivacyProtectionSwitch_ = true; std::vector surfaceIdList_ = {}; std::vector surfaceTypeList_ = {}; std::atomic stopAcquireAudioBufferFromAudio_ = false; @@ -284,6 +300,7 @@ private: int32_t notificationId_ = 0; std::string callingLabel_; std::string liveViewText_; + std::string liveViewSubText_; std::atomic micCount_{0}; float density_ = 0.0f; int32_t capsuleVpSize_ = 18; @@ -301,6 +318,7 @@ private: sptr consumer_ = nullptr; bool isConsumerStart_ = false; bool isDump_ = false; + bool isSystemUI2_ = false; ScreenId virtualScreenId_ = SCREEN_ID_INVALID; ScreenId displayScreenId_ = SCREEN_ID_INVALID; std::vector missionIds_; @@ -373,6 +391,10 @@ private: static constexpr int32_t AV_SCREEN_CAPTURE_SESSION_UID = 1013; static constexpr const char* NOTIFICATION_SCREEN_RECORDING_TITLE_ID = "notification_screen_recording_title"; static constexpr const char* QUOTATION_MARKS_STRING = "\""; + static constexpr const char* NOTIFICATION_SCREEN_RECORDING_PRIVACY_ON_ID = + "notification_screen_recording_privacy_on"; + static constexpr const char* NOTIFICATION_SCREEN_RECORDING_PRIVACY_OFF_ID = + "notification_screen_recording_privacy_off"; static constexpr int64_t MAX_INNER_AUDIO_TIMEOUT_IN_NS = 2000000000; // 2s static constexpr int64_t AUDIO_INTERVAL_IN_NS = 20000000; // 20ms static constexpr int64_t NEG_AUDIO_INTERVAL_IN_NS = -20000000; // 20ms -- Gitee From c5c77fcb88402735337b2f97379a7824f1bdfbe2 Mon Sep 17 00:00:00 2001 From: xiangtongtong Date: Thu, 10 Jul 2025 15:15:06 +0800 Subject: [PATCH 2/4] privacy Signed-off-by: xiangtongtong --- .../screen_capture_controller_impl.cpp | 2 +- services/etc/BUILD.gn | 2 +- .../server/screen_capture_server.cpp | 20 +-- ...creen_capture_server_function_unittest.cpp | 166 ++++++++++++++++++ ...apture_server_function_unittest_window.cpp | 118 +++++++++++++ .../src/screen_capture_unit_test.cpp | 46 +++++ 6 files changed, 342 insertions(+), 12 deletions(-) diff --git a/frameworks/native/screen_capture/screen_capture_controller_impl.cpp b/frameworks/native/screen_capture/screen_capture_controller_impl.cpp index 13d81e849..fe0ad14f5 100644 --- a/frameworks/native/screen_capture/screen_capture_controller_impl.cpp +++ b/frameworks/native/screen_capture/screen_capture_controller_impl.cpp @@ -51,7 +51,7 @@ int32_t ScreenCaptureControllerImpl::GetAVScreenCaptureConfigurableParameters( MEDIA_LOGI("ScreenCaptureController::GetAVScreenCaptureConfigurableParameters start"); std::shared_ptr controllerClient = MediaServiceFactory::GetInstance().CreateScreenCaptureControllerClient(); - CHECK_AND_RETURN_LOG(controllerClient != nullptr, MSREE_UNKNOWN, + CHECK_AND_RETURN_RET_LOG(controllerClient != nullptr, MSERR_UNKNOWN, "failed to CreateScreenCaptureControllerClient"); int32_t ret = controllerClient->GetAVScreenCaptureConfigurableParameters(sessionId, resultStr); MEDIA_LOGI("ScreenCaptureController::GetAVScreenCaptureConfigurableParameters Report result: %{public}d", ret); diff --git a/services/etc/BUILD.gn b/services/etc/BUILD.gn index 8939783ba..bded1db12 100644 --- a/services/etc/BUILD.gn +++ b/services/etc/BUILD.gn @@ -108,7 +108,7 @@ ohos_prebuilt_etc("screencapture_config_dac") { } ohos_prebuilt_etc("screen_capture_capsule_stop_live2_image") { - source = "image/capsult_stop_live2.svg" + source = "image/capsule_stop_live2.svg" subsystem_name = "multimedia" relative_install_dir = "screencapture" part_name = "player_framework" diff --git a/services/services/screen_capture/server/screen_capture_server.cpp b/services/services/screen_capture/server/screen_capture_server.cpp index dd8ad2a71..2d33eb02f 100644 --- a/services/services/screen_capture/server/screen_capture_server.cpp +++ b/services/services/screen_capture/server/screen_capture_server.cpp @@ -4226,16 +4226,16 @@ void ScreenCaptureServer::SystemPrivacyProtected(ScreenId& virtualScreenId, bool void ScreenCaptureServer::AppPrivacyProtected(ScreenId& virtualScreenId, bool appPrivacyProtectionSwitch) { - std::vector screenIds; - screenIds.push_back(virtualScreenId); - MEDIA_LOGI("SystemPrivacyProtected virtualScreenId_: %{public}lu", - virtualScreenId); - auto ret = ScreenManager::GetInstance().SetScreenSkipProtectedWindow(screenIds, appPrivacyProtectionSwitch); - if (ret == DMError::DM_OK || ret == DMError::DM_ERROR_DEVICE_NOT_SUPPORT) { - MEDIA_LOGI("SystemPrivacyProtected SetScreenSkipProtectedWindow success"); - } else { - MEDIA_LOGI("SystemPrivacyProtected SetScreenSkipProtectedWindow failed, ret: %{public}d", ret); - } + // std::vector screenIds; + // screenIds.push_back(virtualScreenId); + // MEDIA_LOGI("SystemPrivacyProtected virtualScreenId_: %{public}lu", + // virtualScreenId); + // auto ret = ScreenManager::GetInstance().SetScreenSkipProtectedWindow(screenIds, appPrivacyProtectionSwitch); + // if (ret == DMError::DM_OK || ret == DMError::DM_ERROR_DEVICE_NOT_SUPPORT) { + // MEDIA_LOGI("SystemPrivacyProtected SetScreenSkipProtectedWindow success"); + // } else { + // MEDIA_LOGI("SystemPrivacyProtected SetScreenSkipProtectedWindow failed, ret: %{public}d", ret); + // } } diff --git a/test/unittest/screen_capture_test/screen_capture_service_function_unittest/server/src/screen_capture_server_function_unittest.cpp b/test/unittest/screen_capture_test/screen_capture_service_function_unittest/server/src/screen_capture_server_function_unittest.cpp index bb79d2992..438e65779 100644 --- a/test/unittest/screen_capture_test/screen_capture_service_function_unittest/server/src/screen_capture_server_function_unittest.cpp +++ b/test/unittest/screen_capture_test/screen_capture_service_function_unittest/server/src/screen_capture_server_function_unittest.cpp @@ -2655,5 +2655,171 @@ HWTEST_F(ScreenCaptureServerFunctionTest, SetVirtualScreenAutoRotation_001, Test screenCaptureServer_->captureConfig_.dataType = DataType::ORIGINAL_STREAM; EXPECT_EQ(screenCaptureServer_->SetVirtualScreenAutoRotation(), MSERR_OK); } + +HWTEST_F(ScreenCaptureServerFunctionTest, GetValueFromJson_001, TestSize.Level2) +{ + Json::Value root; + std::string content = R"({"isEnable": "true"})"; + std::strinf key = "isEnable"; + bool value = false; + screenCaptureServer_->GetValueFromJson(root, content, key, value); + EXPECT_EQ(value, true); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, GetValueFromJson_002, TestSize.Level2) +{ + Json::Value root; + std::string content = R"({"isEnable": "true"})"; + std::strinf key = "Enable"; + bool value = false; + screenCaptureServer_->GetValueFromJson(root, content, key, value); + EXPECT_EQ(value, false); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, GetValueFromJson_003, TestSize.Level2) +{ + Json::Value root; + std::string content = ""; + std::strinf key = "Enable"; + bool value = false; + screenCaptureServer_->GetValueFromJson(root, content, key, value); + EXPECT_EQ(value, false); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, GetValueFromJson_004, TestSize.Level2) +{ + Json::Value root; + std::string content = R"({"isEnable": "true"})"; + std::strinf key = "isEnable"; + bool value = false; + screenCaptureServer_->GetValueFromJson(root, content, key, value); + EXPECT_EQ(value, false); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, SystemPrivacyProtected_001, TestSize.Level2) +{ + ScreenId virtualScreenId = 1; + bool systemPrivacyProtectionSwitch = true; + screenCaptureServer_->SystemPrivacyProtected(virtualScreenId, systemPrivacyProtectionSwitch); + EXPECT_EQ(screenCaptureServer_->captureState_, AVScreenCaptureState::CREATED); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, GetLocalLiveViewContent_001, TestSize.Level2) +{ + std::string callingLabel_ = "TestApp"; + screenCaptureServer_->callingLabel_ = callingLabel_; + auto result = screenCaptureServer_->GetLocalLiveViewContent(); + std::string expectedTitle = "\"TestApp\" 正在使用屏幕"; + EXPECT_EQ(result->GetText(), expectedTitle); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, GetLocalLiveViewContent_002, TestSize.Level2) +{ + std::string callingLabel_ = "TestApp"; + screenCaptureServer_->callingLabel_ = callingLabel_; + screenCaptureServer_->SetDataType(DataType::ORIGINAL_STREAM); + auto result = screenCaptureServer_->GetLocalLiveViewContent(); + std::string expectedTitle = "\"TestApp\" 正在使用屏幕"; + EXPECT_EQ(result->GetTitle(), expectedTitle); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, GetLocalLiveViewContent_003, TestSize.Level2) +{ + std::string callingLabel_ = "TestApp"; + screenCaptureServer_->callingLabel_ = callingLabel_; + screenCaptureServer_->systemPrivacyProtectionSwitch_ = true; + screenCaptureServer_->SetDataType(DataType::ORIGINAL_STREAM); + auto result = screenCaptureServer_->GetLocalLiveViewContent(); + std::string expectedTitle = "\"TestApp\" 正在使用屏幕"; + EXPECT_EQ(result->GetTitle(), expectedTitle); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, HandleStreamDataCase_001, TestSize.Level2) +{ + Json::Value root; + std::string content = R"( + { + "stopRecording": "true", + "appPrivacyProtectionSwitch": "true", + "systemPrivacyProtectionSwitch": "true" + } + )"; + int32_t result = screenCaptureServer_->HandleStreamDataCase(root, content, screenCaptureServer_); + EXPECT_EQ(result, MSERR_OK); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, HandleStreamDataCase_002, TestSize.Level2) +{ + Json::Value root; + std::string content = R"( + { + "stopRecording": "false", + "appPrivacyProtectionSwitch": "true", + "systemPrivacyProtectionSwitch": "true" + } + )"; + int32_t result = screenCaptureServer_->HandleStreamDataCase(root, content, screenCaptureServer_); + EXPECT_EQ(result, MSERR_OK); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, HandleStreamDataCase_003, TestSize.Level2) +{ + Json::Value root; + std::string content = R"( + { + "stopRecording": "false", + "appPrivacyProtectionSwitch": "true", + "systemPrivacyProtectionSwitch": "false" + } + )"; + int32_t result = screenCaptureServer_->HandleStreamDataCase(root, content, screenCaptureServer_); + EXPECT_EQ(result, MSERR_OK); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, HandleStreamDataCase_004, TestSize.Level2) +{ + Json::Value root; + std::string content = R"( + { + "stopRecording": "false", + "appPrivacyProtectionSwitch": "false", + "systemPrivacyProtectionSwitch": "true" + } + )"; + int32_t result = screenCaptureServer_->HandleStreamDataCase(root, content, screenCaptureServer_); + EXPECT_EQ(result, MSERR_OK); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, HandleStreamDataCase_005, TestSize.Level2) +{ + Json::Value root; + std::string content = R"( + { + "stopRecording": "false", + "appPrivacyProtectionSwitch": "false", + "systemPrivacyProtectionSwitch": "false" + } + )"; + int32_t result = screenCaptureServer_->HandleStreamDataCase(root, content, screenCaptureServer_); + EXPECT_EQ(result, MSERR_OK); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, UpdateMicrophoneEnabled_001, TestSize.Level2) +{ + screenCaptureServer_->SetDataType(DataType::ORIGINAL_STREAM); + screenCaptureServer_->StartNotification(); + screenCaptureServer_->isSystemUI2_ = true; + screenCaptureServer_->UpdateMicrophoneEnabled(); + EXPECT_EQ(screenCaptureServer_->isSystemUI2_, true); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, UpdateMicrophoneEnabled_002, TestSize.Level2) +{ + screenCaptureServer_->SetDataType(DataType::ORIGINAL_STREAM); + screenCaptureServer_->StartNotification(); + screenCaptureServer_->isSystemUI2_ = false; + screenCaptureServer_->UpdateMicrophoneEnabled(); + EXPECT_EQ(screenCaptureServer_->isSystemUI2_, false); +} } // Media } // OHOS \ No newline at end of file diff --git a/test/unittest/screen_capture_test/screen_capture_service_function_unittest/server/src/screen_capture_server_function_unittest_window.cpp b/test/unittest/screen_capture_test/screen_capture_service_function_unittest/server/src/screen_capture_server_function_unittest_window.cpp index 383ffc20f..91d640559 100644 --- a/test/unittest/screen_capture_test/screen_capture_service_function_unittest/server/src/screen_capture_server_function_unittest_window.cpp +++ b/test/unittest/screen_capture_test/screen_capture_service_function_unittest/server/src/screen_capture_server_function_unittest_window.cpp @@ -250,6 +250,116 @@ HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_012, T ASSERT_EQ(screenCaptureServer_->isInnerAudioBoxSelected_, false); } +HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_013, TestSize.Level2) +{ + SetInvalidConfig(); + config_.audioInfo.micCapInfo.audioSampleRate = 16000; + config_.audioInfo.micCapInfo.audioChannels = 2; + config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT; + config_.audioInfo.innerCapInfo.audioSampleRate = 16000; + config_.audioInfo.innerCapInfo.audioChannels = 2; + config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK; + ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); + int32_t sessionId = screenCaptureServer_->sessionId_; + ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK); + screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW; + screenCaptureServer_->showShareSystemAudioBox_ = false; + screenCaptureServer_->isInnerAudioBoxSelected_ = false; + std::string choice = + "{\"stopRecording\": \"true\"," + "\"appPrivacyProtectionSwitch\": \"true\"," + "\"systemPrivacyProtectionSwitch\": \"true\"}"; + ASSERT_EQ(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_014, TestSize.Level2) +{ + SetInvalidConfig(); + config_.audioInfo.micCapInfo.audioSampleRate = 16000; + config_.audioInfo.micCapInfo.audioChannels = 2; + config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT; + config_.audioInfo.innerCapInfo.audioSampleRate = 16000; + config_.audioInfo.innerCapInfo.audioChannels = 2; + config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK; + ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); + int32_t sessionId = screenCaptureServer_->sessionId_; + ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK); + screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW; + screenCaptureServer_->showShareSystemAudioBox_ = false; + screenCaptureServer_->isInnerAudioBoxSelected_ = false; + std::string choice = + "{\"stopRecording\": \"false\"," + "\"appPrivacyProtectionSwitch\": \"true\"," + "\"systemPrivacyProtectionSwitch\": \"true\"}"; + ASSERT_EQ(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_015, TestSize.Level2) +{ + SetInvalidConfig(); + config_.audioInfo.micCapInfo.audioSampleRate = 16000; + config_.audioInfo.micCapInfo.audioChannels = 2; + config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT; + config_.audioInfo.innerCapInfo.audioSampleRate = 16000; + config_.audioInfo.innerCapInfo.audioChannels = 2; + config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK; + ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); + int32_t sessionId = screenCaptureServer_->sessionId_; + ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK); + screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW; + screenCaptureServer_->showShareSystemAudioBox_ = false; + screenCaptureServer_->isInnerAudioBoxSelected_ = false; + std::string choice = + "{\"stopRecording\": \"false\"," + "\"appPrivacyProtectionSwitch\": \"true\"," + "\"systemPrivacyProtectionSwitch\": \"false\"}"; + ASSERT_EQ(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_016, TestSize.Level2) +{ + SetInvalidConfig(); + config_.audioInfo.micCapInfo.audioSampleRate = 16000; + config_.audioInfo.micCapInfo.audioChannels = 2; + config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT; + config_.audioInfo.innerCapInfo.audioSampleRate = 16000; + config_.audioInfo.innerCapInfo.audioChannels = 2; + config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK; + ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); + int32_t sessionId = screenCaptureServer_->sessionId_; + ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK); + screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW; + screenCaptureServer_->showShareSystemAudioBox_ = false; + screenCaptureServer_->isInnerAudioBoxSelected_ = false; + std::string choice = + "{\"stopRecording\": \"false\"," + "\"appPrivacyProtectionSwitch\": \"false\"," + "\"systemPrivacyProtectionSwitch\": \"true\"}"; + ASSERT_EQ(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK); +} + +HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_017, TestSize.Level2) +{ + SetInvalidConfig(); + config_.audioInfo.micCapInfo.audioSampleRate = 16000; + config_.audioInfo.micCapInfo.audioChannels = 2; + config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT; + config_.audioInfo.innerCapInfo.audioSampleRate = 16000; + config_.audioInfo.innerCapInfo.audioChannels = 2; + config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK; + ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); + int32_t sessionId = screenCaptureServer_->sessionId_; + ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK); + screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW; + screenCaptureServer_->showShareSystemAudioBox_ = false; + screenCaptureServer_->isInnerAudioBoxSelected_ = false; + std::string choice = + "{\"stopRecording\": \"false\"," + "\"appPrivacyProtectionSwitch\": \"false\"," + "\"systemPrivacyProtectionSwitch\": \"false\"}"; + ASSERT_EQ(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK); +} + #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION HWTEST_F(ScreenCaptureServerFunctionTest, RequestUserPrivacyAuthority_001, TestSize.Level2) { @@ -442,5 +552,13 @@ HWTEST_F(ScreenCaptureServerFunctionTest, GetDisplayIdOfWindows_002, TestSize.Le screenCaptureServer_->missionIds_ = {0}; ASSERT_EQ(screenCaptureServer_->GetDisplayIdOfWindows(defaultDisplayIdValue), defaultDisplayIdValue); } + +HWTEST_F(ScreenCaptureServerFunctionTest, GetAVScreenCaptureConfigurableParameters_001, TestSize.Level2) +{ + int32_t sessionId = screenCapture_->sessionId_; + std::string resultStr; + ASSERT_EQ(screenCaptureServer_->GetAVScreenCaptureConfigurableParameters(sessionId, resultStr), MSERR_OK); + ASSERT_EQ(resultStr, "{\"appPrivacyProtectionSwitch\":false,\"systemPrivacyProtectionSwitch\":false}\n"); +} } // Media } // OHOS \ No newline at end of file diff --git a/test/unittest/screen_capture_test/screen_capture_unittest/src/screen_capture_unit_test.cpp b/test/unittest/screen_capture_test/screen_capture_unittest/src/screen_capture_unit_test.cpp index 473554c1d..247fac0b0 100644 --- a/test/unittest/screen_capture_test/screen_capture_unittest/src/screen_capture_unit_test.cpp +++ b/test/unittest/screen_capture_test/screen_capture_unittest/src/screen_capture_unit_test.cpp @@ -2402,5 +2402,51 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_update_surface, Test MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_update_surface after"); } +/** + * @tc.name: screen_capture_specified_window_file_01 + * @tc.desc: do screencapture + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(ScreenCaptureUnitTest, screen_capture_config_paramer_01, TestSize.Level2) +{ + MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_config_paramer_01 before"); + std::shared_ptr controller = + ScreenCaptureControllerFactory::CreateScreenCaptureController(); + int32_t sessionId = 0; + std::string resultStr = ""; + controller->GetAVScreenCaptureConfigurableParameters(sessionId, resultStr); + RecorderInfo recorderInfo; + SetRecorderInfo("screen_capture_specified_window_file_01.mp4", recorderInfo); + SetConfigFile(config_, recorderInfo); + AudioCaptureInfo innerCapInfo = { + .audioSampleRate = 16000, + .audioChannels = 2, + .audioSource = AudioCaptureSourceType::ALL_PLAYBACK + }; + config_.audioInfo.innerCapInfo = innerCapInfo; + config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW; + std::shared_ptr client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance(); + std::string deviceId = ""; + std::vector missionInfos; + auto result = client_->GetMissionInfos(deviceId, 20, missionInfos); + MEDIA_LOGI("screen_capture_specified_window_file_01 missionInfos size:%{public}s, result:%{public}d", + std::to_string(missionInfos.size()).c_str(), result); + for (OHOS::AAFwk::MissionInfo info : missionInfos) { + MEDIA_LOGI("screen_capture_specified_window_file_01 missionId : %{public}d", info.id); + } + if (missionInfos.size() > 0) { + config_.videoInfo.videoCapInfo.taskIDs.push_back(missionInfos[0].id); + } else { + MEDIA_LOGE("screen_capture_specified_window_file_01 GetMissionInfos failed"); + } + + EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); + EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); + sleep(RECORDER_TIME); + EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); + EXPECT_EQ(MSERR_OK, screenCapture_->Release()); + MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_file_01 after"); +} } // namespace Media } // namespace OHOS \ No newline at end of file -- Gitee From d33d75b71576a7e489b562b892425f5bef658b7e Mon Sep 17 00:00:00 2001 From: xiangtongtong Date: Fri, 11 Jul 2025 09:34:08 +0800 Subject: [PATCH 3/4] privacy Signed-off-by: xiangtongtong --- .../ipc/screen_capture_controller_proxy.cpp | 6 +- .../ipc/screen_capture_controller_stub.cpp | 6 +- .../server/screen_capture_server.cpp | 82 +++++++++---------- .../server/screen_capture_server.h | 9 +- 4 files changed, 51 insertions(+), 52 deletions(-) diff --git a/services/services/screen_capture/ipc/screen_capture_controller_proxy.cpp b/services/services/screen_capture/ipc/screen_capture_controller_proxy.cpp index 60f697986..54c96d9b0 100644 --- a/services/services/screen_capture/ipc/screen_capture_controller_proxy.cpp +++ b/services/services/screen_capture/ipc/screen_capture_controller_proxy.cpp @@ -93,9 +93,9 @@ int32_t ScreenCaptureControllerProxy::GetAVScreenCaptureConfigurableParameters(i CHECK_AND_RETURN_RET_LOG(error == MSERR_OK, MSERR_INVALID_OPERATION, "GetAVScreenCaptureConfigurableParameters failed, error: %{public}d", error); int ret = reply.ReadInt32(); - if (ret == MSERR_OK) { - resultStr = reply.ReadString(); - } + CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, + "GetAVScreenCaptureConfigurableParameters failed, ret: %{public}d", ret); + resultStr = reply.ReadString(); return ret; } diff --git a/services/services/screen_capture/ipc/screen_capture_controller_stub.cpp b/services/services/screen_capture/ipc/screen_capture_controller_stub.cpp index 83c937b70..1884e8547 100644 --- a/services/services/screen_capture/ipc/screen_capture_controller_stub.cpp +++ b/services/services/screen_capture/ipc/screen_capture_controller_stub.cpp @@ -135,7 +135,7 @@ int32_t ScreenCaptureControllerStub::ReportAVScreenCaptureUserChoice(MessageParc int32_t ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr) { - MEDIA_LOGI("ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters start 2"); + MEDIA_LOGI("ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters start"); CHECK_AND_RETURN_RET_LOG(screenCaptureControllerServer_ != nullptr, false, "screen capture controller server is nullptr"); int32_t appUid = IPCSkeleton::GetCallingUid(); @@ -150,14 +150,14 @@ int32_t ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters(in int32_t ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters(MessageParcel &data, MessageParcel &reply) { - MEDIA_LOGI("ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters start 1"); + MEDIA_LOGI("ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters start"); CHECK_AND_RETURN_RET_LOG(screenCaptureControllerServer_ != nullptr, MSERR_INVALID_STATE, "screen capture controller server is nullptr"); (void)data; int32_t sessionId = data.ReadInt32(); std::string resultStr; int32_t ret = GetAVScreenCaptureConfigurableParameters(sessionId, resultStr); - MEDIA_LOGI("ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters start 1 resultStr: %{public}s", + MEDIA_LOGI("ScreenCaptureControllerStub::GetAVScreenCaptureConfigurableParameters start resultStr: %{public}s", resultStr.c_str()); reply.WriteInt32(ret); reply.WriteString(resultStr); diff --git a/services/services/screen_capture/server/screen_capture_server.cpp b/services/services/screen_capture/server/screen_capture_server.cpp index 2d33eb02f..5dba80bd0 100644 --- a/services/services/screen_capture/server/screen_capture_server.cpp +++ b/services/services/screen_capture/server/screen_capture_server.cpp @@ -835,7 +835,7 @@ void ScreenCaptureServer::GetChoiceFromJson(Json::Value &root, } void ScreenCaptureServer::GetValueFromJson(Json::Value &root, - const std::string &content, std::string key, bool &value) + const std::string &content, const std::string key, bool &value) { value = false; @@ -866,7 +866,7 @@ void ScreenCaptureServer::SetCaptureConfig(CaptureMode captureMode, int32_t miss } } -void ScreenCaptureServer::PrepareSelectWindow(Json::Value &root, std::shared_ptr &server) +void ScreenCaptureServer::PrepareSelectWindow(Json::Value &root) { if (root.type() != Json::objectValue) { return; @@ -875,20 +875,20 @@ void ScreenCaptureServer::PrepareSelectWindow(Json::Value &root, std::shared_ptr if (!displayIdJson.isNull() && displayIdJson.isInt() && displayIdJson.asInt64() >= 0) { uint64_t displayId = static_cast(displayIdJson.asInt64()); MEDIA_LOGI("Report Select DisplayId: %{public}" PRIu64, displayId); - server->SetDisplayId(displayId); + SetDisplayId(displayId); // 手机模式 missionId displayId 均为-1 - server->SetCaptureConfig(CaptureMode::CAPTURE_SPECIFIED_SCREEN, -1); + SetCaptureConfig(CaptureMode::CAPTURE_SPECIFIED_SCREEN, -1); } const Json::Value missionIdJson = root["missionId"]; if (!missionIdJson.isNull() && missionIdJson.isInt() && missionIdJson.asInt() >= 0) { int32_t missionId = missionIdJson.asInt(); MEDIA_LOGI("Report Select MissionId: %{public}d", missionId); - server->SetMissionId(missionId); - server->SetCaptureConfig(CaptureMode::CAPTURE_SPECIFIED_WINDOW, missionId); + SetMissionId(missionId); + SetCaptureConfig(CaptureMode::CAPTURE_SPECIFIED_WINDOW, missionId); } ScreenCaptureUserSelectionInfo selectionInfo = {0, static_cast(0)}; - server->PrepareUserSelectionInfo(selectionInfo); - server->NotifyUserSelected(selectionInfo); + PrepareUserSelectionInfo(selectionInfo); + NotifyUserSelected(selectionInfo); } int32_t ScreenCaptureServer::ReportAVScreenCaptureUserChoice(int32_t sessionId, const std::string &content) @@ -900,64 +900,62 @@ int32_t ScreenCaptureServer::ReportAVScreenCaptureUserChoice(int32_t sessionId, "ReportAVScreenCaptureUserChoice failed to get instance, sessionId: %{public}d", sessionId); Json::Value root; if (server->captureState_ == AVScreenCaptureState::POPUP_WINDOW) { - return server->HandlePopupWindowCase(root, content, server); + return server->HandlePopupWindowCase(root, content); } else if (server->GetSCServerDataType() == DataType::ORIGINAL_STREAM && server->captureState_ == AVScreenCaptureState::STARTED) { - return server->HandleStreamDataCase(root, content, server); + return server->HandleStreamDataCase(root, content); } return MSERR_UNKNOWN; } -int32_t ScreenCaptureServer::HandlePopupWindowCase(Json::Value& root, const std::string &content, - std::shared_ptr& server) +int32_t ScreenCaptureServer::HandlePopupWindowCase(Json::Value& root, const std::string &content) { MEDIA_LOGI("ReportAVScreenCaptureUserChoice captureState is %{public}d", AVScreenCaptureState::POPUP_WINDOW); std::string choice = "false"; GetChoiceFromJson(root, content, std::string("choice"), choice); - GetValueFromJson(root, content, std::string("checkBoxSelected"), server->checkBoxSelected_); + GetValueFromJson(root, content, std::string("checkBoxSelected"), checkBoxSelected_); - server->systemPrivacyProtectionSwitch_ = server->checkBoxSelected_; - server->appPrivacyProtectionSwitch_ = server->checkBoxSelected_; - MEDIA_LOGI("ReportAVScreenCaptureUserChoice checkBoxSelected: %{public}d", server->checkBoxSelected_); + systemPrivacyProtectionSwitch_ = checkBoxSelected_; + appPrivacyProtectionSwitch_ = checkBoxSelected_; + MEDIA_LOGI("ReportAVScreenCaptureUserChoice checkBoxSelected: %{public}d", checkBoxSelected_); if (USER_CHOICE_ALLOW.compare(choice) == 0) { - PrepareSelectWindow(root, server); - int32_t ret = server->OnReceiveUserPrivacyAuthority(true); + PrepareSelectWindow(root); + int32_t ret = OnReceiveUserPrivacyAuthority(true); CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "ReportAVScreenCaptureUserChoice user choice is true but start failed"); MEDIA_LOGI("ReportAVScreenCaptureUserChoice user choice is true and start success"); return MSERR_OK; } else if (USER_CHOICE_DENY.compare(choice) == 0) { - return server->OnReceiveUserPrivacyAuthority(false); + return OnReceiveUserPrivacyAuthority(false); } else { MEDIA_LOGW("ReportAVScreenCaptureUserChoice user choice is not support"); } return MSERR_UNKNOWN; } -int32_t ScreenCaptureServer::HandleStreamDataCase(Json::Value& root, const std::string &content, - std::shared_ptr& server) +int32_t ScreenCaptureServer::HandleStreamDataCase(Json::Value& root, const std::string &content) { bool stopRecord = false; GetValueFromJson(root, content, std::string("stopRecording"), stopRecord); if (stopRecord) { - server->StopScreenCaptureInner(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INVLID); + StopScreenCaptureInner(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INVLID); MEDIA_LOGI("ReportAVScreenCaptureUserChoice user stop record"); return MSERR_OK; } GetValueFromJson(root, content, std::string("appPrivacyProtectionSwitch"), - server->appPrivacyProtectionSwitch_); + appPrivacyProtectionSwitch_); GetValueFromJson(root, content, std::string("systemPrivacyProtectionSwitch"), - server->systemPrivacyProtectionSwitch_); + systemPrivacyProtectionSwitch_); - server->SystemPrivacyProtected(server->virtualScreenId_, server->systemPrivacyProtectionSwitch_); - server->AppPrivacyProtected(server->virtualScreenId_, server->appPrivacyProtectionSwitch_); + SystemPrivacyProtected(virtualScreenId_, systemPrivacyProtectionSwitch_); + AppPrivacyProtected(virtualScreenId_, appPrivacyProtectionSwitch_); - std::lock_guard lock(server->mutex_); + std::lock_guard lock(mutex_); NotificationRequest request; - server->SetPublishRequest(server->GetLocalLiveViewContent(), server->notificationId_, request); - request.SetWantAgent(server->GetWantAgent(server->callingLabel_, server->sessionId_)); + SetPublishRequest(GetLocalLiveViewContent(), notificationId_, request); + request.SetWantAgent(GetWantAgent(callingLabel_, sessionId_)); return NotificationHelper::PublishNotification(request); } @@ -2668,9 +2666,9 @@ NotificationTime ScreenCaptureServer::CreateCountTime() void ScreenCaptureServer::GetSystemUIFlag() { - const std::string dumpTag = "persist.systemui.live2"; + const std::string systemUITag = "persist.systemui.live2"; std::string systemUI2; - int32_t systemUIRes = OHOS::system::GetStringParameter(dumpTag, systemUI2, "false"); + int32_t systemUIRes = OHOS::system::GetStringParameter(systemUITag, systemUI2, "false"); if (systemUIRes != 0) { MEDIA_LOGI("Failed to get systemUI flag, Res: %{public}d", systemUIRes); isSystemUI2_ = false; @@ -2840,6 +2838,7 @@ int32_t ScreenCaptureServer::CreateVirtualScreen(const std::string &name, sptr screenIds; - // screenIds.push_back(virtualScreenId); - // MEDIA_LOGI("SystemPrivacyProtected virtualScreenId_: %{public}lu", - // virtualScreenId); - // auto ret = ScreenManager::GetInstance().SetScreenSkipProtectedWindow(screenIds, appPrivacyProtectionSwitch); - // if (ret == DMError::DM_OK || ret == DMError::DM_ERROR_DEVICE_NOT_SUPPORT) { - // MEDIA_LOGI("SystemPrivacyProtected SetScreenSkipProtectedWindow success"); - // } else { - // MEDIA_LOGI("SystemPrivacyProtected SetScreenSkipProtectedWindow failed, ret: %{public}d", ret); - // } + MEDIA_LOGI("AppPrivacyProtected virtualScreenId_: %{public}lu", + virtualScreenId); + std::vector privacyWindowTags; + privacyWindowTags.put_back("TAG_SCREEN_PROTECTION_SENSITIVE_APP"); + auto ret = ScreenManager::GetInstance().SetScreenPrivacyWindowTagSwitch(virtualScreenId, + privacyWindowTags, appPrivacyProtectionSwitch); + if (ret == DMError::DM_OK || ret == DMError::DM_ERROR_DEVICE_NOT_SUPPORT) { + MEDIA_LOGI("AppPrivacyProtected SetScreenSkipProtectedWindow success"); + } else { + MEDIA_LOGI("AppPrivacyProtected SetScreenSkipProtectedWindow failed, ret: %{public}d", ret); + } } diff --git a/services/services/screen_capture/server/screen_capture_server.h b/services/services/screen_capture/server/screen_capture_server.h index f79187aab..159a69842 100644 --- a/services/services/screen_capture/server/screen_capture_server.h +++ b/services/services/screen_capture/server/screen_capture_server.h @@ -47,7 +47,6 @@ public: static int32_t GetAVScreenCaptureConfigurableParameters(int32_t sessionId, std::string &resultStr); static void GetChoiceFromJson(Json::Value &root, const std::string &content, std::string key, std::string &value); static void GetValueFromJson(Json::Value &root, const std::string &content, std::string key, bool &value); - static void PrepareSelectWindow(Json::Value &root, std::shared_ptr &server); static void AddScreenCaptureServerMap(int32_t sessionId, std::weak_ptr server); static void RemoveScreenCaptureServerMap(int32_t sessionId); static bool CheckScreenCaptureSessionIdLimit(int32_t curAppUid); @@ -220,10 +219,10 @@ private: int32_t StartPrivacyWindow(); void SetCaptureConfig(CaptureMode captureMode, int32_t missionId = -1); // -1 invalid ScreenScaleMode GetScreenScaleMode(const AVScreenCaptureFillMode &fillMode); - int32_t HandlePopupWindowCase(Json::Value& root, const std::string &content, - std::shared_ptr& server); - int32_t HandleStreamDataCase(Json::Value& root, const std::string &content, - std::shared_ptr& server); + int32_t HandlePopupWindowCase(Json::Value& root, const std::string &content); + int32_t HandleStreamDataCase(Json::Value& root, const std::string &content); + void PrepareSelectWindow(Json::Value &root); + #ifdef PC_STANDARD bool CheckCaptureSpecifiedWindowForSelectWindow(); void SendConfigToUIParams(AAFwk::Want& want); -- Gitee From 6d17d640d881f3847f877851397c900937b443e4 Mon Sep 17 00:00:00 2001 From: xiangtongtong Date: Fri, 11 Jul 2025 13:50:23 +0800 Subject: [PATCH 4/4] privacy Signed-off-by: xiangtongtong --- .../server/screen_capture_server.cpp | 24 +++++++------------ 1 file changed, 9 insertions(+), 15 deletions(-) diff --git a/services/services/screen_capture/server/screen_capture_server.cpp b/services/services/screen_capture/server/screen_capture_server.cpp index 5dba80bd0..733c42842 100644 --- a/services/services/screen_capture/server/screen_capture_server.cpp +++ b/services/services/screen_capture/server/screen_capture_server.cpp @@ -2447,8 +2447,8 @@ std::string ScreenCaptureServer::GetStringByResourceName(const char* name) { std::string resourceContext; CHECK_AND_RETURN_RET_LOG(resourceManager_ != nullptr, resourceContext, "resourceManager is null"); - if (strcmp(name, NOTIFICATION_SCREEN_RECORDING_TITLE_ID) == 0 || - strcmp(name, NOTIFICATION_SCREEN_RECORDING_PRIVACY_ON_ID) == 0 || + if (strcmp(name, NOTIFICATION_SCREEN_RECORDING_TITLE_ID) == 0 || + strcmp(name, NOTIFICATION_SCREEN_RECORDING_PRIVACY_ON_ID) == 0 || strcmp(name, NOTIFICATION_SCREEN_RECORDING_PRIVACY_OFF_ID) == 0) { resourceManager_->GetStringByName(name, resourceContext); MEDIA_LOGD("get NOTIFICATION_SCREEN_RECORDING_TITLE_ID: %{public}s", resourceContext.c_str()); @@ -3990,7 +3990,7 @@ bool ScreenCaptureServer::DestroyPrivacySheet() MEDIA_LOGI("DestroyPrivacySheet start."); AAFwk::Want want; - std::string bundleName = GetScreenCaptureCaptureSystemParam()["const.multimedia.screencapture.screenrecorderbundlename"]; + std::string bundleName = GetScreenCaptureSystemParam()["const.multimedia.screencapture.screenrecorderbundlename"]; if (bundleName.empty()) { MEDIA_LOGE("Failed to get screenrecorder bundlename."); return false; @@ -4175,10 +4175,10 @@ std::shared_ptr ScreenCaptureServer: auto want = std::make_shared(); AppExecFwk::ElementName element("", GetScreenCaptureSystemParam()["const.multimedia.screencapture.screenrecorderbundlename"], - "com.huawei.hmos.screenrecorder.PrivacyControlAbility"); //DeviceID - want.SetElement(element); - want.SetParam("appLabel", callingLabel); - want.SetParam("sessionId", sessionId); + "com.huawei.hmos.screenrecorder.PrivacyControlAbility"); + want->SetElement(element); + want->SetParam("appLabel", callingLabel); + want->SetParam("sessionId", sessionId); std::vector> wants; wants.push_back(want); MEDIA_LOGI("GetWantAgent, setWantAgent set all params"); @@ -4212,31 +4212,25 @@ void ScreenCaptureServer::SystemPrivacyProtected(ScreenId& virtualScreenId, bool { std::vector screenIds; screenIds.push_back(virtualScreenId); - MEDIA_LOGI("SystemPrivacyProtected virtualScreenId_: %{public}lu", - virtualScreenId); auto ret = ScreenManager::GetInstance().SetScreenSkipProtectedWindow(screenIds, systemPrivacyProtectionSwitch); if (ret == DMError::DM_OK || ret == DMError::DM_ERROR_DEVICE_NOT_SUPPORT) { MEDIA_LOGI("SystemPrivacyProtected SetScreenSkipProtectedWindow success"); } else { MEDIA_LOGI("SystemPrivacyProtected SetScreenSkipProtectedWindow failed, ret: %{public}d", ret); } - } void ScreenCaptureServer::AppPrivacyProtected(ScreenId& virtualScreenId, bool appPrivacyProtectionSwitch) { - MEDIA_LOGI("AppPrivacyProtected virtualScreenId_: %{public}lu", - virtualScreenId); std::vector privacyWindowTags; - privacyWindowTags.put_back("TAG_SCREEN_PROTECTION_SENSITIVE_APP"); + privacyWindowTags.push_back("TAG_SCREEN_PROTECTION_SENSITIVE_APP"); auto ret = ScreenManager::GetInstance().SetScreenPrivacyWindowTagSwitch(virtualScreenId, privacyWindowTags, appPrivacyProtectionSwitch); if (ret == DMError::DM_OK || ret == DMError::DM_ERROR_DEVICE_NOT_SUPPORT) { MEDIA_LOGI("AppPrivacyProtected SetScreenSkipProtectedWindow success"); } else { MEDIA_LOGI("AppPrivacyProtected SetScreenSkipProtectedWindow failed, ret: %{public}d", ret); - } - + } } ScreenCaptureObserverCallBack::ScreenCaptureObserverCallBack( -- Gitee