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 "ims_video_call_control.h"
17 
18 #include "cellular_call_hisysevent.h"
19 #include "ims_call_client.h"
20 #include "securec.h"
21 
22 namespace OHOS {
23 namespace Telephony {
24 const int32_t INVALID_VALUE = -1;
25 
ImsVideoCallControl()26 ImsVideoCallControl::ImsVideoCallControl()
27 {
28     TELEPHONY_LOGD("ImsVideoCallControl start");
29 }
30 
~ImsVideoCallControl()31 ImsVideoCallControl::~ImsVideoCallControl()
32 {
33     TELEPHONY_LOGD("~ImsVideoCallControl start");
34 }
35 
ControlCamera(int32_t slotId,int32_t callIndex,const std::string & cameraId)36 int32_t ImsVideoCallControl::ControlCamera(int32_t slotId, int32_t callIndex, const std::string &cameraId)
37 {
38     if (moduleUtils_.NeedCallImsService()) {
39         auto imsCallClient = DelayedSingleton<ImsCallClient>::GetInstance();
40         if (imsCallClient == nullptr || imsCallClient->GetImsCallProxy() == nullptr) {
41             TELEPHONY_LOGE("ImsCallClient is nullptr or ims service SA not exists.");
42             return CALL_ERR_RESOURCE_UNAVAILABLE;
43         }
44         return imsCallClient->ControlCamera(slotId, callIndex, cameraId);
45     }
46     TELEPHONY_LOGI("ims vendor service does not exist.");
47     return TELEPHONY_ERROR;
48 }
49 
SetPreviewWindow(int32_t slotId,int32_t callIndex,const std::string & surfaceID,sptr<Surface> surface)50 int32_t ImsVideoCallControl::SetPreviewWindow(
51     int32_t slotId, int32_t callIndex, const std::string &surfaceID, sptr<Surface> surface)
52 {
53     if (moduleUtils_.NeedCallImsService()) {
54         auto imsCallClient = DelayedSingleton<ImsCallClient>::GetInstance();
55         if (imsCallClient == nullptr || imsCallClient->GetImsCallProxy() == nullptr) {
56             TELEPHONY_LOGE("ImsCallClient is nullptr or ims service SA not exists.");
57             return CALL_ERR_RESOURCE_UNAVAILABLE;
58         }
59         return imsCallClient->SetPreviewWindow(slotId, callIndex, surfaceID, surface);
60     }
61     TELEPHONY_LOGI("ims vendor service does not exist.");
62     return TELEPHONY_ERROR;
63 }
64 
SetDisplayWindow(int32_t slotId,int32_t callIndex,const std::string & surfaceID,sptr<Surface> surface)65 int32_t ImsVideoCallControl::SetDisplayWindow(
66     int32_t slotId, int32_t callIndex, const std::string &surfaceID, sptr<Surface> surface)
67 {
68     if (moduleUtils_.NeedCallImsService()) {
69         auto imsCallClient = DelayedSingleton<ImsCallClient>::GetInstance();
70         if (imsCallClient == nullptr || imsCallClient->GetImsCallProxy() == nullptr) {
71             TELEPHONY_LOGE("ImsCallClient is nullptr or ims service SA not exists.");
72             return CALL_ERR_RESOURCE_UNAVAILABLE;
73         }
74         return imsCallClient->SetDisplayWindow(slotId, callIndex, surfaceID, surface);
75     }
76     TELEPHONY_LOGI("ims vendor service does not exist.");
77     return TELEPHONY_ERROR;
78 }
79 
SetCameraZoom(float zoomRatio)80 int32_t ImsVideoCallControl::SetCameraZoom(float zoomRatio)
81 {
82     if (moduleUtils_.NeedCallImsService()) {
83         auto imsCallClient = DelayedSingleton<ImsCallClient>::GetInstance();
84         if (imsCallClient == nullptr || imsCallClient->GetImsCallProxy() == nullptr) {
85             TELEPHONY_LOGE("ImsCallClient is nullptr or ims service SA not exists.");
86             return CALL_ERR_RESOURCE_UNAVAILABLE;
87         }
88         return imsCallClient->SetCameraZoom(zoomRatio);
89     }
90     TELEPHONY_LOGI("ims vendor service does not exist.");
91     return TELEPHONY_ERROR;
92 }
93 
SetPausePicture(int32_t slotId,int32_t callIndex,const std::string & path)94 int32_t ImsVideoCallControl::SetPausePicture(int32_t slotId, int32_t callIndex, const std::string &path)
95 {
96     if (moduleUtils_.NeedCallImsService()) {
97         auto imsCallClient = DelayedSingleton<ImsCallClient>::GetInstance();
98         if (imsCallClient == nullptr || imsCallClient->GetImsCallProxy() == nullptr) {
99             TELEPHONY_LOGE("ImsCallClient is nullptr or ims service SA not exists.");
100             return CALL_ERR_RESOURCE_UNAVAILABLE;
101         }
102         return imsCallClient->SetPausePicture(slotId, callIndex, path);
103     }
104     TELEPHONY_LOGI("ims vendor service does not exist.");
105     return TELEPHONY_ERROR;
106 }
107 
SetDeviceDirection(int32_t slotId,int32_t callIndex,int32_t rotation)108 int32_t ImsVideoCallControl::SetDeviceDirection(int32_t slotId, int32_t callIndex, int32_t rotation)
109 {
110     if (moduleUtils_.NeedCallImsService()) {
111         auto imsCallClient = DelayedSingleton<ImsCallClient>::GetInstance();
112         if (imsCallClient == nullptr || imsCallClient->GetImsCallProxy() == nullptr) {
113             TELEPHONY_LOGE("ImsCallClient is nullptr or ims service SA not exists.");
114             return CALL_ERR_RESOURCE_UNAVAILABLE;
115         }
116         return imsCallClient->SetDeviceDirection(slotId, callIndex, rotation);
117     }
118     TELEPHONY_LOGI("ims vendor service does not exist.");
119     return TELEPHONY_ERROR;
120 }
121 
SendUpdateCallMediaModeRequest(const CellularCallInfo & callInfo,ImsCallMode mode)122 int32_t ImsVideoCallControl::SendUpdateCallMediaModeRequest(const CellularCallInfo &callInfo, ImsCallMode mode)
123 {
124     if (moduleUtils_.NeedCallImsService()) {
125         TELEPHONY_LOGI("call ims service");
126         struct CallBehaviorParameterInfo info = { 0 };
127         auto callHiSysEvent = DelayedSingleton<CellularCallHiSysEvent>::GetInstance();
128         if (callHiSysEvent == nullptr) {
129             TELEPHONY_LOGE("CellularCallHiSysEvent is null.");
130             return TELEPHONY_ERR_LOCAL_PTR_NULL;
131         }
132         callHiSysEvent->GetCallParameterInfo(info);
133         info.videoState = static_cast<ImsCallMode>(mode);
134         CellularCallHiSysEvent::WriteImsCallModeBehaviorEvent(
135             CallModeBehaviorType::SEND_REQUEST_EVENT, info, INVALID_VALUE);
136         ImsCallInfo imsCallInfo;
137         if (memset_s(&imsCallInfo, sizeof(imsCallInfo), 0, sizeof(imsCallInfo)) != EOK) {
138             TELEPHONY_LOGE("return, memset_s error.");
139             return TELEPHONY_ERR_MEMSET_FAIL;
140         }
141         if (static_cast<int32_t>(strlen(callInfo.phoneNum) + 1) > kMaxNumberLen) {
142             return TELEPHONY_ERR_STRCPY_FAIL;
143         }
144         errno_t result = strcpy_s(imsCallInfo.phoneNum, strlen(callInfo.phoneNum) + 1, callInfo.phoneNum);
145         if (result != EOK) {
146             TELEPHONY_LOGE("return, strcpy_s fail.");
147             return TELEPHONY_ERR_STRCPY_FAIL;
148         }
149         imsCallInfo.slotId = callInfo.slotId;
150         imsCallInfo.index = callInfo.index;
151         imsCallInfo.videoState = callInfo.videoState;
152         auto imsCallClient = DelayedSingleton<ImsCallClient>::GetInstance();
153         if (imsCallClient == nullptr || imsCallClient->GetImsCallProxy() == nullptr) {
154             TELEPHONY_LOGE("ImsCallClient is nullptr or ims service SA not exists.");
155             return CALL_ERR_RESOURCE_UNAVAILABLE;
156         }
157         ImsCallType imsCallType = ConverToImsCallType(mode);
158         return imsCallClient->SendUpdateCallMediaModeRequest(imsCallInfo, imsCallType);
159     }
160     TELEPHONY_LOGI("ims vendor service does not exist.");
161     return TELEPHONY_ERROR;
162 }
163 
SendUpdateCallMediaModeResponse(const CellularCallInfo & callInfo,ImsCallMode mode)164 int32_t ImsVideoCallControl::SendUpdateCallMediaModeResponse(const CellularCallInfo &callInfo, ImsCallMode mode)
165 {
166     if (moduleUtils_.NeedCallImsService()) {
167         TELEPHONY_LOGI("call ims service");
168         struct CallBehaviorParameterInfo info = { 0 };
169         auto callHiSysEvent = DelayedSingleton<CellularCallHiSysEvent>::GetInstance();
170         if (callHiSysEvent == nullptr) {
171             TELEPHONY_LOGE("CellularCallHiSysEvent is null.");
172             return TELEPHONY_ERR_LOCAL_PTR_NULL;
173         }
174         callHiSysEvent->GetCallParameterInfo(info);
175         info.videoState = static_cast<ImsCallMode>(mode);
176         CellularCallHiSysEvent::WriteImsCallModeBehaviorEvent(
177             CallModeBehaviorType::SEND_RESPONSE_EVENT, info, INVALID_VALUE);
178         ImsCallInfo imsCallInfo;
179         if (memset_s(&imsCallInfo, sizeof(imsCallInfo), 0, sizeof(imsCallInfo)) != EOK) {
180             TELEPHONY_LOGE("return, memset_s error.");
181             return TELEPHONY_ERR_MEMSET_FAIL;
182         }
183         if (static_cast<int32_t>(strlen(callInfo.phoneNum) + 1) > kMaxNumberLen) {
184             return TELEPHONY_ERR_STRCPY_FAIL;
185         }
186         errno_t result = strcpy_s(imsCallInfo.phoneNum, strlen(callInfo.phoneNum) + 1, callInfo.phoneNum);
187         if (result != EOK) {
188             TELEPHONY_LOGE("return, strcpy_s fail.");
189             return TELEPHONY_ERR_STRCPY_FAIL;
190         }
191         imsCallInfo.slotId = callInfo.slotId;
192         imsCallInfo.index = callInfo.index;
193         imsCallInfo.videoState = callInfo.videoState;
194         auto imsCallClient = DelayedSingleton<ImsCallClient>::GetInstance();
195         if (imsCallClient == nullptr || imsCallClient->GetImsCallProxy() == nullptr) {
196             TELEPHONY_LOGE("ImsCallClient is nullptr or ims service SA not exists.");
197             return CALL_ERR_RESOURCE_UNAVAILABLE;
198         }
199         ImsCallType imsCallType = ConverToImsCallType(mode);
200         return imsCallClient->SendUpdateCallMediaModeResponse(imsCallInfo, imsCallType);
201     }
202     TELEPHONY_LOGI("ims vendor service does not exist.");
203     return TELEPHONY_ERROR;
204 }
205 
CancelCallUpgrade(int32_t slotId,int32_t callIndex)206 int32_t ImsVideoCallControl::CancelCallUpgrade(int32_t slotId, int32_t callIndex)
207 {
208     if (moduleUtils_.NeedCallImsService()) {
209         auto imsCallClient = DelayedSingleton<ImsCallClient>::GetInstance();
210         if (imsCallClient == nullptr || imsCallClient->GetImsCallProxy() == nullptr) {
211             TELEPHONY_LOGE("ImsCallClient is nullptr or ims service SA not exists.");
212             return CALL_ERR_RESOURCE_UNAVAILABLE;
213         }
214         return imsCallClient->CancelCallUpgrade(slotId, callIndex);
215     }
216     TELEPHONY_LOGI("ims vendor service does not exist.");
217     return TELEPHONY_ERROR;
218 }
219 
RequestCameraCapabilities(int32_t slotId,int32_t callIndex)220 int32_t ImsVideoCallControl::RequestCameraCapabilities(int32_t slotId, int32_t callIndex)
221 {
222     if (moduleUtils_.NeedCallImsService()) {
223         auto imsCallClient = DelayedSingleton<ImsCallClient>::GetInstance();
224         if (imsCallClient == nullptr || imsCallClient->GetImsCallProxy() == nullptr) {
225             TELEPHONY_LOGE("ImsCallClient is nullptr or ims service SA not exists.");
226             return CALL_ERR_RESOURCE_UNAVAILABLE;
227         }
228         return imsCallClient->RequestCameraCapabilities(slotId, callIndex);
229     }
230     TELEPHONY_LOGI("ims vendor service does not exist.");
231     return TELEPHONY_ERROR;
232 }
233 
ConverToImsCallType(ImsCallMode mode)234 ImsCallType ImsVideoCallControl::ConverToImsCallType(ImsCallMode mode)
235 {
236     ImsCallType callType = ImsCallType::TEL_IMS_CALL_TYPE_VOICE;
237     switch (mode) {
238         case ImsCallMode::CALL_MODE_AUDIO_ONLY:
239             callType = ImsCallType::TEL_IMS_CALL_TYPE_VOICE;
240             break;
241         case ImsCallMode::CALL_MODE_RECEIVE_ONLY:
242             callType = ImsCallType::TEL_IMS_CALL_TYPE_VT_RX;
243             break;
244         case ImsCallMode::CALL_MODE_SEND_ONLY:
245             callType = ImsCallType::TEL_IMS_CALL_TYPE_VT_TX;
246             break;
247         case ImsCallMode::CALL_MODE_SEND_RECEIVE:
248             callType = ImsCallType::TEL_IMS_CALL_TYPE_VT;
249             break;
250         case ImsCallMode::CALL_MODE_VIDEO_PAUSED:
251             callType = ImsCallType::TEL_IMS_CALL_TYPE_PAUSE;
252             break;
253         default:
254             callType = ImsCallType::TEL_IMS_CALL_TYPE_VOICE;
255     }
256     return callType;
257 }
258 } // namespace Telephony
259 } // namespace OHOS