1 /*
2 * Copyright (C) 2021-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 "napi_call_manager_utils.h"
17
18 #include "napi_util.h"
19 #include "system_ability_definition.h"
20 #include "telephony_log_wrapper.h"
21
22 namespace OHOS {
23 namespace Telephony {
24 static constexpr const char *PLACE_CALL = "ohos.permission.PLACE_CALL";
25 static constexpr const char *ANSWER_CALL = "ohos.permission.ANSWER_CALL";
26 static constexpr const char *SET_TELEPHONY_STATE = "ohos.permission.SET_TELEPHONY_STATE";
27 static constexpr const char *GET_TELEPHONY_STATE = "ohos.permission.GET_TELEPHONY_STATE";
28
29 static std::unordered_map<int32_t, const char *> eventNameMap_ = {
30 { CALL_MANAGER_DIAL_CALL, "dial" },
31 { CALL_MANAGER_ANSWER_CALL, "answer" },
32 { CALL_MANAGER_REJECT_CALL, "reject" },
33 { CALL_MANAGER_DISCONNECT_CALL, "hangup" },
34 { CALL_MANAGER_HOLD_CALL, "holdCall" },
35 { CALL_MANAGER_UNHOLD_CALL, "unHoldCall" },
36 { CALL_MANAGER_SWITCH_CALL, "switchCall" },
37 { CALL_MANAGER_GET_CALL_WAITING, "getCallWaitingStatus" },
38 { CALL_MANAGER_SET_CALL_WAITING, "setCallWaiting" },
39 { CALL_MANAGER_GET_CALL_RESTRICTION, "getCallRestrictionStatus" },
40 { CALL_MANAGER_SET_CALL_RESTRICTION, "setCallRestriction" },
41 { CALL_MANAGER_SET_CALL_RESTRICTION_PASSWORD, "setCallRestrictionPassword" },
42 { CALL_MANAGER_GET_CALL_TRANSFER, "getCallTransferInfo" },
43 { CALL_MANAGER_SET_CALL_TRANSFER, "setCallTransfer" },
44 { CALL_MANAGER_CAN_SET_CALL_TRANSFER_TIME, "canSetCallTransferTime" },
45 { CALL_MANAGER_ENABLE_IMS_SWITCH, "enableImsSwitch" },
46 { CALL_MANAGER_DISABLE_IMS_SWITCH, "disableImsSwitch" },
47 { CALL_MANAGER_IS_EMERGENCY_CALL, "isInEmergencyCall" },
48 { CALL_MANAGER_IS_RINGING, "isRinging" },
49 { CALL_MANAGER_MUTE_RINGER, "muteRinger" },
50 { CALL_MANAGER_SET_VONR_STATE, "setVoNRState" },
51 { CALL_MANAGER_GET_VONR_STATE, "getVoNRState" },
52 { CALL_MANAGER_SET_VOIP_CALL_STATE, "setVoIPCallState" },
53 { CALL_MANAGER_CONTROL_CAMERA, "controlCamera" },
54 { CALL_MANAGER_SET_PREVIEW_WINDOW, "setPreviewWindow" },
55 { CALL_MANAGER_SET_DISPLAY_WINDOW, "setDisplayWindow" },
56 { CALL_MANAGER_SET_PAUSE_PICTURE, "setPausePicture" },
57 { CALL_MANAGER_SET_DEVICE_DIRECTION, "setDeviceDirection" },
58 { CALL_MANAGER_QUERY_CAMERA_CAPABILITIES, "queryCameraCapabilities" },
59 { CALL_MANAGER_CANCEL_CALL_UPGRADE, "cancelCallUpgrade" },
60 };
61
62 static std::unordered_map<int32_t, const char *> eventPermissionMap_ = {
63 { CALL_MANAGER_DIAL_CALL, PLACE_CALL },
64 { CALL_MANAGER_ANSWER_CALL, ANSWER_CALL },
65 { CALL_MANAGER_REJECT_CALL, ANSWER_CALL },
66 { CALL_MANAGER_DISCONNECT_CALL, ANSWER_CALL },
67 { CALL_MANAGER_HOLD_CALL, ANSWER_CALL },
68 { CALL_MANAGER_UNHOLD_CALL, ANSWER_CALL },
69 { CALL_MANAGER_SWITCH_CALL, ANSWER_CALL },
70 { CALL_MANAGER_GET_CALL_WAITING, GET_TELEPHONY_STATE },
71 { CALL_MANAGER_SET_CALL_WAITING, SET_TELEPHONY_STATE },
72 { CALL_MANAGER_GET_CALL_RESTRICTION, GET_TELEPHONY_STATE },
73 { CALL_MANAGER_SET_CALL_RESTRICTION, SET_TELEPHONY_STATE },
74 { CALL_MANAGER_SET_CALL_RESTRICTION_PASSWORD, SET_TELEPHONY_STATE },
75 { CALL_MANAGER_GET_CALL_TRANSFER, GET_TELEPHONY_STATE },
76 { CALL_MANAGER_SET_CALL_TRANSFER, SET_TELEPHONY_STATE },
77 { CALL_MANAGER_CAN_SET_CALL_TRANSFER_TIME, GET_TELEPHONY_STATE },
78 { CALL_MANAGER_ENABLE_IMS_SWITCH, SET_TELEPHONY_STATE },
79 { CALL_MANAGER_DISABLE_IMS_SWITCH, SET_TELEPHONY_STATE },
80 { CALL_MANAGER_IS_EMERGENCY_CALL, SET_TELEPHONY_STATE },
81 { CALL_MANAGER_IS_RINGING, SET_TELEPHONY_STATE },
82 { CALL_MANAGER_MUTE_RINGER, SET_TELEPHONY_STATE },
83 { CALL_MANAGER_SET_VONR_STATE, SET_TELEPHONY_STATE },
84 { CALL_MANAGER_GET_VONR_STATE, GET_TELEPHONY_STATE },
85 { CALL_MANAGER_CONTROL_CAMERA, SET_TELEPHONY_STATE },
86 { CALL_MANAGER_SET_PREVIEW_WINDOW, SET_TELEPHONY_STATE },
87 { CALL_MANAGER_SET_DISPLAY_WINDOW, SET_TELEPHONY_STATE },
88 { CALL_MANAGER_SET_PAUSE_PICTURE, SET_TELEPHONY_STATE },
89 { CALL_MANAGER_SET_DEVICE_DIRECTION, SET_TELEPHONY_STATE },
90 { CALL_MANAGER_QUERY_CAMERA_CAPABILITIES, GET_TELEPHONY_STATE },
91 { CALL_MANAGER_CANCEL_CALL_UPGRADE, PLACE_CALL },
92 };
93
GetEventName(int32_t eventId)94 std::string NapiCallManagerUtils::GetEventName(int32_t eventId)
95 {
96 std::string result = "";
97 auto iter = eventNameMap_.find(eventId);
98 if (iter == eventNameMap_.end()) {
99 TELEPHONY_LOGE("NapiCallManagerUtils::GetEventName return null.");
100 return result;
101 }
102 result = iter->second;
103 TELEPHONY_LOGI("NapiCallManagerUtils::GetEventName message = %{public}s", result.c_str());
104 return result;
105 }
106
GetEventPermission(int32_t eventId)107 std::string NapiCallManagerUtils::GetEventPermission(int32_t eventId)
108 {
109 std::string result = "";
110 auto iter = eventPermissionMap_.find(eventId);
111 if (iter == eventPermissionMap_.end()) {
112 TELEPHONY_LOGE("NapiCallManagerUtils::GetEventPermission return null.");
113 return result;
114 }
115 result = iter->second;
116 TELEPHONY_LOGI("NapiCallManagerUtils::GetEventPermission message = %{public}s", result.c_str());
117 return result;
118 }
119
CreateErrorCodeAndMessageForJs(napi_env env,int32_t errorCode,int32_t eventId)120 napi_value NapiCallManagerUtils::CreateErrorCodeAndMessageForJs(napi_env env, int32_t errorCode, int32_t eventId)
121 {
122 JsError error = {};
123 switch (errorCode) {
124 case TELEPHONY_ERR_PERMISSION_ERR: {
125 std::string funcName = GetEventName(eventId);
126 std::string permission = GetEventPermission(eventId);
127 error = NapiUtil::ConverErrorMessageWithPermissionForJs(errorCode, funcName, permission);
128 break;
129 }
130 default:
131 error = NapiUtil::ConverErrorMessageForJs(errorCode);
132 break;
133 }
134 return CreateErrorMessageWithErrorCode(env, error.errorMessage, error.errorCode);
135 }
136
MatchValueType(napi_env env,napi_value value,napi_valuetype targetType)137 bool NapiCallManagerUtils::MatchValueType(napi_env env, napi_value value, napi_valuetype targetType)
138 {
139 napi_valuetype valueType = napi_undefined;
140 napi_typeof(env, value, &valueType);
141 return valueType == targetType;
142 }
143
CreateUndefined(napi_env env)144 napi_value NapiCallManagerUtils::CreateUndefined(napi_env env)
145 {
146 napi_value result = nullptr;
147 napi_get_undefined(env, &result);
148 return result;
149 }
150
CreateErrorMessage(napi_env env,std::string msg)151 napi_value NapiCallManagerUtils::CreateErrorMessage(napi_env env, std::string msg)
152 {
153 napi_value result = nullptr;
154 napi_value message = nullptr;
155 napi_create_string_utf8(env, msg.c_str(), msg.length(), &message);
156 napi_create_error(env, nullptr, message, &result);
157 return result;
158 }
159
CreateErrorMessageWithErrorCode(napi_env env,std::string msg,int32_t errorCode)160 napi_value NapiCallManagerUtils::CreateErrorMessageWithErrorCode(napi_env env, std::string msg, int32_t errorCode)
161 {
162 napi_value message = nullptr;
163 NAPI_CALL(env, napi_create_string_utf8(env, msg.c_str(), msg.length(), &message));
164 napi_value codeValue = nullptr;
165 NAPI_CALL(env, napi_create_int32(env, errorCode, &codeValue));
166 napi_value result = nullptr;
167 NAPI_CALL(env, napi_create_object(env, &result));
168 NAPI_CALL(env, napi_set_named_property(env, result, "code", codeValue));
169 NAPI_CALL(env, napi_set_named_property(env, result, "message", message));
170 return result;
171 }
172
ToInt32Value(napi_env env,int32_t value)173 napi_value NapiCallManagerUtils::ToInt32Value(napi_env env, int32_t value)
174 {
175 napi_value staticValue = nullptr;
176 napi_create_int32(env, value, &staticValue);
177 return staticValue;
178 }
179
GetNamedProperty(napi_env env,napi_value object,const std::string & propertyName)180 napi_value NapiCallManagerUtils::GetNamedProperty(napi_env env, napi_value object, const std::string &propertyName)
181 {
182 napi_value value = nullptr;
183 napi_get_named_property(env, object, propertyName.c_str(), &value);
184 return value;
185 }
186
GetStringProperty(napi_env env,napi_value object,const std::string & propertyName)187 std::string NapiCallManagerUtils::GetStringProperty(napi_env env, napi_value object, const std::string &propertyName)
188 {
189 napi_value value = nullptr;
190 napi_status getNameStatus = napi_get_named_property(env, object, propertyName.c_str(), &value);
191 if (getNameStatus == napi_ok) {
192 char tmpStr[MESSAGE_CONTENT_MAXIMUM_LIMIT + 1] = { 0 };
193 size_t len = 0;
194 napi_status getStringStatus =
195 napi_get_value_string_utf8(env, value, tmpStr, MESSAGE_CONTENT_MAXIMUM_LIMIT, &len);
196 if (getStringStatus == napi_ok && len > 0) {
197 return std::string(tmpStr, len);
198 }
199 }
200 TELEPHONY_LOGW("GetStringProperty failed!");
201 return "";
202 }
203
GetIntProperty(napi_env env,napi_value object,const std::string & propertyName)204 int32_t NapiCallManagerUtils::GetIntProperty(napi_env env, napi_value object, const std::string &propertyName)
205 {
206 int32_t intValue = 0;
207 napi_value value = nullptr;
208 napi_status getNameStatus = napi_get_named_property(env, object, propertyName.c_str(), &value);
209 if (getNameStatus == napi_ok) {
210 napi_status getIntStatus = napi_get_value_int32(env, value, &intValue);
211 if (getIntStatus == napi_ok) {
212 return intValue;
213 }
214 }
215 TELEPHONY_LOGW("GetIntProperty failed!");
216 return intValue;
217 }
218
GetUssdIntProperty(napi_env env,napi_value object,const std::string & propertyName,int32_t & result)219 bool NapiCallManagerUtils::GetUssdIntProperty(
220 napi_env env, napi_value object, const std::string &propertyName, int32_t &result)
221 {
222 napi_value value = nullptr;
223 napi_status getNameStatus = napi_get_named_property(env, object, propertyName.c_str(), &value);
224 if (getNameStatus == napi_ok) {
225 napi_status getIntStatus = napi_get_value_int32(env, value, &result);
226 if (getIntStatus == napi_ok) {
227 return true;
228 }
229 }
230 TELEPHONY_LOGW("GetUssdIntProperty failed!");
231 return false;
232 }
233
GetUssdStringProperty(napi_env env,napi_value object,const std::string & propertyName,std::string & result)234 bool NapiCallManagerUtils::GetUssdStringProperty(
235 napi_env env, napi_value object, const std::string &propertyName, std::string &result)
236 {
237 napi_value value = nullptr;
238 napi_status getNameStatus = napi_get_named_property(env, object, propertyName.c_str(), &value);
239 if (getNameStatus == napi_ok) {
240 char tmpStr[MESSAGE_CONTENT_MAXIMUM_LIMIT + 1] = { 0 };
241 size_t len = 0;
242 napi_status getStringStatus =
243 napi_get_value_string_utf8(env, value, tmpStr, MESSAGE_CONTENT_MAXIMUM_LIMIT, &len);
244 if (getStringStatus == napi_ok && len > 0) {
245 result = std::string(tmpStr, len);
246 return true;
247 }
248 }
249 TELEPHONY_LOGW("GetUssdStringProperty failed!");
250 return false;
251 }
252
GetBoolProperty(napi_env env,napi_value object,const std::string & propertyName)253 bool NapiCallManagerUtils::GetBoolProperty(napi_env env, napi_value object, const std::string &propertyName)
254 {
255 bool boolValue = false;
256 napi_value value = nullptr;
257 napi_status getNameStatus = napi_get_named_property(env, object, propertyName.c_str(), &value);
258 if (getNameStatus == napi_ok) {
259 napi_status getIntStatus = napi_get_value_bool(env, value, &boolValue);
260 if (getIntStatus == napi_ok) {
261 return boolValue;
262 }
263 }
264 TELEPHONY_LOGW("GetBoolProperty failed!");
265 return boolValue;
266 }
267
SetPropertyInt32(napi_env env,napi_value object,std::string name,int32_t value)268 void NapiCallManagerUtils::SetPropertyInt32(napi_env env, napi_value object, std::string name, int32_t value)
269 {
270 napi_value peopertyValue = nullptr;
271 napi_create_int32(env, value, &peopertyValue);
272 napi_set_named_property(env, object, name.c_str(), peopertyValue);
273 }
274
SetPropertyStringUtf8(napi_env env,napi_value object,std::string name,std::string value)275 void NapiCallManagerUtils::SetPropertyStringUtf8(napi_env env, napi_value object, std::string name, std::string value)
276 {
277 napi_value peopertyValue = nullptr;
278 napi_create_string_utf8(env, value.c_str(), value.length(), &peopertyValue);
279 napi_set_named_property(env, object, name.c_str(), peopertyValue);
280 }
281
SetPropertyBoolean(napi_env env,napi_value object,std::string name,int32_t value)282 void NapiCallManagerUtils::SetPropertyBoolean(napi_env env, napi_value object, std::string name, int32_t value)
283 {
284 napi_value peopertyValue = nullptr;
285 napi_get_boolean(env, value, &peopertyValue);
286 napi_set_named_property(env, object, name.c_str(), peopertyValue);
287 }
288
CreateEnumConstructor(napi_env env,napi_callback_info info)289 napi_value NapiCallManagerUtils::CreateEnumConstructor(napi_env env, napi_callback_info info)
290 {
291 napi_value thisArg = nullptr;
292 void *data = nullptr;
293 napi_get_cb_info(env, info, nullptr, nullptr, &thisArg, &data);
294 napi_value global = nullptr;
295 napi_get_global(env, &global);
296 return thisArg;
297 }
298 } // namespace Telephony
299 } // namespace OHOS
300