fix: 根据检视意见修改

1. 源码权限更改为644
2. 修复智能指针未判空就使用的问题
3. 将部分文件名修改得更易理解

Signed-off-by: Far <yesiyuan2@huawei.com>

frameworks/js/napi/include/event_listener_manager.h

@@ -22,6 +22,7 @@
 #include "event_listener.h"
 #include "event_listener_handler.h"
 #include "telephony_update_event_type.h"
+#include "telephony_log_wrapper.h"
 
 namespace OHOS {
 namespace Telephony {
@@ -30,7 +31,12 @@ public:
     template<typename T, typename D>
     inline static bool SendEvent(uint32_t innerEventId, std::unique_ptr<T, D> &object, int64_t delayTime = 0)
     {
-        return DelayedSingleton<EventListenerHandler>::GetInstance()->SendEvent(innerEventId, object, delayTime);
+        auto handler = DelayedSingleton<EventListenerHandler>::GetInstance();
+        if (handler == nullptr) {
+            TELEPHONY_LOGE("Get handler failed");
+            return false;
+        }
+        return handler->SendEvent(innerEventId, object, delayTime);
     }
     static std::optional<int32_t> RegisterEventListener(EventListener &eventListener);
     static std::optional<int32_t> UnregisterEventListener(int32_t slotId, const TelephonyUpdateEventType eventType);
@@ -38,4 +44,4 @@ public:
 };
 } // namespace Telephony
 } // namespace OHOS
-#endif // EVENT_LISTENER_MANAGER_H
+#endif // EVENT_LISTENER_MANAGER_H

frameworks/js/napi/include/update_infos.h

@@ -30,7 +30,7 @@ namespace OHOS {
 namespace Telephony {
 struct UpdateInfo {
     int32_t slotId_ = 0;
-    UpdateInfo(int32_t slotId) : slotId_(slotId) {}
+    explicit UpdateInfo(int32_t slotId) : slotId_(slotId) {}
 };
 
 struct CallStateUpdateInfo : public UpdateInfo {
@@ -83,4 +83,4 @@ struct CellularDataFlowUpdate : public UpdateInfo {
 };
 } // namespace Telephony
 } // namespace OHOS
-#endif // UPDATE_INFOS_H
+#endif // UPDATE_INFOS_H

frameworks/js/napi/src/event_listener_handler.cpp

@@ -122,7 +122,12 @@ napi_status NapiReturnToJS(napi_env env, napi_ref callbackRef, napi_value callba
     if (status != napi_ok) {
         TELEPHONY_LOGE("NapiReturnToJS napi_call_function return error : %{public}d", status);
     }
-    DelayedSingleton<EventListenerHandler>::GetInstance()->SetCallbackCompleteToListener(callbackRef);
+    auto handler = DelayedSingleton<EventListenerHandler>::GetInstance();
+    if (handler == nullptr) {
+        TELEPHONY_LOGE("Get event handler failed");
+        return status;
+    }
+    handler->SetCallbackCompleteToListener(callbackRef);
     return status;
 }
 
@@ -342,7 +347,7 @@ void EventListenerHandler::RemoveListener(TelephonyUpdateEventType eventType)
             if (listener.env != nullptr && listener.callbackRef != nullptr) {
                 napi_delete_reference(listener.env, listener.callbackRef);
             }
-        };
+        }
         return matched;
     });
 }
@@ -544,4 +549,4 @@ void EventListenerHandler::WorkCellularDataFlowUpdate(uv_work_t *work, int statu
     NapiReturnToJS(dataFlowInfo->env, dataFlowInfo->callbackRef, callbackValue);
 }
 } // namespace Telephony
-} // namespace OHOS
+} // namespace OHOS

frameworks/js/napi/src/event_listener_manager.cpp

@@ -20,18 +20,32 @@ namespace OHOS {
 namespace Telephony {
 std::optional<int32_t> EventListenerManager::RegisterEventListener(EventListener &eventListener)
 {
-    return DelayedSingleton<EventListenerHandler>::GetInstance()->RegisterEventListener(eventListener);
+    auto handler = DelayedSingleton<EventListenerHandler>::GetInstance();
+    if (handler == nullptr) {
+        TELEPHONY_LOGE("Get event handler failed");
+        return std::nullopt;
+    }
+    return handler->RegisterEventListener(eventListener);
 }
 
 std::optional<int32_t> EventListenerManager::UnregisterEventListener(
     int32_t slotId, const TelephonyUpdateEventType eventType)
 {
-    return DelayedSingleton<EventListenerHandler>::GetInstance()->UnregisterEventListener(slotId, eventType);
+    auto handler = DelayedSingleton<EventListenerHandler>::GetInstance();
+    if (handler == nullptr) {
+        TELEPHONY_LOGE("Get event handler failed");
+        return std::nullopt;
+    }
+    return handler->UnregisterEventListener(slotId, eventType);
 }
 
 void EventListenerManager::RemoveListener(TelephonyUpdateEventType eventType)
 {
-    DelayedSingleton<EventListenerHandler>::GetInstance()->RemoveListener(eventType);
+    auto handler = DelayedSingleton<EventListenerHandler>::GetInstance();
+    if (handler == nullptr) {
+        TELEPHONY_LOGE("Get event handler failed");
+    }
+    handler->RemoveListener(eventType);
 }
 } // namespace Telephony
-} // namespace OHOS
+} // namespace OHOS

frameworks/js/napi/src/napi_state_registry.cpp

@@ -197,8 +197,8 @@ static napi_module _stateRegistryModule = {
     .nm_filename = nullptr,
     .nm_register_func = InitNapiStateRegistry,
     .nm_modname = "telephony.observer",
-    .nm_priv = ((void *)0),
-    .reserved = {(void *)0},
+    .nm_priv = nullptr,
+    .reserved = {nullptr},
 };
 
 extern "C" __attribute__((constructor)) void RegisterTelephonyObserverModule(void)

frameworks/js/napi/src/napi_telephony_observer.cpp

@@ -26,6 +26,10 @@ void NapiTelephonyObserver::OnCallStateUpdated(int32_t slotId, int32_t callState
     TELEPHONY_LOGI("OnCallStateUpdated slotId = %{public}d, callState = %{public}d", slotId, callState);
     std::unique_ptr<CallStateUpdateInfo> callStateInfo =
         std::make_unique<CallStateUpdateInfo>(slotId, callState, phoneNumber);
+    if (callStateInfo == nullptr) {
+        TELEPHONY_LOGE("callStateInfo is nullptr!");
+        return;
+    }
     EventListenerManager::SendEvent(ToUint32t(TelephonyCallbackEventId::EVENT_ON_CALL_STATE_UPDATE), callStateInfo);
 }
 
@@ -37,6 +41,7 @@ void NapiTelephonyObserver::OnSignalInfoUpdated(
     std::unique_ptr<SignalUpdateInfo> infoList = std::make_unique<SignalUpdateInfo>(slotId, signalInfoList);
     if (infoList == nullptr) {
         TELEPHONY_LOGE("SignalUpdateInfo is nullptr!");
+        return;
     }
     EventListenerManager::SendEvent(ToUint32t(TelephonyCallbackEventId::EVENT_ON_SIGNAL_INFO_UPDATE), infoList);
 }
@@ -49,6 +54,7 @@ void NapiTelephonyObserver::OnNetworkStateUpdated(int32_t slotId, const sptr<Net
         std::make_unique<NetworkStateUpdateInfo>(slotId, networkState);
     if (networkStateUpdateInfo == nullptr) {
         TELEPHONY_LOGE("NetworkStateUpdateInfo is nullptr!");
+        return;
     }
     EventListenerManager::SendEvent(
         ToUint32t(TelephonyCallbackEventId::EVENT_ON_NETWORK_STATE_UPDATE), networkStateUpdateInfo);
@@ -62,6 +68,7 @@ void NapiTelephonyObserver::OnSimStateUpdated(
         std::make_unique<SimStateUpdateInfo>(slotId, type, state, reason);
     if (simStateUpdateInfo == nullptr) {
         TELEPHONY_LOGE("SimStateUpdateInfo is nullptr!");
+        return;
     }
     EventListenerManager::SendEvent(
         ToUint32t(TelephonyCallbackEventId::EVENT_ON_SIM_STATE_UPDATE), simStateUpdateInfo);
@@ -73,6 +80,7 @@ void NapiTelephonyObserver::OnCellInfoUpdated(int32_t slotId, const std::vector<
     std::unique_ptr<CellInfomationUpdate> cellInfo = std::make_unique<CellInfomationUpdate>(slotId, vec);
     if (cellInfo == nullptr) {
         TELEPHONY_LOGE("CellInfomationUpdate is nullptr!");
+        return;
     }
     EventListenerManager::SendEvent(ToUint32t(TelephonyCallbackEventId::EVENT_ON_CELL_INFOMATION_UPDATE), cellInfo);
 }
@@ -88,6 +96,7 @@ void NapiTelephonyObserver::OnCellularDataConnectStateUpdated(
         std::make_unique<CellularDataConnectState>(slotId, dataState, networkType);
     if (cellularDataConnectState == nullptr) {
         TELEPHONY_LOGE("OnCellularDataConnectStateUpdated cellularDataConnectState is nullptr!");
+        return;
     }
     EventListenerManager::SendEvent(
         ToUint32t(TelephonyCallbackEventId::EVENT_ON_CELLULAR_DATA_CONNECTION_UPDATE), cellularDataConnectState);
@@ -101,9 +110,10 @@ void NapiTelephonyObserver::OnCellularDataFlowUpdated(int32_t slotId, int32_t da
         std::make_unique<CellularDataFlowUpdate>(slotId, dataFlowType);
     if (cellularDataFlowUpdateInfo == nullptr) {
         TELEPHONY_LOGE("CellularDataFlowUpdate is nullptr!");
+        return;
     }
     EventListenerManager::SendEvent(
         ToUint32t(TelephonyCallbackEventId::EVENT_ON_CELLULAR_DATA_FLOW_UPDATE), cellularDataFlowUpdateInfo);
 }
 } // namespace Telephony
-} // namespace OHOS
+} // namespace OHOS

frameworks/native/observer/include/telephony_observer.h

@@ -28,8 +28,8 @@ namespace OHOS {
 namespace Telephony {
 class TelephonyObserver : public IRemoteStub<TelephonyObserverBroker> {
 public:
-    TelephonyObserver() {};
-    ~TelephonyObserver() {};
+    TelephonyObserver() {}
+    ~TelephonyObserver() {}
     virtual void OnCallStateUpdated(
         int32_t slotId, int32_t callState, const std::u16string &phoneNumber) override;
     virtual void OnSignalInfoUpdated(

service/src/telephony_state_registry_dump_helper.cpp

@@ -58,19 +58,25 @@ bool TelephonyStateRegistryDumpHelper::ShowTelephonyStateRegistryInfo(
             result.append("\n");
         }
     }
+    std::shared_ptr<TelephonyStateRegistryService> service =
+        DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
+    if (service == nullptr) {
+        TELEPHONY_LOGE("Get state registry service failed");
+        return false;
+    }
     result.append("BindStartTime: ");
     result.append(
-        DelayedSingleton<TelephonyStateRegistryService>::GetInstance()->GetBindStartTime());
+        service->GetBindStartTime());
     result.append("\n");
     result.append("BindEndTime: ");
     result.append(
-        DelayedSingleton<TelephonyStateRegistryService>::GetInstance()->GetBindEndTime());
+        service->GetBindEndTime());
     result.append("\n");
     result.append("BindSpendTime: ");
     result.append(
-        DelayedSingleton<TelephonyStateRegistryService>::GetInstance()->GetBindSpendTime());
+        service->GetBindSpendTime());
     result.append("\n");
     return true;
 }
 } // namespace Telephony
-} // namespace OHOS
+} // namespace OHOS

service/src/telephony_state_registry_service.cpp

@@ -283,7 +283,6 @@ int32_t TelephonyStateRegistryService::RegisterStateChange(
         return TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED;
     }
     std::lock_guard<std::mutex> guard(lock_);
-    int32_t result = TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST;
     bool isExist = false;
     TelephonyStateRegistryRecord record;
     for (size_t i = 0; i < stateRecords_.size(); i++) {
@@ -301,7 +300,6 @@ int32_t TelephonyStateRegistryService::RegisterStateChange(
         record.bundleName_ = bundleName;
         record.telephonyObserver_ = telephonyObserver;
         stateRecords_.push_back(record);
-        result = TELEPHONY_SUCCESS;
     }
 
     if (isUpdate && VerifySlotId(slotId)) {
@@ -564,4 +562,4 @@ std::string TelephonyStateRegistryService::GetBindSpendTime()
     return oss.str();
 }
 } // namespace Telephony
-} // namespace OHOS
+} // namespace OHOS

test/unittest/state_test/state_registry_test.cpp

@@ -76,6 +76,7 @@ void StateRegistryTest::UpdateSignalInfo()
     std::unique_ptr<SignalInformation> signal = std::make_unique<GsmSignalInformation>();
     if (signal == nullptr) {
         TELEPHONY_LOGE("SignalInformation is nullptr\n");
+        return;
     }
     vec.push_back(signal.release());
     DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().
@@ -115,6 +116,7 @@ void StateRegistryTest::UpdateNetworkState()
     std::unique_ptr<NetworkState> networkState = std::make_unique<NetworkState>();
     if (networkState == nullptr) {
         TELEPHONY_LOGE("NetworkState is nullptr\n");
+        return;
     }
     DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().
         UpdateNetworkState(slotId, networkState.release());