diff --git a/interfaces/innerkits/src/bundle_active_client.cpp b/interfaces/innerkits/src/bundle_active_client.cpp
index c24711db2241226cd90bf7e0410692c51cc199f4..8eabbe2f375686391ac0a5c8a4512338101d8ba9 100644
--- a/interfaces/innerkits/src/bundle_active_client.cpp
+++ b/interfaces/innerkits/src/bundle_active_client.cpp
@@ -31,6 +31,7 @@ BundleActiveClient& BundleActiveClient::GetInstance()
 
 ErrCode BundleActiveClient::GetBundleActiveProxy()
 {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     if (bundleActiveProxy_ != nullptr) {
         return ERR_OK;
     }
@@ -74,43 +75,43 @@ ErrCode BundleActiveClient::GetBundleActiveProxy()
 ErrCode BundleActiveClient::ReportEvent(BundleActiveEvent event, const int32_t userId)
 {
     BUNDLE_ACTIVE_LOGI("BundleActiveClient::ReportEvent called");
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     return bundleActiveProxy_->ReportEvent(event, userId);
 }
 
 ErrCode BundleActiveClient::IsBundleIdle(bool& isBundleIdle, const std::string& bundleName, int32_t userId)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     return bundleActiveProxy_->IsBundleIdle(isBundleIdle, bundleName, userId);
 }
 
 ErrCode BundleActiveClient::QueryBundleStatsInfoByInterval(std::vector<BundleActivePackageStats>& PackageStats,
     const int32_t intervalType, const int64_t beginTime, const int64_t endTime, int32_t userId)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     return bundleActiveProxy_->QueryBundleStatsInfoByInterval(PackageStats, intervalType, beginTime, endTime, userId);
 }
 
 ErrCode BundleActiveClient::QueryBundleEvents(std::vector<BundleActiveEvent>& bundleActiveEvents,
     const int64_t beginTime, const int64_t endTime, int32_t userId)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     auto err = bundleActiveProxy_->QueryBundleEvents(bundleActiveEvents, beginTime, endTime, userId);
     BUNDLE_ACTIVE_LOGI("QueryBundleEvents bundleActiveEvents is %{public}zu", bundleActiveEvents.size());
     return err;
@@ -118,43 +119,43 @@ ErrCode BundleActiveClient::QueryBundleEvents(std::vector<BundleActiveEvent>& bu
 
 ErrCode BundleActiveClient::SetAppGroup(std::string bundleName, const int32_t newGroup, int32_t userId)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     return bundleActiveProxy_->SetAppGroup(bundleName, newGroup, userId);
 }
 
 ErrCode BundleActiveClient::QueryBundleStatsInfos(std::vector<BundleActivePackageStats>& bundleActivePackageStats,
     const int32_t intervalType, const int64_t beginTime, const int64_t endTime)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     return bundleActiveProxy_->QueryBundleStatsInfos(bundleActivePackageStats, intervalType, beginTime, endTime);
 }
 
 ErrCode BundleActiveClient::QueryCurrentBundleEvents(std::vector<BundleActiveEvent>& bundleActiveEvents,
     const int64_t beginTime, const int64_t endTime)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     return bundleActiveProxy_->QueryCurrentBundleEvents(bundleActiveEvents, beginTime, endTime);
 }
 
 ErrCode BundleActiveClient::QueryAppGroup(int32_t& appGroup, std::string& bundleName, const int32_t userId)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     return bundleActiveProxy_->QueryAppGroup(appGroup, bundleName, userId);
 }
 
@@ -165,21 +166,21 @@ ErrCode BundleActiveClient::QueryModuleUsageRecords(int32_t maxNum, std::vector<
         BUNDLE_ACTIVE_LOGI("maxNum is illegal, maxNum is %{public}d", maxNum);
         return ERR_MAX_RECORDS_NUM_BIGER_THEN_ONE_THOUSAND;
     }
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     return bundleActiveProxy_->QueryModuleUsageRecords(maxNum, results, userId);
 }
 
 ErrCode BundleActiveClient::RegisterAppGroupCallBack(const sptr<IAppGroupCallback> &observer)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ret = bundleActiveProxy_->RegisterAppGroupCallBack(observer);
     if (recipient_ && ret == ERR_OK) {
         recipient_->AddObserver(observer);
@@ -189,11 +190,11 @@ ErrCode BundleActiveClient::RegisterAppGroupCallBack(const sptr<IAppGroupCallbac
 
 ErrCode BundleActiveClient::UnRegisterAppGroupCallBack(const sptr<IAppGroupCallback> &observer)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ret = bundleActiveProxy_->UnRegisterAppGroupCallBack(observer);
     if (recipient_ && ret == ERR_OK) {
         recipient_->RemoveObserver();
@@ -204,22 +205,22 @@ ErrCode BundleActiveClient::UnRegisterAppGroupCallBack(const sptr<IAppGroupCallb
 ErrCode BundleActiveClient::QueryDeviceEventStats(int64_t beginTime, int64_t endTime,
     std::vector<BundleActiveEventStats>& eventStats, int32_t userId)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     return bundleActiveProxy_->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
 }
 
 ErrCode BundleActiveClient::QueryNotificationEventStats(int64_t beginTime, int64_t endTime,
     std::vector<BundleActiveEventStats>& eventStats, int32_t userId)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     ErrCode ret = GetBundleActiveProxy();
     if (ret != ERR_OK) {
         return ret;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     return bundleActiveProxy_->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
 }
 
@@ -242,8 +243,10 @@ void BundleActiveClient::BundleActiveClientDeathRecipient::RemoveObserver()
 void BundleActiveClient::BundleActiveClientDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &object)
 {
     (void)object;
-    std::lock_guard<std::recursive_mutex> lock(BundleActiveClient::GetInstance().mutex_);
-    BundleActiveClient::GetInstance().bundleActiveProxy_ = nullptr;
+    {
+        std::lock_guard<std::recursive_mutex> lock(BundleActiveClient::GetInstance().mutex_);
+        BundleActiveClient::GetInstance().bundleActiveProxy_ = nullptr;
+    }
     BundleActiveClient::GetInstance().bundleClientHandler_->PostTask([this]() {
             this->OnServiceDiedInner();
         }, DELAY_TIME);
@@ -251,10 +254,12 @@ void BundleActiveClient::BundleActiveClientDeathRecipient::OnRemoteDied(const wp
 
 void BundleActiveClient::BundleActiveClientDeathRecipient::OnServiceDiedInner()
 {
-    std::lock_guard<std::recursive_mutex> lock(BundleActiveClient::GetInstance().mutex_);
-    while (BundleActiveClient::GetInstance().GetBundleActiveProxy() != ERR_OK) {
+    int32_t loopTimes = 5;
+    while ((BundleActiveClient::GetInstance().GetBundleActiveProxy() != ERR_OK) && (loopTimes > 0)) {
         sleep(SLEEP_TIME);
+        loopTimes--;
     }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     if (observer_) {
         BundleActiveClient::GetInstance().RegisterAppGroupCallBack(observer_);
     }
diff --git a/interfaces/innerkits/src/bundle_active_proxy.cpp b/interfaces/innerkits/src/bundle_active_proxy.cpp
index 4b01289dcce2a27653f725347754a4a8a3275348..cd6b4dc71bbd631c3e9d5132bbb51d579f7d6a21 100644
--- a/interfaces/innerkits/src/bundle_active_proxy.cpp
+++ b/interfaces/innerkits/src/bundle_active_proxy.cpp
@@ -19,15 +19,18 @@ namespace OHOS {
 namespace DeviceUsageStats {
 ErrCode BundleActiveProxy::ReportEvent(BundleActiveEvent& event, const int32_t userId)
 {
+    auto remote = Remote();
+    if (remote == nullptr) {
+        BUNDLE_ACTIVE_LOGE("device_usage_statistics remote is dead.");
+        return ERR_IPC_COMMUNICATION_FAILED;
+    }
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
+    if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(userId) || !event.Marshalling(data)) {
         return ERR_PARCEL_WRITE_FALIED;
     }
-    data.WriteInt32(userId);
-    event.Marshalling(data);
-    Remote() -> SendRequest(REPORT_EVENT, data, reply, option);
+    remote -> SendRequest(REPORT_EVENT, data, reply, option);
 
     int32_t result = reply.ReadInt32();
     return result;
@@ -35,15 +38,18 @@ ErrCode BundleActiveProxy::ReportEvent(BundleActiveEvent& event, const int32_t u
 
 ErrCode BundleActiveProxy::IsBundleIdle(bool& isBundleIdle, const std::string& bundleName, int32_t userId)
 {
+    auto remote = Remote();
+    if (remote == nullptr) {
+        BUNDLE_ACTIVE_LOGE("device_usage_statistics remote is dead.");
+        return ERR_IPC_COMMUNICATION_FAILED;
+    }
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor()) ||
-        !data.WriteString(bundleName) ||
-        !data.WriteInt32(userId)) {
+    if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(bundleName) || !data.WriteInt32(userId)) {
         return ERR_PARCEL_WRITE_FALIED;
     }
-    Remote() -> SendRequest(IS_BUNDLE_IDLE, data, reply, option);
+    remote -> SendRequest(IS_BUNDLE_IDLE, data, reply, option);
     isBundleIdle = reply.ReadInt32();
     return reply.ReadInt32();
 }
@@ -51,17 +57,19 @@ ErrCode BundleActiveProxy::IsBundleIdle(bool& isBundleIdle, const std::string& b
 ErrCode BundleActiveProxy::QueryBundleStatsInfoByInterval(std::vector<BundleActivePackageStats>& PackageStats,
     const int32_t intervalType, const int64_t beginTime, const int64_t endTime, int32_t userId)
 {
+    auto remote = Remote();
+    if (remote == nullptr) {
+        BUNDLE_ACTIVE_LOGE("device_usage_statistics remote is dead.");
+        return ERR_IPC_COMMUNICATION_FAILED;
+    }
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
+    if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(intervalType) || !data.WriteInt64(beginTime) ||
+        !data.WriteInt64(endTime) || !data.WriteInt32(userId)) {
         return ERR_PARCEL_WRITE_FALIED;
     }
-    data.WriteInt32(intervalType);
-    data.WriteInt64(beginTime);
-    data.WriteInt64(endTime);
-    data.WriteInt32(userId);
-    Remote() -> SendRequest(QUERY_BUNDLE_STATS_INFO_BY_INTERVAL, data, reply, option);
+    remote -> SendRequest(QUERY_BUNDLE_STATS_INFO_BY_INTERVAL, data, reply, option);
     ErrCode errCode = reply.ReadInt32();
     int32_t size = reply.ReadInt32();
     std::shared_ptr<BundleActivePackageStats> tmp;
@@ -86,16 +94,19 @@ ErrCode BundleActiveProxy::QueryBundleStatsInfoByInterval(std::vector<BundleActi
 ErrCode BundleActiveProxy::QueryBundleEvents(std::vector<BundleActiveEvent>& bundleActiveEvents,
     const int64_t beginTime, const int64_t endTime, int32_t userId)
 {
+    auto remote = Remote();
+    if (remote == nullptr) {
+        BUNDLE_ACTIVE_LOGE("device_usage_statistics remote is dead.");
+        return ERR_IPC_COMMUNICATION_FAILED;
+    }
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
+    if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt64(beginTime) ||
+        !data.WriteInt64(endTime) || !data.WriteInt32(userId)) {
         return ERR_PARCEL_WRITE_FALIED;
     }
-    data.WriteInt64(beginTime);
-    data.WriteInt64(endTime);
-    data.WriteInt32(userId);
-    Remote() -> SendRequest(QUERY_BUNDLE_EVENTS, data, reply, option);
+    remote -> SendRequest(QUERY_BUNDLE_EVENTS, data, reply, option);
     ErrCode errCode = reply.ReadInt32();
     int32_t size = reply.ReadInt32();
     std::shared_ptr<BundleActiveEvent> tmp;
@@ -114,33 +125,39 @@ ErrCode BundleActiveProxy::QueryBundleEvents(std::vector<BundleActiveEvent>& bun
 
 ErrCode BundleActiveProxy::SetAppGroup(const std::string& bundleName, int32_t newGroup, int32_t userId)
 {
+    auto remote = Remote();
+    if (remote == nullptr) {
+        BUNDLE_ACTIVE_LOGE("device_usage_statistics remote is dead.");
+        return ERR_IPC_COMMUNICATION_FAILED;
+    }
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
+    if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(bundleName) || !data.WriteInt32(newGroup) ||
+        !data.WriteInt32(userId)) {
         return ERR_PARCEL_WRITE_FALIED;
     }
-    data.WriteString(bundleName);
-    data.WriteInt32(newGroup);
-    data.WriteInt32(userId);
 
-    Remote() -> SendRequest(SET_APP_GROUP, data, reply, option);
+    remote -> SendRequest(SET_APP_GROUP, data, reply, option);
     return reply.ReadInt32();
 }
 
 ErrCode BundleActiveProxy::QueryBundleStatsInfos(std::vector<BundleActivePackageStats>& bundleActivePackageStats,
     const int32_t intervalType, const int64_t beginTime, const int64_t endTime)
 {
+    auto remote = Remote();
+    if (remote == nullptr) {
+        BUNDLE_ACTIVE_LOGE("device_usage_statistics remote is dead.");
+        return ERR_IPC_COMMUNICATION_FAILED;
+    }
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
+    if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(intervalType) || !data.WriteInt64(beginTime) ||
+        !data.WriteInt64(endTime)) {
         return ERR_PARCEL_WRITE_FALIED;
     }
-    data.WriteInt32(intervalType);
-    data.WriteInt64(beginTime);
-    data.WriteInt64(endTime);
-    Remote() -> SendRequest(QUERY_BUNDLE_STATS_INFOS, data, reply, option);
+    remote -> SendRequest(QUERY_BUNDLE_STATS_INFOS, data, reply, option);
     ErrCode errCode = reply.ReadInt32();
     int32_t size = reply.ReadInt32();
     std::shared_ptr<BundleActivePackageStats> tmp;
@@ -167,15 +184,18 @@ ErrCode BundleActiveProxy::QueryBundleStatsInfos(std::vector<BundleActivePackage
 ErrCode BundleActiveProxy::QueryCurrentBundleEvents(std::vector<BundleActiveEvent>& bundleActiveEvents,
     const int64_t beginTime, const int64_t endTime)
 {
+    auto remote = Remote();
+    if (remote == nullptr) {
+        BUNDLE_ACTIVE_LOGE("device_usage_statistics remote is dead.");
+        return ERR_IPC_COMMUNICATION_FAILED;
+    }
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
+    if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt64(beginTime) || !data.WriteInt64(endTime)) {
         return ERR_PARCEL_WRITE_FALIED;
     }
-    data.WriteInt64(beginTime);
-    data.WriteInt64(endTime);
-    Remote() -> SendRequest(QUERY_CURRENT_BUNDLE_EVENTS, data, reply, option);
+    remote -> SendRequest(QUERY_CURRENT_BUNDLE_EVENTS, data, reply, option);
     ErrCode errCode = reply.ReadInt32();
     int32_t size = reply.ReadInt32();
     std::shared_ptr<BundleActiveEvent> tmp;
@@ -196,17 +216,19 @@ ErrCode BundleActiveProxy::QueryCurrentBundleEvents(std::vector<BundleActiveEven
 
 ErrCode BundleActiveProxy::QueryAppGroup(int32_t& appGroup, std::string& bundleName, const int32_t userId)
 {
+    auto remote = Remote();
+    if (remote == nullptr) {
+        BUNDLE_ACTIVE_LOGE("device_usage_statistics remote is dead.");
+        return ERR_IPC_COMMUNICATION_FAILED;
+    }
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
 
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
+    if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(bundleName) || !data.WriteInt32(userId)) {
         return ERR_PARCEL_WRITE_FALIED;
     }
-
-    data.WriteString(bundleName);
-    data.WriteInt32(userId);
-    Remote() -> SendRequest(QUERY_APP_GROUP, data, reply, option);
+    remote -> SendRequest(QUERY_APP_GROUP, data, reply, option);
     appGroup = reply.ReadInt32();
     return reply.ReadInt32();
 }
@@ -214,15 +236,18 @@ ErrCode BundleActiveProxy::QueryAppGroup(int32_t& appGroup, std::string& bundleN
 ErrCode BundleActiveProxy::QueryModuleUsageRecords(int32_t maxNum, std::vector<BundleActiveModuleRecord>& results,
     int32_t userId)
 {
+    auto remote = Remote();
+    if (remote == nullptr) {
+        BUNDLE_ACTIVE_LOGE("device_usage_statistics remote is dead.");
+        return ERR_IPC_COMMUNICATION_FAILED;
+    }
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
+    if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(maxNum) || !data.WriteInt32(userId)) {
         return ERR_PARCEL_WRITE_FALIED;
     }
-    data.WriteInt32(maxNum);
-    data.WriteInt32(userId);
-    Remote() -> SendRequest(QUERY_MODULE_USAGE_RECORDS, data, reply, option);
+    remote -> SendRequest(QUERY_MODULE_USAGE_RECORDS, data, reply, option);
     ErrCode errCode = reply.ReadInt32();
     int32_t size = reply.ReadInt32();
     std::shared_ptr<BundleActiveModuleRecord> tmp;
@@ -253,6 +278,11 @@ ErrCode BundleActiveProxy::RegisterAppGroupCallBack(const sptr<IAppGroupCallback
         BUNDLE_ACTIVE_LOGE("RegisterAppGroupCallBack observer is nullptr");
         return ERR_MEMORY_OPERATION_FAILED;
     }
+    auto remote = Remote();
+    if (remote == nullptr) {
+        BUNDLE_ACTIVE_LOGE("device_usage_statistics remote is dead.");
+        return ERR_IPC_COMMUNICATION_FAILED;
+    }
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
@@ -264,7 +294,7 @@ ErrCode BundleActiveProxy::RegisterAppGroupCallBack(const sptr<IAppGroupCallback
         BUNDLE_ACTIVE_LOGE("RegisterAppGroupCallBack observer write failed.");
         return ERR_PARCEL_WRITE_FALIED;
     }
-    int32_t ret = Remote()->SendRequest(REGISTER_APP_GROUP_CALLBACK, data, reply, option);
+    int32_t ret = remote->SendRequest(REGISTER_APP_GROUP_CALLBACK, data, reply, option);
     if (ret!= ERR_OK) {
         BUNDLE_ACTIVE_LOGE("RegisterAppGroupCallBack SendRequest failed, error code: %{public}d", ret);
     }
@@ -277,6 +307,11 @@ ErrCode BundleActiveProxy::UnRegisterAppGroupCallBack(const sptr<IAppGroupCallba
         BUNDLE_ACTIVE_LOGE("UnRegisterAppGroupCallBack observer is nullptr");
         return ERR_MEMORY_OPERATION_FAILED;
     }
+    auto remote = Remote();
+    if (remote == nullptr) {
+        BUNDLE_ACTIVE_LOGE("device_usage_statistics remote is dead.");
+        return ERR_IPC_COMMUNICATION_FAILED;
+    }
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
@@ -287,7 +322,7 @@ ErrCode BundleActiveProxy::UnRegisterAppGroupCallBack(const sptr<IAppGroupCallba
         BUNDLE_ACTIVE_LOGE("UnRegisterAppGroupCallBack observer write failed.");
         return ERR_PARCEL_WRITE_FALIED;
     }
-    Remote()->SendRequest(UNREGISTER_APP_GROUP_CALLBACK, data, reply, option);
+    remote ->SendRequest(UNREGISTER_APP_GROUP_CALLBACK, data, reply, option);
     return reply.ReadInt32();
 }
 
@@ -316,16 +351,19 @@ ErrCode BundleActiveProxy::QueryNotificationEventStats(int64_t beginTime, int64_
 ErrCode BundleActiveProxy::IPCCommunication(int64_t beginTime, int64_t endTime,
     std::vector<BundleActiveEventStats>& eventStats, int32_t userId, int32_t communicationFlag)
 {
+    auto remote = Remote();
+    if (remote == nullptr) {
+        BUNDLE_ACTIVE_LOGE("device_usage_statistics remote is dead.");
+        return ERR_IPC_COMMUNICATION_FAILED;
+    }
     MessageParcel data;
     MessageParcel reply;
     MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
+    if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt64(beginTime) ||
+        !data.WriteInt64(endTime) || !data.WriteInt32(userId)) {
         return ERR_PARCEL_WRITE_FALIED;
     }
-    data.WriteInt64(beginTime);
-    data.WriteInt64(endTime);
-    data.WriteInt32(userId);
-    Remote() -> SendRequest(communicationFlag, data, reply, option);
+    remote -> SendRequest(communicationFlag, data, reply, option);
     ErrCode errCode = reply.ReadInt32();
     int32_t size = reply.ReadInt32();
     std::shared_ptr<BundleActiveEventStats> tmp;