diff --git a/frameworks/ets/ani/ability_manager/src/ets_ability_manager.cpp b/frameworks/ets/ani/ability_manager/src/ets_ability_manager.cpp
index c2763fd0b1a58be8eba541dee0ad653946c781d1..033685ed7563c3952c8b85952c33d4847fb51c06 100644
--- a/frameworks/ets/ani/ability_manager/src/ets_ability_manager.cpp
+++ b/frameworks/ets/ani/ability_manager/src/ets_ability_manager.cpp
@@ -20,9 +20,12 @@
 #include "ability_manager_client.h"
 #include "ability_manager_errors.h"
 #include "ability_manager_interface.h"
+#include "acquire_share_data_callback_stub.h"
 #include "ani_base_context.h"
 #include "ani_common_ability_state_data.h"
+#include "ani_common_configuration.h"
 #include "ani_common_want.h"
+#include "ani_enum_convert.h"
 #include "app_mgr_interface.h"
 #include "ets_ability_foreground_state_observer.h"
 #include "ets_ability_manager_utils.h"
@@ -42,6 +45,46 @@ constexpr const char* ETS_ABILITY_MANAGER_SIGNATURE_ARRAY = ":Lescompat/Array;";
 constexpr const char* ETS_ABILITY_MANAGER_SIGNATURE_CALLBACK = "Lutils/AbilityUtils/AsyncCallbackWrapper;:V";
 constexpr const char *ON_OFF_TYPE_ABILITY_FOREGROUND_STATE = "abilityForegroundState";
 constexpr int32_t ERR_FAILURE = -1;
+
+sptr<AAFwk::AcquireShareDataCallbackStub> CreateShareDataCallbackStub(
+    ani_vm *aniVM, ani_ref callbackRef)
+{
+    auto shareDataCallbackStub = new (std::nothrow) AAFwk::AcquireShareDataCallbackStub();
+    if (shareDataCallbackStub == nullptr) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "null shareDataCallbackStub");
+        return nullptr;
+    }
+    auto handler = std::make_shared<AppExecFwk::EventHandler>(AppExecFwk::EventRunner::GetMainEventRunner());
+    shareDataCallbackStub->SetHandler(handler);
+    AAFwk::ShareRuntimeTask task =
+        [aniVM, callbackRef](int32_t resultCode, const AAFwk::WantParams &wantParam) {
+            ani_env *env = nullptr;
+            ani_status status = aniVM->GetEnv(ANI_VERSION_1, &env);
+            if (status != ANI_OK || env == nullptr) {
+                TAG_LOGE(AAFwkTag::ABILITYMGR, "null env");
+                return;
+            }
+            if (resultCode != 0) {
+                AppExecFwk::AsyncCallback(env, static_cast<ani_object>(callbackRef),
+                    EtsErrorUtil::CreateErrorByNativeErr(env, resultCode), nullptr);
+                env->GlobalReference_Delete(callbackRef);
+                return;
+            }
+            ani_ref wantParamRef = AppExecFwk::WrapWantParams(env, wantParam);
+            if (wantParamRef == nullptr) {
+                TAG_LOGE(AAFwkTag::ABILITYMGR, "null wantParamRef");
+                AppExecFwk::AsyncCallback(env, static_cast<ani_object>(callbackRef),
+                    EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER), nullptr);
+                env->GlobalReference_Delete(callbackRef);
+                return;
+            }
+            AppExecFwk::AsyncCallback(env, static_cast<ani_object>(callbackRef),
+                EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), static_cast<ani_object>(wantParamRef));
+            env->GlobalReference_Delete(callbackRef);
+        };
+    shareDataCallbackStub->SetShareRuntimeTask(task);
+    return shareDataCallbackStub;
+}
 }
 
 class EtsAbilityManager final {
@@ -52,6 +95,13 @@ public:
     static void IsEmbeddedOpenAllowed(ani_env *env, ani_object contextObj, ani_string aniAppId, ani_object callbackObj);
     static void NativeOn(ani_env *env, ani_string aniType, ani_object aniObserver);
     static void NativeOff(ani_env *env, ani_string aniType, ani_object aniObserver);
+    static void NativeNotifyDebugAssertResult(ani_env *env, ani_string aniSessionId, ani_object userStatusObj,
+        ani_object callbackObj);
+    static void NativeSetResidentProcessEnabled(ani_env *env, ani_string aniBundleName, ani_boolean enabled,
+        ani_object callbackObj);
+    static void NativeAcquireShareData(ani_env *env, ani_int aniMissionId, ani_object callbackObj);
+    static void NativeUpdateConfiguration(ani_env *env, ani_object configObj, ani_object callbackObj);
+
 private:
     static sptr<AppExecFwk::IAbilityManager> GetAbilityManagerInstance();
     static sptr<AppExecFwk::IAppMgr> GetAppManagerInstance();
@@ -271,6 +321,163 @@ void EtsAbilityManager::NativeOff(ani_env *env, ani_string aniType, ani_object a
     TAG_LOGD(AAFwkTag::ABILITYMGR, "nativeOff end");
 }
 
+
+void EtsAbilityManager::NativeNotifyDebugAssertResult(ani_env *env, ani_string aniSessionId,
+    ani_object userStatusObj, ani_object callbackObj)
+{
+    TAG_LOGD(AAFwkTag::ABILITYMGR, "NativeNotifyDebugAssertResult called");
+    if (env == nullptr) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "env null ptr");
+        return;
+    }
+    std::string sessionId;
+    if (!AppExecFwk::GetStdString(env, aniSessionId, sessionId)) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "convert sessionId failed");
+        EtsErrorUtil::ThrowInvalidParamError(env, "Parse param sessionId failed, must be a string.");
+        return;
+    }
+
+    uint64_t assertSessionId = std::stoull(sessionId);
+    if (assertSessionId == 0) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "convert sessionId failed");
+        EtsErrorUtil::ThrowInvalidParamError(env, "Parse param sessionId failed, value must not be equal to zero.");
+        return;
+    }
+    int32_t userStatus;
+    if (!AAFwk::AniEnumConvertUtil::EnumConvert_EtsToNative(env, userStatusObj, userStatus)) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "convert status failed");
+        EtsErrorUtil::ThrowInvalidParamError(env, "Parse param status failed, must be a UserStatus.");
+        return;
+    }
+    auto amsClient = AAFwk::AbilityManagerClient::GetInstance();
+    if (amsClient == nullptr) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "null amsClient");
+        AppExecFwk::AsyncCallback(env, callbackObj,
+            EtsErrorUtil::CreateErrorByNativeErr(env, AAFwk::INNER_ERR), nullptr);
+        return;
+    }
+    auto ret = amsClient->NotifyDebugAssertResult(assertSessionId, static_cast<AAFwk::UserStatus>(userStatus));
+    if (ret != ERR_OK) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "failed %{public}d", ret);
+    }
+    AppExecFwk::AsyncCallback(env, callbackObj, EtsErrorUtil::CreateErrorByNativeErr(env, ret), nullptr);
+}
+
+void EtsAbilityManager::NativeSetResidentProcessEnabled(ani_env *env, ani_string aniBundleName,
+    ani_boolean enabled, ani_object callbackObj)
+{
+    TAG_LOGD(AAFwkTag::ABILITYMGR, "NativeSetResidentProcessEnabled called");
+    if (env == nullptr) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "env null ptr");
+        return;
+    }
+
+    std::string bundleName;
+    if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName) || bundleName.empty()) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "parse bundleName failed, not string");
+        EtsErrorUtil::ThrowInvalidParamError(env, "Parse param bundleName failed, must be a string.");
+        AppExecFwk::AsyncCallback(env, callbackObj,
+            EtsErrorUtil::CreateErrorByNativeErr(env, AAFwk::INNER_ERR), nullptr);
+        return;
+    }
+
+    bool enableState = (enabled != 0);
+
+    auto amsClient = AAFwk::AbilityManagerClient::GetInstance();
+    int32_t ret = ERR_OK;
+    if (amsClient == nullptr) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "null amsClient");
+        ret = static_cast<int32_t>(AAFwk::INNER_ERR);
+    } else {
+        ret = amsClient->SetResidentProcessEnabled(bundleName, enableState);
+    }
+
+    if (ret != ERR_OK) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "error: %{public}d", ret);
+        AppExecFwk::AsyncCallback(env, callbackObj,
+            EtsErrorUtil::CreateErrorByNativeErr(env, ret), nullptr);
+        return;
+    }
+    AppExecFwk::AsyncCallback(env, callbackObj,
+        EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), nullptr);
+}
+void EtsAbilityManager::NativeAcquireShareData(ani_env *env, ani_int aniMissionId, ani_object callbackObj)
+{
+    TAG_LOGD(AAFwkTag::ABILITYMGR, "NativeAcquireShareData called");
+    if (env == nullptr) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "env null ptr");
+        return;
+    }
+    int32_t missionId = aniMissionId;
+    ani_vm *aniVM = nullptr;
+    if (env->GetVM(&aniVM) != ANI_OK) {
+        TAG_LOGE(AAFwkTag::DELEGATOR, "GetVM failed");
+        return;
+    }
+    ani_ref callbackRef = nullptr;
+    env->GlobalReference_Create(callbackObj, &callbackRef);
+
+    auto shareDataCallbackStub = CreateShareDataCallbackStub(aniVM, callbackRef);
+    if (shareDataCallbackStub == nullptr) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "null shareDataCallbackStub");
+        AppExecFwk::AsyncCallback(env, callbackObj,
+            EtsErrorUtil::CreateErrorByNativeErr(env, AAFwk::INNER_ERR), nullptr);
+        env->GlobalReference_Delete(callbackRef);
+        return;
+    }
+
+    auto amsClient = AAFwk::AbilityManagerClient::GetInstance();
+    int32_t err = ERR_OK;
+    if (amsClient == nullptr) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "null amsClient");
+        err = static_cast<int32_t>(AAFwk::INNER_ERR);
+    } else {
+        err = amsClient->AcquireShareData(missionId, shareDataCallbackStub);
+    }
+    if (err != ERR_OK) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "error: %{public}d", err);
+        AppExecFwk::AsyncCallback(env, callbackObj,
+            EtsErrorUtil::CreateErrorByNativeErr(env, err), nullptr);
+        env->GlobalReference_Delete(callbackRef);
+    }
+}
+
+void EtsAbilityManager::NativeUpdateConfiguration(ani_env *env, ani_object configObj, ani_object callbackObj)
+{
+    TAG_LOGD(AAFwkTag::ABILITYMGR, "NativeUpdateConfiguration called");
+    if (env == nullptr) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "env null ptr");
+        return;
+    }
+
+    AppExecFwk::Configuration changeConfig;
+    if (!AppExecFwk::UnwrapConfiguration(env, configObj, changeConfig)) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "UnwrapConfiguration failed");
+        EtsErrorUtil::ThrowInvalidParamError(env, "Parse param config failed, must be a Configuration.");
+        AppExecFwk::AsyncCallback(env, callbackObj,
+            EtsErrorUtil::CreateErrorByNativeErr(env, AAFwk::INNER_ERR), nullptr);
+        return;
+    }
+
+    auto appManager = GetAppManagerInstance();
+    int32_t errcode = ERR_OK;
+    if (appManager == nullptr) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "appManager is null");
+        errcode = static_cast<int32_t>(AAFwk::INNER_ERR);
+    } else {
+        errcode = appManager->UpdateConfiguration(changeConfig);
+    }
+
+    if (errcode != ERR_OK) {
+        TAG_LOGE(AAFwkTag::ABILITYMGR, "UpdateConfiguration failed: %{public}d", errcode);
+        AppExecFwk::AsyncCallback(env, callbackObj,
+            EtsErrorUtil::CreateErrorByNativeErr(env, errcode), nullptr);
+        return;
+    }
+    AppExecFwk::AsyncCallback(env, callbackObj,
+        EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), nullptr);
+}
+
 void EtsAbilityManagerRegistryInit(ani_env *env)
 {
     TAG_LOGD(AAFwkTag::ABILITYMGR, "call EtsAbilityManagerRegistryInit");
@@ -301,7 +508,15 @@ void EtsAbilityManagerRegistryInit(ani_env *env)
             "Lapplication/Context/Context;Lstd/core/String;Lutils/AbilityUtils/AsyncCallbackWrapper;:V",
             reinterpret_cast<void *>(EtsAbilityManager::IsEmbeddedOpenAllowed) },
         ani_native_function { "nativeOn", nullptr, reinterpret_cast<void *>(EtsAbilityManager::NativeOn) },
-        ani_native_function { "nativeOff", nullptr, reinterpret_cast<void *>(EtsAbilityManager::NativeOff) }
+        ani_native_function { "nativeOff", nullptr, reinterpret_cast<void *>(EtsAbilityManager::NativeOff) },
+        ani_native_function { "nativeNotifyDebugAssertResult",
+            nullptr, reinterpret_cast<void *>(EtsAbilityManager::NativeNotifyDebugAssertResult) },
+        ani_native_function { "nativeSetResidentProcessEnabled",
+            nullptr, reinterpret_cast<void *>(EtsAbilityManager::NativeSetResidentProcessEnabled) },
+        ani_native_function { "nativeAcquireShareData",
+            nullptr, reinterpret_cast<void *>(EtsAbilityManager::NativeAcquireShareData) },
+        ani_native_function { "nativeUpdateConfiguration",
+            nullptr, reinterpret_cast<void *>(EtsAbilityManager::NativeUpdateConfiguration) }
     };
     status = env->Namespace_BindNativeFunctions(ns, methods.data(), methods.size());
     if (status != ANI_OK) {
diff --git a/frameworks/ets/ani/ani_common/src/ani_common_configuration.cpp b/frameworks/ets/ani/ani_common/src/ani_common_configuration.cpp
index b8ffcd2dc40edd390806952bdebfb00d79d57a99..cdc17018697f499242428455eba1f201e22971c4 100644
--- a/frameworks/ets/ani/ani_common/src/ani_common_configuration.cpp
+++ b/frameworks/ets/ani/ani_common/src/ani_common_configuration.cpp
@@ -136,7 +136,7 @@ bool UnwrapConfiguration(ani_env *env, ani_object param, Configuration &config)
         return false;
     }
     std::string language { "" };
-    if (GetFieldStringByName(env, param, "language", language)) {
+    if (GetStringProperty(env, param, "language", language)) {
         TAG_LOGD(AAFwkTag::ANI, "The parsed language part %{public}s", language.c_str());
         if (!config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, language)) {
             TAG_LOGE(AAFwkTag::ANI, "language Parsing failed");
@@ -144,7 +144,7 @@ bool UnwrapConfiguration(ani_env *env, ani_object param, Configuration &config)
         }
     }
     std::string locale { "" };
-    if (GetFieldStringByName(env, param, "locale", locale)) {
+    if (GetStringProperty(env, param, "locale", locale)) {
         TAG_LOGD(AAFwkTag::ANI, "The parsed locale part %{public}s", locale.c_str());
         if (!config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LOCALE, locale)) {
             TAG_LOGE(AAFwkTag::ANI, "locale parsing failed");
@@ -153,7 +153,7 @@ bool UnwrapConfiguration(ani_env *env, ani_object param, Configuration &config)
     }
 
     ani_double fontSizeScale = 0.0;
-    if (GetFieldDoubleByName(env, param, "fontSizeScale", fontSizeScale)) {
+    if (GetDoublePropertyObject(env, param, "fontSizeScale", fontSizeScale)) {
         if (fontSizeScale < FONT_SIZE_MIN_SCALE || fontSizeScale > FONT_SIZE_MAX_SCALE) {
             TAG_LOGE(AAFwkTag::ANI, "invalid fontSizeScale");
             return false;
@@ -164,7 +164,7 @@ bool UnwrapConfiguration(ani_env *env, ani_object param, Configuration &config)
     }
 
     ani_double fontWeightScale = 0.0;
-    if (GetFieldDoubleByName(env, param, "fontWeightScale", fontWeightScale)) {
+    if (GetDoublePropertyObject(env, param, "fontWeightScale", fontWeightScale)) {
         if (fontWeightScale < FONT_WEIGHT_MIN_SCALE || fontWeightScale > FONT_WEIGHT_MAX_SCALE) {
             TAG_LOGE(AAFwkTag::ANI, "invalid fontWeightScale");
             return false;
diff --git a/frameworks/ets/ani/service_extension_ability/include/ets_service_extension_context.h b/frameworks/ets/ani/service_extension_ability/include/ets_service_extension_context.h
index 33034dbb0b84561bb09d45e15c200c65a427a7e3..6243759a33af92e1f7f34d377358e30df61be3c1 100644
--- a/frameworks/ets/ani/service_extension_ability/include/ets_service_extension_context.h
+++ b/frameworks/ets/ani/service_extension_ability/include/ets_service_extension_context.h
@@ -69,6 +69,8 @@ public:
     static void StartServiceExtensionAbility(ani_env *env, ani_object obj, ani_object wantObj, ani_object callbackobj);
     static void StopServiceExtensionAbility(
         ani_env *env, ani_object aniObj, ani_object wantObj, ani_object callbackobj);
+    static void OpenAtomicService(ani_env *env, ani_object aniObj, ani_string aniAppId,
+        ani_object callbackObj, ani_object optionsObj);
 
     std::weak_ptr<ServiceExtensionContext> GetAbilityContext()
     {
@@ -83,6 +85,11 @@ private:
         ani_object wantObj, ani_object connectOptionsObj);
     void OnDisconnectServiceExtensionAbility(ani_env *env, ani_object aniObj, ani_long connectId,
         ani_object callback);
+    void OnOpenAtomicService(ani_env *env, ani_object aniObj, ani_string aniAppId, ani_object callbackObj,
+        ani_object optionsObj);
+    void OpenAtomicServiceInner(ani_env *env, ani_object aniObj, AAFwk::Want &want,
+        AAFwk::StartOptions &options, std::string appId, ani_object callbackObj);
+
     void AddFreeInstallObserver(ani_env *env, const AAFwk::Want &want,
         ani_object callbackObj, std::shared_ptr<ServiceExtensionContext> context);
 
diff --git a/frameworks/ets/ani/service_extension_ability/src/ets_service_extension_context.cpp b/frameworks/ets/ani/service_extension_ability/src/ets_service_extension_context.cpp
index 965c6196e9618d7cd50e60df92e755bc9a08ee55..8da880c3083944521a29e6c398956ee557a476c4 100644
--- a/frameworks/ets/ani/service_extension_ability/src/ets_service_extension_context.cpp
+++ b/frameworks/ets/ani/service_extension_ability/src/ets_service_extension_context.cpp
@@ -40,6 +40,7 @@ constexpr const int FAILED_CODE = -1;
 constexpr const char *SIGNATURE_CONNECT_SERVICE_EXTENSION =
     "L@ohos/app/ability/Want/Want;Lability/connectOptions/ConnectOptions;:J";
 constexpr const char *SIGNATURE_DISCONNECT_SERVICE_EXTENSION = "JLutils/AbilityUtils/AsyncCallbackWrapper;:V";
+const std::string ATOMIC_SERVICE_PREFIX = "com.atomicservice.";
 constexpr int32_t ARGC_ONE = 1;
 constexpr int32_t ARGC_TWO = 2;
 
@@ -65,6 +66,8 @@ bool BindNativeMethods(ani_env *env, ani_class &cls)
             reinterpret_cast<void *>(EtsServiceExtensionContext::ConnectServiceExtensionAbility) },
         ani_native_function { "nativeDisconnectServiceExtensionAbility", SIGNATURE_DISCONNECT_SERVICE_EXTENSION,
             reinterpret_cast<void *>(EtsServiceExtensionContext::DisconnectServiceExtensionAbility) },
+        ani_native_function { "nativeOpenAtomicService", SIGNATURE_DISCONNECT_SERVICE_EXTENSION,
+            reinterpret_cast<void *>(EtsServiceExtensionContext::OpenAtomicService) },
     };
     if ((status = env->Class_BindNativeMethods(cls, functions.data(), functions.size())) != ANI_OK
         && status != ANI_ALREADY_BINDED) {
@@ -255,6 +258,18 @@ void EtsServiceExtensionContext::DisconnectServiceExtensionAbility(ani_env *env,
     etsServiceExtensionContext->OnDisconnectServiceExtensionAbility(env, aniObj, connectId, callback);
 }
 
+void EtsServiceExtensionContext::OpenAtomicService(
+    ani_env *env, ani_object aniObj, ani_string aniAppId, ani_object callbackObj, ani_object optionsObj)
+{
+    TAG_LOGD(AAFwkTag::SERVICE_EXT, "OpenAtomicService called");
+    auto etsContext = GetEtsAbilityContext(env, aniObj);
+    if (etsContext == nullptr) {
+        TAG_LOGE(AAFwkTag::SERVICE_EXT, "null etsContext");
+        return;
+    }
+    etsContext->OnOpenAtomicService(env, aniObj, aniAppId, callbackObj, optionsObj);
+}
+
 EtsServiceExtensionContext *EtsServiceExtensionContext::GetEtsAbilityContext(
     ani_env *env, ani_object aniObj)
 {
@@ -488,6 +503,72 @@ void EtsServiceExtensionContext::OnDisconnectServiceExtensionAbility(ani_env *en
     AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), nullptr);
 }
 
+
+void EtsServiceExtensionContext::OnOpenAtomicService(
+    ani_env *env, ani_object aniObj, ani_string aniAppId, ani_object callbackObj, ani_object optionsObj)
+{
+    TAG_LOGD(AAFwkTag::SERVICE_EXT, "OnOpenAtomicService");
+    ani_status status = ANI_ERROR;
+    ani_boolean isOptionsUndefined = true;
+    ani_object errorObject = nullptr;
+    if ((status = env->Reference_IsUndefined(optionsObj, &isOptionsUndefined)) != ANI_OK) {
+        TAG_LOGE(AAFwkTag::SERVICE_EXT, "status: %{public}d", status);
+        return;
+    }
+    std::string appId;
+    if (!AppExecFwk::GetStdString(env, aniAppId, appId)) {
+        TAG_LOGE(AAFwkTag::SERVICE_EXT, "parse appId failed");
+        errorObject = EtsErrorUtil::CreateInvalidParamError(env, "Parse param appId failed, appId must be string.");
+        AppExecFwk::AsyncCallback(env, callbackObj, errorObject, nullptr);
+        return;
+    }
+    AAFwk::Want want;
+    AAFwk::StartOptions startOptions;
+    if (!isOptionsUndefined) {
+        if (!AppExecFwk::UnwrapAtomicServiceOptions(env, optionsObj, want, startOptions)) {
+            TAG_LOGE(AAFwkTag::SERVICE_EXT, "UnwrapAtomicServiceOptions failed");
+            errorObject = EtsErrorUtil::CreateInvalidParamError(env, "UnwrapAtomicServiceOptions failed.");
+            AppExecFwk::AsyncCallback(env, callbackObj, errorObject, nullptr);
+            return;
+        }
+    }
+    OpenAtomicServiceInner(env, aniObj, want, startOptions, appId, callbackObj);
+}
+
+void EtsServiceExtensionContext::OpenAtomicServiceInner(ani_env *env, ani_object aniObj, AAFwk::Want &want,
+    AAFwk::StartOptions &options, std::string appId, ani_object callbackObj)
+{
+    std::string bundleName = ATOMIC_SERVICE_PREFIX + appId;
+    TAG_LOGD(AAFwkTag::SERVICE_EXT, "bundleName: %{public}s", bundleName.c_str());
+    want.SetBundle(bundleName);
+    want.AddFlags(AAFwk::Want::FLAG_INSTALL_ON_DEMAND);
+    std::string startTime = std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>
+        (std::chrono::system_clock::now().time_since_epoch()).count());
+    want.SetParam(AAFwk::Want::PARAM_RESV_START_TIME, startTime);
+    auto context = context_.lock();
+    if (context == nullptr) {
+        TAG_LOGE(AAFwkTag::SERVICE_EXT, "null context");
+        EtsErrorUtil::ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT);
+        return;
+    }
+    AddFreeInstallObserver(env, want, callbackObj, context);
+    want.SetParam(AAFwk::Want::PARAM_RESV_FOR_RESULT, true);
+    int32_t ErrCode = context->OpenAtomicService(want, options);
+    if (ErrCode == ERR_OK) {
+        TAG_LOGI(AAFwkTag::SERVICE_EXT, "OpenAtomicService success");
+        return;
+    }
+    TAG_LOGE(AAFwkTag::SERVICE_EXT, "OpenAtomicService failed");
+    if (freeInstallObserver_ != nullptr) {
+        std::string bundleName = want.GetElement().GetBundleName();
+        std::string abilityName = want.GetElement().GetAbilityName();
+        freeInstallObserver_->OnInstallFinished(bundleName, abilityName, startTime, ErrCode);
+    } else {
+        TAG_LOGI(AAFwkTag::SERVICE_EXT, "OpenAtomicService success");
+        AppExecFwk::AsyncCallback(env, callbackObj, EtsErrorUtil::CreateErrorByNativeErr(env, ErrCode), nullptr);
+    }
+}
+
 void EtsServiceExtensionContext::AddFreeInstallObserver(
     ani_env *env, const AAFwk::Want &want, ani_object callbackObj, std::shared_ptr<ServiceExtensionContext> context)
 {
diff --git a/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets b/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets
index 6d653337ba12c9945a1f267aa00104c516d0b6af..48a764420d4f21dedd0cee2322bf408fa1e8a455 100644
--- a/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets
@@ -20,7 +20,10 @@ import AsyncCallbackWrapper from './utils/AbilityUtils';
 import { AbilityRunningInfo as _AbilityRunningInfo } from 'application.AbilityRunningInfo';
 import _AbilityStateData from 'application.AbilityStateData';
 import Context from 'application.Context';
+import { Configuration } from '@ohos.app.ability.Configuration';
 import _AbilityForegroundStateObserver from 'application.AbilityForegroundStateObserver';
+import { ExtensionRunningInfo as _ExtensionRunningInfo } from './application/ExtensionRunningInfo';
+
 
 export default namespace abilityManager {
   loadLibrary("ability_manager_ani_kit.z")
@@ -32,6 +35,10 @@ export default namespace abilityManager {
   export native function nativeIsEmbeddedOpenAllowed(context: Context, appId: string, callback:AsyncCallbackWrapper<boolean>) : void;
   export native function nativeOn(type:string, observer: AbilityForegroundStateObserver): void;
   export native function nativeOff(type:string, observer?: AbilityForegroundStateObserver): void;
+  export native function nativeNotifyDebugAssertResult(sessionId: string, status: UserStatus, callback: AsyncCallbackWrapper<void>): void;
+  export native function nativeSetResidentProcessEnabled(bundleName: string, enable: boolean, callback: AsyncCallbackWrapper<void>): void;
+  export native function nativeAcquireShareData(missionId: int, callback: AsyncCallbackWrapper<Record<string, Object>>): void;
+  export native function nativeUpdateConfiguration(config: Configuration, callback: AsyncCallbackWrapper<void>): void;
 
   export function getForegroundUIAbilities():Promise<Array<AbilityStateData>> {
     let p = new Promise<Array<AbilityStateData>>((resolve: (data: Array<AbilityStateData>) => void, reject: (error: Error) => void): void => {
@@ -118,6 +125,83 @@ export default namespace abilityManager {
     });
   }
 
+ function notifyDebugAssertResult(sessionId: string, status: UserStatus): Promise<void> {
+    return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        if (err == null || err.code == 0) {
+          resolve(undefined);
+        } else {
+          reject(err);
+        }
+      });
+      taskpool.execute((): void => {
+        abilityManager.nativeNotifyDebugAssertResult(sessionId, status, asyncCall);
+      });
+    });
+  }
+
+  function setResidentProcessEnabled(bundleName: string, enable: boolean): Promise<void> {
+    return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        if (err == null || err.code == 0) {
+          resolve(undefined);
+        } else {
+          reject(err);
+        }
+      });
+      taskpool.execute((): void => {
+        abilityManager.nativeSetResidentProcessEnabled(bundleName, enable, asyncCall);
+      });
+    });
+  }
+
+  function acquireShareData(missionId: int, callback: AsyncCallback<Record<string, Object>>): void {
+    let asyncCall = new AsyncCallbackWrapper<Record<string, Object>>(callback);
+    taskpool.execute( (): void => {
+        abilityManager.nativeAcquireShareData(missionId, asyncCall);
+    });
+  }
+
+  function acquireShareData(missionId: int): Promise<Record<string, Object>> {
+    return new Promise<Record<string, Object>>((resolve: (data: Record<string, Object>) => void,
+      reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<Record<string, Object>>((err: BusinessError | null,
+        data: Record<string, Object> | undefined) => {
+        if (err == null || err.code == 0) {
+          resolve(data as Record<string, Object>);
+        } else {
+          reject(err);
+        }
+      });
+      taskpool.execute((): void => {
+        abilityManager.nativeAcquireShareData(missionId, asyncCall);
+      });
+    });
+  }
+
+  function updateConfiguration(config: Configuration, callback: AsyncCallback<void>): void {
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
+    taskpool.execute((): void => {
+      abilityManager.nativeUpdateConfiguration(config, asyncCall);
+    });
+  }
+
+  function updateConfiguration(config: Configuration): Promise<void> {
+    return new Promise<void>((resolve: (data: undefined) => void,
+      reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        if (err == null || err.code == 0) {
+          resolve(undefined);
+        } else {
+          reject(err);
+        }
+      });
+      taskpool.execute((): void => {
+        abilityManager.nativeUpdateConfiguration(config, asyncCall);
+      });
+    });
+  }
+
   export function on(type: 'abilityForegroundState', observer: AbilityForegroundStateObserver): void {
     abilityManager.nativeOn('abilityForegroundState', observer);
   }
@@ -146,4 +230,6 @@ export default namespace abilityManager {
   export type AbilityStateData = _AbilityStateData;
 
   export type AbilityForegroundStateObserver = _AbilityForegroundStateObserver;
+
+  export type ExtensionRunningInfo = _ExtensionRunningInfo;
 }
\ No newline at end of file
diff --git a/frameworks/ets/ets/application/ServiceExtensionContext.ets b/frameworks/ets/ets/application/ServiceExtensionContext.ets
index 2bb11c2f1f5b3dce31fec9f54417d783ffca9de5..7ea6cea2cb89d1513f3924c550d8651fe2726cc3 100644
--- a/frameworks/ets/ets/application/ServiceExtensionContext.ets
+++ b/frameworks/ets/ets/application/ServiceExtensionContext.ets
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+import AtomicServiceOptions from '@ohos.app.ability.AtomicServiceOptions';
 import { AsyncCallback } from '@ohos.base';
 import AsyncCallbackWrapper from '../utils/AbilityUtils';
 import { BusinessError } from '@ohos.base';
@@ -72,6 +73,8 @@ export default class ServiceExtensionContext extends ExtensionContext {
 
   native nativeDisconnectServiceExtensionAbility(connection: long, callback: AsyncCallbackWrapper<void>): void;
 
+  native nativeOpenAtomicService(appId: string, callback: AsyncCallbackWrapper<void>, options?: AtomicServiceOptions): void;
+
   terminateSelf(callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
@@ -191,4 +194,19 @@ export default class ServiceExtensionContext extends ExtensionContext {
       })
     });
   }
+
+  openAtomicService(appId: string, options?: AtomicServiceOptions): Promise<void> {
+    return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        if (err == null || err.code == 0) {
+          resolve(undefined);
+        } else {
+          reject(err);
+        }
+      });
+      taskpool.execute((): void => {
+        this.nativeOpenAtomicService(appId, asyncCall, options);
+      });
+    });
+  }
 }