1 /*
2 * Copyright (C) 2021 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 "call_data_base_helper.h"
17
18 #include "iservice_registry.h"
19
20 #include "ability_context.h"
21
22 #include "telephony_log_wrapper.h"
23
24 namespace OHOS {
25 namespace Telephony {
26 class AbsSharedResultSet;
27 static constexpr const char *CALLLOG_URI = "datashare:///com.ohos.calllogability";
28 static constexpr const char *CALL_SUBSECTION = "datashare:///com.ohos.calllogability/calls/calllog";
29 static constexpr const char *CONTACT_URI = "datashare:///com.ohos.contactsdataability";
30 static constexpr const char *CALL_BLOCK = "datashare:///com.ohos.contactsdataability/contacts/contact_blocklist";
31 static constexpr const char *CONTACT_DATA = "datashare:///com.ohos.contactsdataability/contacts/contact_data";
32
CallDataRdbObserver(std::vector<std::string> * phones)33 CallDataRdbObserver::CallDataRdbObserver(std::vector<std::string> *phones)
34 {
35 this->phones = phones;
36 }
37
~CallDataRdbObserver()38 CallDataRdbObserver::~CallDataRdbObserver() {}
39
OnChange()40 void CallDataRdbObserver::OnChange()
41 {
42 std::shared_ptr<CallDataBaseHelper> callDataPtr = DelayedSingleton<CallDataBaseHelper>::GetInstance();
43 if (callDataPtr == nullptr) {
44 TELEPHONY_LOGE("callDataPtr is nullptr!");
45 return;
46 }
47
48 DataShare::DataSharePredicates predicates;
49 predicates.NotEqualTo("phone_number", std::string(""));
50 this->phones->clear();
51 callDataPtr->Query(this->phones, predicates);
52 }
53
CallDataBaseHelper()54 CallDataBaseHelper::CallDataBaseHelper() {}
55
~CallDataBaseHelper()56 CallDataBaseHelper::~CallDataBaseHelper() {}
57
CreateDataShareHelper(std::string uri)58 std::shared_ptr<DataShare::DataShareHelper> CallDataBaseHelper::CreateDataShareHelper(std::string uri)
59 {
60 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
61 if (saManager == nullptr) {
62 TELEPHONY_LOGE("Get system ability mgr failed.");
63 return nullptr;
64 }
65 auto remoteObj = saManager->GetSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
66 if (remoteObj == nullptr) {
67 TELEPHONY_LOGE("GetSystemAbility Service Failed.");
68 return nullptr;
69 }
70 return DataShare::DataShareHelper::Creator(remoteObj, uri);
71 }
72
RegisterObserver(std::vector<std::string> * phones)73 void CallDataBaseHelper::RegisterObserver(std::vector<std::string> *phones)
74 {
75 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(CONTACT_URI);
76 if (helper == nullptr) {
77 TELEPHONY_LOGE("helper_ is null");
78 return;
79 }
80 Uri uri(CALL_BLOCK);
81 callDataRdbObserverPtr_ = new (std::nothrow) CallDataRdbObserver(phones);
82 if (callDataRdbObserverPtr_ == nullptr) {
83 TELEPHONY_LOGE("callDataRdbObserverPtr_ is null");
84 return;
85 }
86 helper->RegisterObserver(uri, callDataRdbObserverPtr_);
87 }
88
UnRegisterObserver()89 void CallDataBaseHelper::UnRegisterObserver()
90 {
91 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(CONTACT_URI);
92 if (helper == nullptr) {
93 TELEPHONY_LOGE("helper_ is null");
94 return;
95 }
96 Uri uri(CALL_BLOCK);
97 if (callDataRdbObserverPtr_ == nullptr) {
98 TELEPHONY_LOGE("callDataRdbObserverPtr_ is null");
99 return;
100 }
101 helper->UnregisterObserver(uri, callDataRdbObserverPtr_);
102 }
103
Insert(DataShare::DataShareValuesBucket & values)104 bool CallDataBaseHelper::Insert(DataShare::DataShareValuesBucket &values)
105 {
106 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(CALLLOG_URI);
107 if (helper == nullptr) {
108 TELEPHONY_LOGE("helper is nullptr!");
109 return false;
110 }
111 Uri uri(CALL_SUBSECTION);
112 return helper->Insert(uri, values);
113 }
114
Query(std::vector<std::string> * phones,DataShare::DataSharePredicates & predicates)115 bool CallDataBaseHelper::Query(std::vector<std::string> *phones, DataShare::DataSharePredicates &predicates)
116 {
117 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(CONTACT_URI);
118 if (helper == nullptr) {
119 TELEPHONY_LOGE("helper is nullptr");
120 return false;
121 }
122 Uri uri(CALL_BLOCK);
123 std::vector<std::string> columns;
124 columns.push_back("phone_number");
125 auto resultSet = helper->Query(uri, predicates, columns);
126 helper->Release();
127 if (resultSet == nullptr) {
128 return false;
129 }
130 int32_t resultSetNum = resultSet->GoToFirstRow();
131 while (resultSetNum == 0) {
132 std::string phone;
133 int32_t columnIndex;
134 resultSet->GetColumnIndex("phone_number", columnIndex);
135 int32_t ret = resultSet->GetString(columnIndex, phone);
136 if (ret == 0 && (!phone.empty())) {
137 phones->push_back(phone);
138 }
139 resultSetNum = resultSet->GoToNextRow();
140 }
141 resultSet->Close();
142 TELEPHONY_LOGI("Query end");
143 return true;
144 }
145
Query(ContactInfo & contactInfo,DataShare::DataSharePredicates & predicates)146 bool CallDataBaseHelper::Query(ContactInfo &contactInfo, DataShare::DataSharePredicates &predicates)
147 {
148 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(CONTACT_URI);
149 if (helper == nullptr) {
150 TELEPHONY_LOGE("helper is nullptr");
151 return false;
152 }
153 Uri uri(CONTACT_DATA);
154 std::vector<std::string> columns;
155 auto resultSet = helper->Query(uri, predicates, columns);
156 helper->Release();
157 if (resultSet == nullptr) {
158 TELEPHONY_LOGE("resultSet is nullptr");
159 return false;
160 }
161 int32_t resultSetNum = resultSet->GoToFirstRow();
162 while (resultSetNum == 0) {
163 std::string displayName;
164 int32_t columnIndex;
165 resultSet->GetColumnIndex(CALL_DISPLAY_NAME, columnIndex);
166 int32_t ret = resultSet->GetString(columnIndex, displayName);
167 if (ret == 0 && (!displayName.empty())) {
168 size_t cpyLen = displayName.length() + 1;
169 if (displayName.length() > static_cast<size_t>(CONTACT_NAME_LEN)) {
170 return false;
171 }
172 if (strcpy_s(contactInfo.name, cpyLen, displayName.c_str()) != EOK) {
173 TELEPHONY_LOGE("strcpy_s fail.");
174 return false;
175 }
176 }
177 resultSetNum = resultSet->GoToNextRow();
178 }
179 resultSet->Close();
180 TELEPHONY_LOGI("Query end");
181 return true;
182 }
183
Delete(DataShare::DataSharePredicates & predicates)184 bool CallDataBaseHelper::Delete(DataShare::DataSharePredicates &predicates)
185 {
186 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(CALLLOG_URI);
187 if (helper == nullptr) {
188 TELEPHONY_LOGE("helper is nullptr!");
189 return false;
190 }
191 Uri uri(CALL_SUBSECTION);
192 return helper->Delete(uri, predicates);
193 }
194 } // namespace Telephony
195 } // namespace OHOS