diff --git a/frameworks/innerkitsimpl/include/iprint_ipc_interface_code.h b/frameworks/innerkitsimpl/include/iprint_ipc_interface_code.h
index dce94b6cc2a14314a2375ea6fc289d6c5b62b039..bcb5853498cf4e62c0c918a6ff48308f8ff7d8a6 100644
--- a/frameworks/innerkitsimpl/include/iprint_ipc_interface_code.h
+++ b/frameworks/innerkitsimpl/include/iprint_ipc_interface_code.h
@@ -46,7 +46,8 @@ namespace OHOS::Print {
         CMD_ADDPRINTERTOCUPS,
         CMD_QUERYPRINTERCAPABILITYBYURI,
         CMD_STARTPRINTJOB_BY_ADAPTER,
-        CMD_START_GET_FILE
+        CMD_START_GET_FILE,
+        CMD_NOTIFY_PRINT_SERVICE,
     };
 } // namespace OHOS:Print
 #endif // PRINT_SERVICE_INTERFACE_H
diff --git a/frameworks/innerkitsimpl/include/iprint_service.h b/frameworks/innerkitsimpl/include/iprint_service.h
index c4a66736e3d5564281243e053eb22254770adab3..37cebeb838aed319ec1ec7ccc2735c152959eaae 100644
--- a/frameworks/innerkitsimpl/include/iprint_service.h
+++ b/frameworks/innerkitsimpl/include/iprint_service.h
@@ -66,6 +66,7 @@ public:
         const sptr<IRemoteObject> &token) = 0;
     virtual int32_t StartGetPrintFile(const std::string &jobId, const PrintAttributes &printAttributes,
         const uint32_t fd) = 0;
+    virtual int32_t NotifyPrintService(const std::string &jobId, const std::string &type) = 0;
 };
 } // namespace OHOS::Print
 #endif // PRINT_SERVICE_INTERFACE_H
\ No newline at end of file
diff --git a/frameworks/innerkitsimpl/include/print_manager_client.h b/frameworks/innerkitsimpl/include/print_manager_client.h
index 9f122474ae8224a072a7d78f56400d52e4d803bb..de7792cb87a67751cd998c3465befc280dafed60 100644
--- a/frameworks/innerkitsimpl/include/print_manager_client.h
+++ b/frameworks/innerkitsimpl/include/print_manager_client.h
@@ -73,6 +73,7 @@ public:
         const PrintAttributes &printAttributes, void* contextToken);
     int32_t StartGetPrintFile(const std::string &jobId, const PrintAttributes &printAttributes,
         const uint32_t fd);
+    int32_t NotifyPrintService(const std::string &jobId, const std::string &type);
 
     int32_t RegisterExtCallback(const std::string &extensionId, uint32_t callbackId, PrintExtCallback cb);
     int32_t RegisterExtCallback(const std::string &extensionId, uint32_t callbackId, PrintJobCallback cb);
diff --git a/frameworks/innerkitsimpl/include/print_service_proxy.h b/frameworks/innerkitsimpl/include/print_service_proxy.h
index 6ca4e2344a8ac5c60839a5b56bce755e3fcb7b83..0042651400501dcd2e24cae594549371227ecc97 100644
--- a/frameworks/innerkitsimpl/include/print_service_proxy.h
+++ b/frameworks/innerkitsimpl/include/print_service_proxy.h
@@ -60,6 +60,7 @@ public:
         const sptr<IRemoteObject> &token) override;
     int32_t StartGetPrintFile(const std::string &jobId, const PrintAttributes &printAttributes,
         const uint32_t fd) override;
+    int32_t NotifyPrintService(const std::string &jobId, const std::string &type) override;
 
 private:
     int32_t GetResult(int retCode, MessageParcel &reply);
diff --git a/frameworks/innerkitsimpl/src/print_manager_client.cpp b/frameworks/innerkitsimpl/src/print_manager_client.cpp
index a2dfd6c699c891c19c5f6d48f07e81a5f9b56f6f..0e1ccdfdebc49d682bab8c355819aa6a3515675e 100644
--- a/frameworks/innerkitsimpl/src/print_manager_client.cpp
+++ b/frameworks/innerkitsimpl/src/print_manager_client.cpp
@@ -380,6 +380,17 @@ int32_t PrintManagerClient::StartGetPrintFile(const std::string &jobId, const Pr
     return CALL_COMMON_CLIENT(func);
 }
 
+int32_t PrintManagerClient::NotifyPrintService(const std::string &jobId, const std::string &type)
+{
+    PRINT_HILOGD("PrintManagerClient NotifyPrintService start.");
+    int32_t ret = E_PRINT_RPC_FAILURE;
+    if (LoadServer() && GetPrintServiceProxy()) {
+        ret = printServiceProxy_->NotifyPrintService(jobId, type);
+        PRINT_HILOGD("PrintManagerClient NotifyPrintService out ret = [%{public}d].", ret);
+    }
+    return ret;
+}
+
 int32_t PrintManagerClient::runBase(const char* callerFunName, std::function<int32_t(sptr<IPrintService>)> func)
 {
     PRINT_HILOGI("PrintManagerClient %{public}s start.", callerFunName);
diff --git a/frameworks/innerkitsimpl/src/print_service_proxy.cpp b/frameworks/innerkitsimpl/src/print_service_proxy.cpp
index 1809c9cac7a1e8bf8270d37fa77a65c10855e316..dd9f7e613f7612247101adb86ac1766469dc4587 100644
--- a/frameworks/innerkitsimpl/src/print_service_proxy.cpp
+++ b/frameworks/innerkitsimpl/src/print_service_proxy.cpp
@@ -534,6 +534,22 @@ int32_t PrintServiceProxy::StartGetPrintFile(const std::string &jobId, const Pri
     return ret;
 }
 
+int32_t PrintServiceProxy::NotifyPrintService(const std::string &jobId, const std::string &type)
+{
+    PRINT_HILOGD("PrintServiceProxy::NotifyPrintService in");
+    MessageParcel data, reply;
+    MessageOption option;
+
+    data.WriteInterfaceToken(GetDescriptor());
+    data.WriteString(jobId);
+    data.WriteString(type);
+    int32_t ret = Remote()->SendRequest(
+        OHOS::Print::IPrintInterfaceCode::CMD_NOTIFY_PRINT_SERVICE, data, reply, option);
+    ret = GetResult(ret, reply);
+    PRINT_HILOGD("PrintServiceProxy NotifyPrintService out. ret = [%{public}d]", ret);
+    return ret;
+}
+
 int32_t PrintServiceProxy::UnregisterAllExtCallback(const std::string &extensionId)
 {
     PRINT_HILOGD("PrintServiceProxy::UnregisterAllExtCallback in");
diff --git a/interfaces/kits/napi/include/napi_inner_print.h b/interfaces/kits/napi/include/napi_inner_print.h
index b7654143156c55a41124926093c2681cc75cfd54..b354ca6464922e0594d02eae1bd660ed88b480b9 100644
--- a/interfaces/kits/napi/include/napi_inner_print.h
+++ b/interfaces/kits/napi/include/napi_inner_print.h
@@ -44,8 +44,8 @@ public:
     static napi_value QueryPrintJobById(napi_env env, napi_callback_info info);
     static napi_value On(napi_env env, napi_callback_info info);
     static napi_value Off(napi_env env, napi_callback_info info);
-    static napi_value PrintByAdapter(napi_env env, napi_callback_info info);
     static napi_value StartGetPrintFile(napi_env env, napi_callback_info info);
+    static napi_value NotifyPrintService(napi_env env, napi_callback_info info);
 
 private:
     static bool IsSupportType(const std::string& type);
diff --git a/interfaces/kits/napi/include/napi_print_task.h b/interfaces/kits/napi/include/napi_print_task.h
index f5674bb48013dab5e7558929f1541150b0a97937..a7794c46f54da80a87527bb761982c1318c669f8 100644
--- a/interfaces/kits/napi/include/napi_print_task.h
+++ b/interfaces/kits/napi/include/napi_print_task.h
@@ -43,6 +43,8 @@ private:
     static napi_value WrapVoidToJS(napi_env env);
     static napi_status VerifyParameters(napi_env env, size_t argc, napi_value *argv,
         const std::shared_ptr<PrintTaskContext> context);
+    static napi_value PrintByAdapter(napi_env env, napi_callback_info info);
+    static napi_value ParsePrintAdapterParameter(napi_env env, size_t argc, napi_value *argv, napi_value self);
 
 private:
     static __thread napi_ref globalCtor;
diff --git a/interfaces/kits/napi/include/print_task.h b/interfaces/kits/napi/include/print_task.h
index dd62bf2f30c1b0a8508e6da0a75fdb013e768c37..0b69aa1617cb4c12e55e178fa058f1e5b7f6f7b5 100644
--- a/interfaces/kits/napi/include/print_task.h
+++ b/interfaces/kits/napi/include/print_task.h
@@ -31,9 +31,12 @@ namespace OHOS::Print {
 class PrintTask {
 public:
     explicit PrintTask(const std::vector<std::string> &fileList, const sptr<IRemoteObject> &callerToken_);
+    PrintTask(const std::string &printJobName_, const sptr<IPrintCallback> &printAdapterCallback_,
+        const std::shared_ptr<PrintAttributes> &printAttributes_, const sptr<IRemoteObject> &callerToken_);
     ~PrintTask();
 
     uint32_t Start();
+    uint32_t StartPrintAdapter();
     void Stop();
     const std::string &GetId() const;
     static napi_value On(napi_env env, napi_callback_info info);
@@ -58,7 +61,10 @@ private:
     std::vector<uint32_t> fdList_;
     std::map<std::string, bool> supportEvents_;
     uint32_t pathType_ = 0;
-    sptr<IRemoteObject> callerToken_;
+    sptr<IRemoteObject> callerToken_ = nullptr;
+    std::string printJobName_;
+    sptr<IPrintCallback> printAdapterCallback_ = nullptr;
+    std::shared_ptr<PrintAttributes> printAttributes_ = nullptr;
     enum FilePathType {
         FD_UNDEFINED,
         FD_PATH,
diff --git a/interfaces/kits/napi/src/napi_inner_print.cpp b/interfaces/kits/napi/src/napi_inner_print.cpp
index 33a6f32702efcac0cfd84c1a3d7291158c80f1bd..9b912c2fe8aded47303888b2a9e333df250a3144 100644
--- a/interfaces/kits/napi/src/napi_inner_print.cpp
+++ b/interfaces/kits/napi/src/napi_inner_print.cpp
@@ -513,45 +513,44 @@ napi_value NapiInnerPrint::StartGetPrintFile(napi_env env, napi_callback_info in
     return nullptr;
 }
 
-napi_value NapiInnerPrint::PrintByAdapter(napi_env env, napi_callback_info info)
+napi_value NapiInnerPrint::NotifyPrintService(napi_env env, napi_callback_info info)
 {
-    PRINT_HILOGI("PrintByAdapter start ---->");
-    napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr };
-    size_t argc = NapiPrintUtils::GetJsVal(env, info, argv, NapiPrintUtils::MAX_ARGC);
-    PRINT_ASSERT(env, argc == NapiPrintUtils::ARGC_FOUR || argc == NapiPrintUtils::ARGC_THREE,
-        "PrintByAdapter need 3 or 4 parameter!");
-
-    napi_valuetype valuetype;
-    PRINT_CALL(env, napi_typeof(env, argv[0], &valuetype));
-    PRINT_ASSERT(env, valuetype == napi_string, "type is not a string");
-    std::string printJobName = NapiPrintUtils::GetStringFromValueUtf8(env, argv[0]);
-    PRINT_HILOGD("printJobName : %{public}s", printJobName.c_str());
-
-    uint32_t type = argc == NapiPrintUtils::ARGC_FOUR ?
-        NapiPrintUtils::GetUint32FromValue(env, argv[NapiPrintUtils::ARGC_THREE]) : 0;
-    sptr<IPrintCallback> callback = nullptr;
-    if (type == 0) {
-        napi_ref adapterRef = NapiPrintUtils::CreateReference(env, argv[1]);
-        callback = new (std::nothrow) PrintCallback(env, adapterRef);
-    } else {
-        PrintDocumentAdapter *adapter = new PrintDocumentInnerAdapter();
-        callback = new (std::nothrow) PrintCallback(adapter);
-    }
-
-    if (callback == nullptr) {
-        PRINT_HILOGE("create print callback object fail");
-        return nullptr;
-    }
-
-    if (static_cast<uint32_t>(argc) > NapiPrintUtils::INDEX_TWO) {
-        auto printAttributes = PrintAttributesHelper::BuildFromJs(env, argv[NapiPrintUtils::INDEX_TWO]);
-        int32_t ret = PrintManagerClient::GetInstance()->Print(printJobName, callback, *printAttributes);
+    PRINT_HILOGI("Enter NotifyPrintService---->");
+    auto context = std::make_shared<InnerPrintContext>();
+    auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
+        PRINT_ASSERT_BASE(env, argc == NapiPrintUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
+        napi_valuetype valuetype;
+        PRINT_CALL_BASE(env, napi_typeof(env, argv[0], &valuetype), napi_invalid_arg);
+        PRINT_ASSERT_BASE(env, valuetype == napi_string, "jobId is not a string", napi_string_expected);
+        PRINT_CALL_BASE(env, napi_typeof(env, argv[1], &valuetype), napi_invalid_arg);
+        PRINT_ASSERT_BASE(env, valuetype == napi_string, "info type is not a string", napi_string_expected);
+        std::string jobId = NapiPrintUtils::GetStringFromValueUtf8(env, argv[0]);
+        std::string type = NapiPrintUtils::GetStringFromValueUtf8(env, argv[1]);
+        if (jobId == "" || type == "") {
+            PRINT_HILOGE("Parse JobId error!");
+            context->SetErrorIndex(E_PRINT_INVALID_PARAMETER);
+            return napi_invalid_arg;
+        }
+        context->jobId = jobId;
+        context->type = type;
+        return napi_ok;
+    };
+    auto output = [context](napi_env env, napi_value *result) -> napi_status {
+        napi_status status = napi_get_boolean(env, context->result, result);
+        PRINT_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
+        return status;
+    };
+    auto exec = [context](PrintAsyncCall::Context *ctx) {
+        int32_t ret = PrintManagerClient::GetInstance()->NotifyPrintService(context->jobId, context->type);
+        context->result = ret == E_PRINT_NONE;
         if (ret != E_PRINT_NONE) {
-            PRINT_HILOGE("Failed to register event");
-            return nullptr;
+            PRINT_HILOGE("Failed to NotifyPrintService");
+            context->SetErrorIndex(ret);
         }
-    }
-    return nullptr;
+    };
+    context->SetAction(std::move(input), std::move(output));
+    PrintAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<PrintAsyncCall::Context>(context));
+    return asyncCall.Call(env, exec);
 }
 
 bool NapiInnerPrint::IsSupportType(const std::string& type)
diff --git a/interfaces/kits/napi/src/napi_print_task.cpp b/interfaces/kits/napi/src/napi_print_task.cpp
index 6837e61ebab9a78f301fafad0e93d2458e9033a2..0cb972b3130bf60e3b91011befd016905f83132e 100644
--- a/interfaces/kits/napi/src/napi_print_task.cpp
+++ b/interfaces/kits/napi/src/napi_print_task.cpp
@@ -21,6 +21,9 @@
 #include "print_manager_client.h"
 #include "print_task.h"
 #include "napi_print_task.h"
+#include "print_attributes_helper.h"
+#include "print_callback.h"
+#include "iprint_callback.h"
 
 static constexpr const char *FUNCTION_ON = "on";
 static constexpr const char *FUNCTION_OFF = "off";
@@ -36,8 +39,8 @@ napi_value NapiPrintTask::Print(napi_env env, napi_callback_info info)
     size_t paramCount = NapiPrintUtils::GetJsVal(env, info, argv, NapiPrintUtils::MAX_ARGC);
     napi_valuetype type;
     PRINT_CALL(env, napi_typeof(env, argv[0], &type));
-    if ((paramCount == NapiPrintUtils::ARGC_FOUR || paramCount == NapiPrintUtils::ARGC_THREE) && type == napi_string) {
-        return NapiInnerPrint::PrintByAdapter(env, info);
+    if ((paramCount > NapiPrintUtils::ARGC_THREE) && type == napi_string) {
+        return PrintByAdapter(env, info);
     }
 
     auto context = std::make_shared<PrintTaskContext>();
@@ -85,6 +88,94 @@ napi_value NapiPrintTask::Print(napi_env env, napi_callback_info info)
     return asyncCall.Call(env);
 }
 
+napi_value NapiPrintTask::PrintByAdapter(napi_env env, napi_callback_info info)
+{
+    PRINT_HILOGI("PrintByAdapter start ---->");
+    auto context = std::make_shared<PrintTaskContext>();
+    auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
+        PRINT_ASSERT_BASE(env, argc == NapiPrintUtils::ARGC_FOUR, "need 4 parameter!", napi_invalid_arg);
+        napi_status checkStatus = VerifyParameters(env, argc, argv, context);
+        if (checkStatus != napi_ok) {
+            return checkStatus;
+        }
+
+        napi_value proxy = nullptr;
+        napi_status status = napi_new_instance(env, GetCtor(env), argc, argv, &proxy);
+        if ((proxy == nullptr) || (status != napi_ok)) {
+            PRINT_HILOGE("Failed to create print task");
+            context->SetErrorIndex(E_PRINT_GENERIC_FAILURE);
+            return napi_generic_failure;
+        }
+
+        PrintTask *task;
+        PRINT_CALL_BASE(env, napi_unwrap(env, proxy, reinterpret_cast<void **>(&task)), napi_invalid_arg);
+        uint32_t ret = E_PRINT_GENERIC_FAILURE;
+        if (task != nullptr) {
+            ret = task->StartPrintAdapter();
+        }
+        if (ret != E_PRINT_NONE) {
+            PRINT_HILOGE("Failed to start print task");
+            context->SetErrorIndex(ret);
+            return napi_generic_failure;
+        }
+        napi_create_reference(env, proxy, 1, &(context->ref));
+        return napi_ok;
+    };
+    auto output = [context](napi_env env, napi_value *result) -> napi_status {
+        if (context->ref == nullptr) {
+            *result = NapiPrintUtils::GetUndefined(env);
+            return napi_generic_failure;
+        }
+        napi_status status = napi_get_reference_value(env, context->ref, result);
+        napi_delete_reference(env, context->ref);
+        return status;
+    };
+    context->SetAction(std::move(input), std::move(output));
+    PrintAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<PrintAsyncCall::Context>(context));
+    return asyncCall.Call(env);
+}
+
+napi_value NapiPrintTask::ParsePrintAdapterParameter(napi_env env, size_t argc, napi_value *argv, napi_value self)
+{
+    if (argc > NapiPrintUtils::ARGC_THREE && argc > NapiPrintUtils::ARGC_TWO) {
+        std::string printJobName = NapiPrintUtils::GetStringFromValueUtf8(env, argv[0]);
+        
+        napi_ref adapterRef = NapiPrintUtils::CreateReference(env, argv[1]);
+        sptr<IPrintCallback> callback = new (std::nothrow) PrintCallback(env, adapterRef);
+
+        std::shared_ptr<PrintAttributes> printAttributes;
+        printAttributes = PrintAttributesHelper::BuildFromJs(env, argv[NapiPrintUtils::ARGC_TWO]);
+        if (callback == nullptr || printAttributes == nullptr) {
+            PRINT_HILOGE("printAdapter paramter error");
+            return nullptr;
+        }
+
+        std::shared_ptr<OHOS::AbilityRuntime::AbilityContext> abilityContext;
+        sptr<IRemoteObject> callerToken = nullptr;
+        if (GetAbilityContext(env, argv[NapiPrintUtils::ARGC_THREE], abilityContext) != nullptr) {
+            callerToken = abilityContext->GetToken();
+        }
+        auto task = new (std::nothrow) PrintTask(printJobName, callback, printAttributes, callerToken);
+
+        if (task == nullptr) {
+            PRINT_HILOGE("print task fail");
+            return nullptr;
+        }
+        auto finalize = [](napi_env env, void *data, void *hint) {
+            PRINT_HILOGD("destructed print task");
+            PrintTask *task = reinterpret_cast<PrintTask *>(data);
+            delete task;
+        };
+        if (napi_wrap(env, self, task, finalize, nullptr, nullptr) != napi_ok) {
+            finalize(env, task, nullptr);
+            return nullptr;
+        }
+        PRINT_HILOGD("Succeed to allocate print task");
+        return self;
+    }
+    return nullptr;
+}
+
 napi_value NapiPrintTask::GetAbilityContext(
     napi_env env, napi_value value, std::shared_ptr<OHOS::AbilityRuntime::AbilityContext> &abilityContext)
 {
@@ -141,43 +232,46 @@ napi_value NapiPrintTask::Initialize(napi_env env, napi_callback_info info)
     size_t argc = NapiPrintUtils::MAX_ARGC;
     napi_value argv[NapiPrintUtils::MAX_ARGC] = { nullptr };
     PRINT_CALL(env, napi_get_cb_info(env, info, &argc, argv, &self, nullptr));
-
-    std::vector<std::string> printfiles;
-    uint32_t arrayReLength = 0;
-    PRINT_CALL(env, napi_get_array_length(env, argv[0], &arrayReLength));
-    for (uint32_t index = 0; index < arrayReLength; index++) {
-        napi_value filesValue;
-        napi_get_element(env, argv[0], index, &filesValue);
-        std::string files = NapiPrintUtils::GetStringFromValueUtf8(env, filesValue);
-        PRINT_HILOGD("file[%{public}d] %{private}s.", index, files.c_str());
-        if (IsValidFile(files)) {
-            printfiles.emplace_back(files);
+    
+    if (argc > NapiPrintUtils::ARGC_THREE) {
+        return ParsePrintAdapterParameter(env, argc, argv, self);
+    } else {
+        std::vector<std::string> printfiles;
+        uint32_t arrayReLength = 0;
+        PRINT_CALL(env, napi_get_array_length(env, argv[0], &arrayReLength));
+        for (uint32_t index = 0; index < arrayReLength; index++) {
+            napi_value filesValue;
+            napi_get_element(env, argv[0], index, &filesValue);
+            std::string files = NapiPrintUtils::GetStringFromValueUtf8(env, filesValue);
+            PRINT_HILOGD("file[%{public}d] %{private}s.", index, files.c_str());
+            if (IsValidFile(files)) {
+                printfiles.emplace_back(files);
+            }
         }
-    }
-
-    std::shared_ptr<OHOS::AbilityRuntime::AbilityContext> abilityContext;
-    sptr<IRemoteObject> callerToken;
-    if (argc == NapiPrintUtils::ARGC_TWO && GetAbilityContext(env, argv[1], abilityContext) != nullptr) {
-        callerToken = abilityContext->GetToken();
-        PRINT_HILOGI("get callerToken:%{public}s", callerToken !=nullptr ? "success" : "failed");
-    }
 
-    auto task = new (std::nothrow) PrintTask(printfiles, callerToken);
-    if (task == nullptr) {
-        PRINT_HILOGE("print task fail");
-        return nullptr;
-    }
-    auto finalize = [](napi_env env, void *data, void *hint) {
-        PRINT_HILOGD("destructed print task");
-        PrintTask *task = reinterpret_cast<PrintTask *>(data);
-        delete task;
-    };
-    if (napi_wrap(env, self, task, finalize, nullptr, nullptr) != napi_ok) {
-        finalize(env, task, nullptr);
-        return nullptr;
+        std::shared_ptr<OHOS::AbilityRuntime::AbilityContext> abilityContext;
+        sptr<IRemoteObject> callerToken;
+        if (argc == NapiPrintUtils::ARGC_TWO && GetAbilityContext(env, argv[1], abilityContext) != nullptr) {
+            callerToken = abilityContext->GetToken();
+            PRINT_HILOGI("get callerToken:%{public}s", callerToken != nullptr ? "success" : "failed");
+        }
+        auto task = new (std::nothrow) PrintTask(printfiles, callerToken);
+        if (task == nullptr) {
+            PRINT_HILOGE("print task fail");
+            return nullptr;
+        }
+        auto finalize = [](napi_env env, void *data, void *hint) {
+            PRINT_HILOGD("destructed print task");
+            PrintTask *task = reinterpret_cast<PrintTask *>(data);
+            delete task;
+        };
+        if (napi_wrap(env, self, task, finalize, nullptr, nullptr) != napi_ok) {
+            finalize(env, task, nullptr);
+            return nullptr;
+        }
+        PRINT_HILOGD("Succeed to allocate print task");
+        return self;
     }
-    PRINT_HILOGD("Succeed to allocate print task");
-    return self;
 }
 
 bool NapiPrintTask::IsValidFile(const std::string &fileName)
@@ -202,6 +296,16 @@ bool NapiPrintTask::IsValidFile(const std::string &fileName)
 napi_status NapiPrintTask::VerifyParameters(napi_env env, size_t argc, napi_value *argv,
     const std::shared_ptr<PrintTaskContext> context)
 {
+    if (argc > NapiPrintUtils::ARGC_THREE) {
+        std::shared_ptr<OHOS::AbilityRuntime::AbilityContext> abilityContext;
+        if (GetAbilityContext(env, argv[NapiPrintUtils::ARGC_THREE], abilityContext) == nullptr) {
+            PRINT_HILOGE("Print adapter Ability Context is null.");
+            context->SetErrorIndex(E_PRINT_INVALID_PARAMETER);
+            return napi_invalid_arg;
+        }
+        return napi_ok;
+    }
+
     bool isFileArray = false;
 
     napi_is_array(env, argv[0], &isFileArray);
diff --git a/interfaces/kits/napi/src/print_module.cpp b/interfaces/kits/napi/src/print_module.cpp
index cca1bc720c8a83d4b607f57b6ab5595d560ad560..4c402abf2ffdf90a000a52d2cab420972f668afd 100644
--- a/interfaces/kits/napi/src/print_module.cpp
+++ b/interfaces/kits/napi/src/print_module.cpp
@@ -44,6 +44,7 @@ static constexpr const char *FUNCTION_UPDATE_EXTENSION_INFO = "updateExtensionIn
 static constexpr const char *FUNCTION_NATIVE_ADD_PRINTER_TO_CUPS = "addPrinterToCups";
 static constexpr const char *FUNCTION_QUERY_CAPABILITY_BY_URI = "queryPrinterCapabilityByUri";
 static constexpr const char *FUNCTION_START_GET_PRINT_FILE = "startGetPrintFile";
+static constexpr const char *FUNCTION_NOTIFY_PRINT_SERVICE = "notifyPrintService";
 
 static constexpr const char *PROPERTY_PRINTER_ADD = "PRINTER_ADDED";
 static constexpr const char *PROPERTY_PRINTER_REMOVE = "PRINTER_REMOVED";
@@ -299,6 +300,7 @@ static napi_value Init(napi_env env, napi_value exports)
         PRINT_NAPI_METHOD(FUNCTION_NATIVE_ADD_PRINTER_TO_CUPS, NapiPrintExt::AddPrinterToCups),
         PRINT_NAPI_METHOD(FUNCTION_QUERY_CAPABILITY_BY_URI, NapiPrintExt::QueryPrinterCapabilityByUri),
         PRINT_NAPI_METHOD(FUNCTION_START_GET_PRINT_FILE, NapiInnerPrint::StartGetPrintFile),
+        PRINT_NAPI_METHOD(FUNCTION_NOTIFY_PRINT_SERVICE, NapiInnerPrint::NotifyPrintService),
     };
 
     napi_status status = napi_define_properties(env, exports, sizeof(desc) / sizeof(napi_property_descriptor), desc);
diff --git a/interfaces/kits/napi/src/print_task.cpp b/interfaces/kits/napi/src/print_task.cpp
index 15aa52d8de07340d69d1753f12e3e2b7254ca77f..67c7249a5d0f45427124a694fe71f7ba93143ca5 100644
--- a/interfaces/kits/napi/src/print_task.cpp
+++ b/interfaces/kits/napi/src/print_task.cpp
@@ -55,6 +55,20 @@ PrintTask::PrintTask(const std::vector<std::string> &innerList, const sptr<IRemo
     callerToken_ = innerCallerToken_;
 }
 
+PrintTask::PrintTask(const std::string &innerPrintJobName_, const sptr<IPrintCallback> &innerPrintAdapterCallback_,
+    const std::shared_ptr<PrintAttributes> &innerPrintAttributes_, const sptr<IRemoteObject> &innerCallerToken_)
+    : taskId_("")
+{
+    supportEvents_[EVENT_BLOCK] = true;
+    supportEvents_[EVENT_SUCCESS] = true;
+    supportEvents_[EVENT_FAIL] = true;
+    supportEvents_[EVENT_CANCEL] = true;
+    printJobName_ = innerPrintJobName_;
+    printAdapterCallback_ = innerPrintAdapterCallback_;
+    printAttributes_ = innerPrintAttributes_;
+    callerToken_ = innerCallerToken_;
+}
+
 PrintTask::~PrintTask()
 {
     supportEvents_.clear();
@@ -86,6 +100,16 @@ uint32_t PrintTask::Start()
     }
 }
 
+uint32_t PrintTask::StartPrintAdapter()
+{
+    if (printAdapterCallback_ != nullptr && printAttributes_ != nullptr && callerToken_ != nullptr) {
+        PRINT_HILOGI("call client's StartPrintAdapter interface.");
+        return PrintManagerClient::GetInstance()->Print(
+            printJobName_, printAdapterCallback_, *printAttributes_, static_cast<void*>(callerToken_));
+    }
+    return E_PRINT_INVALID_PARAMETER;
+}
+
 void PrintTask::Stop()
 {
     PrintManagerClient::GetInstance()->StopPrint(taskId_);
diff --git a/services/include/print_service_ability.h b/services/include/print_service_ability.h
index fff472cc21dca8a27072a719fec557c317182d19..6e817947de3dc8e8bf8762213703d82fd5b8216d 100644
--- a/services/include/print_service_ability.h
+++ b/services/include/print_service_ability.h
@@ -86,6 +86,7 @@ public:
         const sptr<IRemoteObject> &token) override;
     int32_t StartGetPrintFile(const std::string &jobId, const PrintAttributes &printAttributes,
         const uint32_t fd) override;
+    int32_t NotifyPrintService(const std::string &jobId, const std::string &type) override;
 
 protected:
     void OnStart() override;
diff --git a/services/include/print_service_stub.h b/services/include/print_service_stub.h
index 66aefa3fcea3a125a095855f0f401729ee7a7d56..7907b0fc67afc4554c0a3622963928abee312054 100644
--- a/services/include/print_service_stub.h
+++ b/services/include/print_service_stub.h
@@ -58,6 +58,7 @@ private:
     bool OnQueryPrinterCapabilityByUri(MessageParcel &data, MessageParcel &reply);
     bool OnPrintByAdapter(MessageParcel &data, MessageParcel &reply);
     bool OnStartGetPrintFile(MessageParcel &data, MessageParcel &reply);
+    bool OnNotifyPrintService(MessageParcel &data, MessageParcel &reply);
 
 private:
     using PrintCmdHandler = bool (PrintServiceStub::*)(MessageParcel &, MessageParcel &);
diff --git a/services/src/print_service_ability.cpp b/services/src/print_service_ability.cpp
index f913c89d05140fee7a19c94ed94bd6c56311f212..6acf58e0c4b6608be7cf80817727d81dec6646be 100644
--- a/services/src/print_service_ability.cpp
+++ b/services/src/print_service_ability.cpp
@@ -1593,6 +1593,21 @@ int32_t PrintServiceAbility::StartGetPrintFile(const std::string &jobId, const P
     return E_PRINT_NONE;
 }
 
+int32_t PrintServiceAbility::NotifyPrintService(const std::string &jobId, const std::string &type)
+{
+    std::string permission = PERMISSION_NAME_PRINT_JOB;
+    if (!CheckPermission(permission)) {
+        PRINT_HILOGE("no permission to access print service");
+        return E_PRINT_NO_PERMISSION;
+    }
+
+    if (type == "0") {
+        PRINT_HILOGI("Notify Spooler Closed jobId : %{public}s", jobId.c_str());
+        return E_PRINT_NONE;
+    }
+    return E_PRINT_INVALID_PARAMETER;
+}
+
 void PrintServiceAbility::notifyAdapterJobChanged(const std::string jobId, const uint32_t state,
     const uint32_t subState)
 {
diff --git a/services/src/print_service_stub.cpp b/services/src/print_service_stub.cpp
index 2db1b4718df9acfd2c29a686a24d8f11a0580c52..55ce40461579b372924bf81b5157b631822c65ef 100644
--- a/services/src/print_service_stub.cpp
+++ b/services/src/print_service_stub.cpp
@@ -56,6 +56,7 @@ PrintServiceStub::PrintServiceStub()
         &PrintServiceStub::OnQueryPrinterCapabilityByUri;
     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_STARTPRINTJOB_BY_ADAPTER] = &PrintServiceStub::OnPrintByAdapter;
     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_START_GET_FILE] = &PrintServiceStub::OnStartGetPrintFile;
+    cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_NOTIFY_PRINT_SERVICE] = &PrintServiceStub::OnNotifyPrintService;
 }
 
 int32_t PrintServiceStub::OnRemoteRequest(
@@ -505,4 +506,17 @@ bool PrintServiceStub::OnStartGetPrintFile(MessageParcel &data, MessageParcel &r
     PRINT_HILOGI("PrintServiceStub::OnStartGetPrintFile out");
     return ret == E_PRINT_NONE;
 }
+
+bool PrintServiceStub::OnNotifyPrintService(MessageParcel &data, MessageParcel &reply)
+{
+    PRINT_HILOGD("PrintServiceStub::OnNotifyPrintService in");
+    std::string jobId = data.ReadString();
+    std::string type = data.ReadString();
+    PRINT_HILOGD(
+        "PrintServiceStub::OnNotifyPrintService jobId=%{public}s type=%{public}s ", jobId.c_str(), type.c_str());
+    int32_t ret = NotifyPrintService(jobId, type);
+    reply.WriteInt32(ret);
+    PRINT_HILOGD("PrintServiceStub::OnNotifyPrintService out");
+    return ret == E_PRINT_NONE;
+}
 } // namespace OHOS::Print
diff --git a/test/unittest/service_test/mock/mock_print_service.h b/test/unittest/service_test/mock/mock_print_service.h
index d093aa101be7131ec861bd1f5fcd829133453093..5a91a9336d7dd1d6f8ccd82017aa10d380ba1ca5 100644
--- a/test/unittest/service_test/mock/mock_print_service.h
+++ b/test/unittest/service_test/mock/mock_print_service.h
@@ -145,6 +145,10 @@ public:
     {
         return E_PRINT_NONE;
     }
+    int32_t NotifyPrintService(const std::string &jobId, const std::string &type) override
+    {
+        return E_PRINT_NONE;
+    }
 };
 
 class MockPrintService final : public DummyPrintServiceStub {