1 /*
2 * Copyright (C) 2022 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 "ims_sms_client.h"
17
18 #include "ims_sms_callback_stub.h"
19 #include "iservice_registry.h"
20 #include "system_ability_definition.h"
21 #include "telephony_errors.h"
22 #include "telephony_log_wrapper.h"
23
24 namespace OHOS {
25 namespace Telephony {
26 ImsSmsClient::ImsSmsClient() = default;
27
~ImsSmsClient()28 ImsSmsClient::~ImsSmsClient()
29 {
30 UnInit();
31 }
32
Init()33 void ImsSmsClient::Init()
34 {
35 TELEPHONY_LOGI("Init start");
36 if (IsConnect()) {
37 TELEPHONY_LOGE("Init, IsConnect return true");
38 return;
39 }
40
41 GetImsSmsProxy();
42 if (imsSmsProxy_ == nullptr) {
43 TELEPHONY_LOGE("Init, get ims sms proxy failed!");
44 }
45
46 statusChangeListener_ = new (std::nothrow) SystemAbilityListener();
47 if (statusChangeListener_ == nullptr) {
48 TELEPHONY_LOGE("Init, failed to create statusChangeListener.");
49 return;
50 }
51 auto managerPtr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
52 if (managerPtr == nullptr) {
53 TELEPHONY_LOGE("Init, get system ability manager error.");
54 return;
55 }
56 int32_t ret = managerPtr->SubscribeSystemAbility(TELEPHONY_IMS_SYS_ABILITY_ID,
57 statusChangeListener_);
58 if (ret) {
59 TELEPHONY_LOGE("Init, failed to subscribe sa:%{public}d", TELEPHONY_IMS_SYS_ABILITY_ID);
60 return;
61 }
62 TELEPHONY_LOGI("Init successfully");
63 }
64
UnInit()65 void ImsSmsClient::UnInit()
66 {
67 Clean();
68 if (statusChangeListener_ != nullptr) {
69 statusChangeListener_.clear();
70 statusChangeListener_ = nullptr;
71 }
72 handlerMap_.clear();
73 }
74
GetImsSmsProxy()75 sptr<ImsSmsInterface> ImsSmsClient::GetImsSmsProxy()
76 {
77 if (imsSmsProxy_ != nullptr) {
78 return imsSmsProxy_;
79 }
80 auto managerPtr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
81 if (managerPtr == nullptr) {
82 TELEPHONY_LOGE("GetImsSmsProxy return, get system ability manager error.");
83 return nullptr;
84 }
85 auto remoteObjectPtr = managerPtr->CheckSystemAbility(TELEPHONY_IMS_SYS_ABILITY_ID);
86 if (remoteObjectPtr == nullptr) {
87 TELEPHONY_LOGE("GetImsSmsProxy return, remote service not exists.");
88 return nullptr;
89 }
90 imsCoreServiceProxy_ = iface_cast<ImsCoreServiceInterface>(remoteObjectPtr);
91 if (imsCoreServiceProxy_ == nullptr) {
92 TELEPHONY_LOGE("GetImsSmsProxy return, imsCoreServiceProxy_ is nullptr.");
93 return nullptr;
94 }
95 sptr<IRemoteObject> imsSmsRemoteObjectPtr = imsCoreServiceProxy_->GetProxyObjectPtr(PROXY_IMS_SMS);
96 if (imsSmsRemoteObjectPtr == nullptr) {
97 TELEPHONY_LOGE("GetImsSmsProxy return, ImsCallRemoteObjectPtr is nullptr.");
98 return nullptr;
99 }
100
101 imsSmsProxy_ = iface_cast<ImsSmsInterface>(imsSmsRemoteObjectPtr);
102 if (imsSmsProxy_ == nullptr) {
103 TELEPHONY_LOGE("GetImsSmsProxy return, iface_cast<imsSmsProxy_> failed!");
104 return nullptr;
105 }
106 // register callback
107 RegisterImsSmsCallback();
108 TELEPHONY_LOGI("GetImsSmsProxy success.");
109 return imsSmsProxy_;
110 }
111
IsConnect() const112 bool ImsSmsClient::IsConnect() const
113 {
114 return (imsSmsProxy_ != nullptr);
115 }
116
RegisterImsSmsCallback()117 int32_t ImsSmsClient::RegisterImsSmsCallback()
118 {
119 if (imsSmsProxy_ == nullptr) {
120 TELEPHONY_LOGE("imsSmsProxy_ is null!");
121 return TELEPHONY_ERR_LOCAL_PTR_NULL;
122 }
123 imsSmsCallback_ = (std::make_unique<ImsSmsCallbackStub>()).release();
124 if (imsSmsCallback_ == nullptr) {
125 TELEPHONY_LOGE("RegisterImsSmsCallback return, make unique error.");
126 return TELEPHONY_ERR_LOCAL_PTR_NULL;
127 }
128 int32_t ret = imsSmsProxy_->RegisterImsSmsCallback(imsSmsCallback_);
129 if (ret) {
130 TELEPHONY_LOGE("RegisterImsSmsCallback return, register callback error.");
131 return TELEPHONY_ERR_FAIL;
132 }
133 TELEPHONY_LOGI("RegisterImsSmsCallback success.");
134 return TELEPHONY_SUCCESS;
135 }
136
ImsSendMessage(int32_t slotId,const ImsMessageInfo & imsMessageInfo)137 int32_t ImsSmsClient::ImsSendMessage(int32_t slotId, const ImsMessageInfo &imsMessageInfo)
138 {
139 if (imsSmsProxy_ != nullptr) {
140 return imsSmsProxy_->ImsSendMessage(slotId, imsMessageInfo);
141 } else {
142 TELEPHONY_LOGE("imsSmsProxy_ is null!");
143 return TELEPHONY_ERR_LOCAL_PTR_NULL;
144 }
145 }
146
ImsSetSmsConfig(int32_t slotId,int32_t imsSmsConfig)147 int32_t ImsSmsClient::ImsSetSmsConfig(int32_t slotId, int32_t imsSmsConfig)
148 {
149 if (ReConnectService() != TELEPHONY_SUCCESS) {
150 TELEPHONY_LOGE("ipc reconnect failed!");
151 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
152 }
153 return imsSmsProxy_->ImsSetSmsConfig(slotId, imsSmsConfig);
154 }
155
ImsGetSmsConfig(int32_t slotId)156 int32_t ImsSmsClient::ImsGetSmsConfig(int32_t slotId)
157 {
158 if (ReConnectService() != TELEPHONY_SUCCESS) {
159 TELEPHONY_LOGE("ipc reconnect failed!");
160 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
161 }
162 return imsSmsProxy_->ImsGetSmsConfig(slotId);
163 }
164
RegisterImsSmsCallbackHandler(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler)165 int32_t ImsSmsClient::RegisterImsSmsCallbackHandler(
166 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler)
167 {
168 if (handler == nullptr) {
169 TELEPHONY_LOGE("RegisterImsSmsCallbackHandler return, handler is null.");
170 return TELEPHONY_ERR_LOCAL_PTR_NULL;
171 }
172
173 std::lock_guard<std::mutex> lock(mutex_);
174 handlerMap_.insert(std::make_pair(slotId, handler));
175 TELEPHONY_LOGI("RegisterImsSmsCallbackHandler success.");
176 return TELEPHONY_SUCCESS;
177 }
178
GetHandler(int32_t slotId)179 std::shared_ptr<AppExecFwk::EventHandler> ImsSmsClient::GetHandler(int32_t slotId)
180 {
181 std::lock_guard<std::mutex> lock(mutex_);
182 if (handlerMap_.find(slotId) != handlerMap_.end()) {
183 return handlerMap_[slotId];
184 } else {
185 TELEPHONY_LOGE("GetHandler nullptr");
186 return nullptr;
187 }
188 }
189
ReConnectService()190 int32_t ImsSmsClient::ReConnectService()
191 {
192 if (imsSmsProxy_ == nullptr) {
193 TELEPHONY_LOGI("try to reconnect ims sms service now...");
194 GetImsSmsProxy();
195 if (imsSmsProxy_ == nullptr) {
196 TELEPHONY_LOGE("Connect service failed");
197 return TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL;
198 }
199 }
200 return TELEPHONY_SUCCESS;
201 }
202
Clean()203 void ImsSmsClient::Clean()
204 {
205 Utils::UniqueWriteGuard<Utils::RWLock> guard(rwClientLock_);
206 if (imsCoreServiceProxy_ != nullptr) {
207 imsCoreServiceProxy_.clear();
208 imsCoreServiceProxy_ = nullptr;
209 }
210 if (imsSmsProxy_ != nullptr) {
211 imsSmsProxy_.clear();
212 imsSmsProxy_ = nullptr;
213 }
214 if (imsSmsCallback_ != nullptr) {
215 imsSmsCallback_.clear();
216 imsSmsCallback_ = nullptr;
217 }
218 }
219
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)220 void ImsSmsClient::SystemAbilityListener::OnAddSystemAbility(int32_t systemAbilityId,
221 const std::string& deviceId)
222 {
223 TELEPHONY_LOGI("SA:%{public}d is added!", systemAbilityId);
224 if (!CheckInputSysAbilityId(systemAbilityId)) {
225 TELEPHONY_LOGE("add SA:%{public}d is invalid!", systemAbilityId);
226 return;
227 }
228
229 auto imsSmsClient = DelayedSingleton<ImsSmsClient>::GetInstance();
230 if (imsSmsClient->IsConnect()) {
231 TELEPHONY_LOGI("SA:%{public}d already connected!", systemAbilityId);
232 return;
233 }
234
235 imsSmsClient->Clean();
236 int32_t res = imsSmsClient->ReConnectService();
237 if (res != TELEPHONY_SUCCESS) {
238 TELEPHONY_LOGE("SA:%{public}d reconnect service failed!", systemAbilityId);
239 return;
240 }
241 TELEPHONY_LOGI("SA:%{public}d reconnect service successfully!", systemAbilityId);
242 }
243
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)244 void ImsSmsClient::SystemAbilityListener::OnRemoveSystemAbility(int32_t systemAbilityId,
245 const std::string& deviceId)
246 {
247 TELEPHONY_LOGI("SA:%{public}d is removed!", systemAbilityId);
248 auto imsSmsClient = DelayedSingleton<ImsSmsClient>::GetInstance();
249 if (!imsSmsClient->IsConnect()) {
250 return;
251 }
252
253 imsSmsClient->Clean();
254 }
255 } // namespace Telephony
256 } // namespace OHOS
257