1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "system_param_manager.h"
17
18 #include "iservice_registry.h"
19 #include "parameter.h"
20 #include "system_ability_definition.h"
21 #include "system_ability_status_change_stub.h"
22
23 #include "iam_check.h"
24 #include "iam_common_defines.h"
25 #include "iam_logger.h"
26
27 #define LOG_TAG "USER_AUTH_SA"
28
29 namespace OHOS {
30 namespace UserIam {
31 namespace UserAuth {
32 namespace {
33 const char SYSTEM_VALUE_TRUE[] = "true";
34 const char IAM_ENABLE_FINGERPRINT_PARAM[] = "persist.useriam.enable.fingerprintauth";
35
IsEnableValue(const char * value)36 bool IsEnableValue(const char *value)
37 {
38 return (strcmp(value, SYSTEM_VALUE_TRUE) == 0);
39 }
40
ParameterChange(const char * key,const char * value,void * context)41 void ParameterChange(const char *key, const char *value, void *context)
42 {
43 if ((key == nullptr) || (value == nullptr)) {
44 IAM_LOGE("return invalid param");
45 return;
46 }
47 IAM_LOGI("receive param %{public}s:%{public}s", key, value);
48 if (strcmp(key, IAM_ENABLE_FINGERPRINT_PARAM) != 0) {
49 IAM_LOGE("event key mismatch");
50 return;
51 }
52 SystemParamManager::GetInstance().UpdateFingerAuthEnable(IsEnableValue(value));
53 }
54 }
55
56 class SystemParamServiceStatusListener : public OHOS::SystemAbilityStatusChangeStub, public NoCopyable {
57 public:
58 static void Subscribe();
59
60 void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
61 void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
62
63 private:
64 static sptr<SystemParamServiceStatusListener> GetInstance();
65
SystemParamServiceStatusListener()66 SystemParamServiceStatusListener() {};
~SystemParamServiceStatusListener()67 ~SystemParamServiceStatusListener() override {};
68 };
69
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)70 void SystemParamServiceStatusListener::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
71 {
72 if (systemAbilityId != PARAM_WATCHER_DISTRIBUTED_SERVICE_ID) {
73 return;
74 }
75
76 IAM_LOGI("param watcher service add process begin");
77 int32_t ret = WatchParameter(IAM_ENABLE_FINGERPRINT_PARAM, ParameterChange, nullptr);
78 if (ret != 0) {
79 IAM_LOGE("WatchParameter fail %{public}d", ret);
80 }
81 IAM_LOGI("param watcher service add process finish");
82 }
83
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)84 void SystemParamServiceStatusListener::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
85 {
86 if (systemAbilityId != PARAM_WATCHER_DISTRIBUTED_SERVICE_ID) {
87 return;
88 }
89
90 IAM_LOGE("param watcher service remove process begin");
91 int32_t ret = RemoveParameterWatcher(IAM_ENABLE_FINGERPRINT_PARAM, ParameterChange, nullptr);
92 if (ret != 0) {
93 IAM_LOGE("RemoveParameterWatcher fail %{public}d", ret);
94 }
95 IAM_LOGI("param watcher service remove process finish");
96 }
97
GetInstance()98 sptr<SystemParamServiceStatusListener> SystemParamServiceStatusListener::GetInstance()
99 {
100 static sptr<SystemParamServiceStatusListener> listener(new (std::nothrow) SystemParamServiceStatusListener());
101 if (listener == nullptr) {
102 IAM_LOGE("SystemParamServiceStatusListener is null");
103 }
104 return listener;
105 }
106
Subscribe()107 void SystemParamServiceStatusListener::Subscribe()
108 {
109 auto sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
110 if (sam == nullptr) {
111 IAM_LOGE("failed to get SA manager");
112 return;
113 }
114
115 auto instance = GetInstance();
116 IF_FALSE_LOGE_AND_RETURN(instance != NULL);
117
118 int32_t ret = sam->SubscribeSystemAbility(PARAM_WATCHER_DISTRIBUTED_SERVICE_ID, instance);
119 if (ret != ERR_OK) {
120 IAM_LOGE("failed to subscribe param watcher service status");
121 return;
122 }
123
124 IAM_LOGI("subscribe param watcher service status success");
125 }
126
SystemParamManager()127 SystemParamManager::SystemParamManager()
128 {}
129
GetInstance()130 SystemParamManager &SystemParamManager::GetInstance()
131 {
132 static SystemParamManager systemParamManager;
133 return systemParamManager;
134 }
135
Start()136 void SystemParamManager::Start()
137 {
138 SystemParamServiceStatusListener::Subscribe();
139 }
140
UpdateFingerAuthEnable(bool isFingerAuthEnable)141 void SystemParamManager::UpdateFingerAuthEnable(bool isFingerAuthEnable)
142 {
143 std::lock_guard<std::recursive_mutex> lock(recursiveMutex_);
144 IAM_LOGI("UpdateFingerAuthEnable %{public}d", isFingerAuthEnable);
145 isFingerAuthEnable_ = isFingerAuthEnable;
146 }
147
IsAuthTypeEnable(int32_t authType)148 bool SystemParamManager::IsAuthTypeEnable(int32_t authType)
149 {
150 std::lock_guard<std::recursive_mutex> lock(recursiveMutex_);
151 if ((authType == AuthType::FINGERPRINT) && !isFingerAuthEnable_) {
152 IAM_LOGI("fingerprint not enable");
153 return false;
154 }
155 return true;
156 }
157 } // namespace UserAuth
158 } // namespace UserIam
159 } // namespace OHOS