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#ifndef CELLULAR_CALL_SERVICE_H
17#define CELLULAR_CALL_SERVICE_H
18
19#include <memory>
20#include <mutex>
21
22#include "cellular_call_config.h"
23#include "cellular_call_handler.h"
24#include "cellular_call_stub.h"
25#include "cellular_call_supplement.h"
26#include "event_runner.h"
27#include "iremote_broker.h"
28#include "singleton.h"
29#include "system_ability.h"
30#include "system_ability_status_change_stub.h"
31
32namespace OHOS {
33namespace Telephony {
34enum class ServiceRunningState { STATE_STOPPED, STATE_RUNNING };
35
36class CellularCallService : public SystemAbility,
37                            public CellularCallStub,
38                            public std::enable_shared_from_this<CellularCallService> {
39    DECLARE_DELAYED_SINGLETON(CellularCallService)
40    DECLEAR_SYSTEM_ABILITY(CellularCallService)
41
42public:
43    /**
44     * service OnStart
45     */
46    void OnStart() override;
47
48    /**
49     * service OnStop
50     */
51    void OnStop() override;
52
53    /**
54     * service dump
55     *
56     * @param fd
57     * @param args
58     * @return
59     */
60    int32_t Dump(std::int32_t fd, const std::vector<std::u16string> &args) override;
61
62    /**
63     * Get serviceRunningState_
64     * @return serviceRunningState_
65     */
66    int32_t GetServiceRunningState();
67
68    /**
69     * RegisterHandler
70     */
71    void RegisterHandler();
72
73    /**
74     * Get bindTime_
75     *
76     * @return int64_t
77     */
78    std::string GetBindTime();
79
80    /**
81     * Get EndTime
82     *
83     * @return int64_t
84     */
85    std::string GetEndTime();
86
87    /**
88     * Get SpendTime
89     *
90     * @return int64_t
91     */
92    std::string GetSpendTime();
93
94    /**
95     * Dial
96     *
97     * @param CellularCallInfo, dial param.
98     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
99     */
100    int32_t Dial(const CellularCallInfo &callInfo) override;
101
102    /**
103     * HangUp
104     *
105     * @param CellularCallInfo, HangUp param.
106     * @param CallSupplementType
107     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
108     */
109    int32_t HangUp(const CellularCallInfo &callInfo, CallSupplementType type) override;
110
111    /**
112     * Reject
113     *
114     * @param CellularCallInfo, Reject param.
115     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
116     */
117    int32_t Reject(const CellularCallInfo &callInfo) override;
118
119    /**
120     * Answer
121     *
122     * @param CellularCallInfo, Answer param.
123     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
124     */
125    int32_t Answer(const CellularCallInfo &callInfo) override;
126
127    /**
128     * HoldCall
129     *
130     * @param CellularCallInfo, Hold param.
131     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
132     */
133    int32_t HoldCall(const CellularCallInfo &callInfo) override;
134
135    /**
136     * UnHoldCall
137     *
138     * @param CellularCallInfo, UnHold param.
139     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
140     */
141    int32_t UnHoldCall(const CellularCallInfo &callInfo) override;
142
143    /**
144     * SwitchCall
145     *
146     * @param CellularCallInfo, SwitchCall param.
147     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
148     */
149    int32_t SwitchCall(const CellularCallInfo &callInfo) override;
150
151    /**
152     * IsEmergencyPhoneNumber
153     *
154     * @param slotId
155     * @param phone number
156     * @param enabled Is Urgent Call
157     * @return TELEPHONY_SUCCESS on success, others on failure.
158     */
159    int32_t IsEmergencyPhoneNumber(int32_t slotId, const std::string &phoneNum, bool &enabled) override;
160
161    /**
162     * SetEmergencyCallList
163     *
164     * @param slotId
165     * @param eccVec
166     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
167     */
168    int32_t SetEmergencyCallList(int32_t slotId, std::vector<EmergencyCall> &eccVec) override;
169
170    /**
171     * Merge into multiple calls
172     *
173     * @param CellularCallInfo
174     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
175     */
176    int32_t CombineConference(const CellularCallInfo &callInfo) override;
177
178    /**
179     * SeparateConference
180     *
181     * @param CellularCallInfo
182     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
183     */
184    int32_t SeparateConference(const CellularCallInfo &callInfo) override;
185
186    /**
187     * InviteToConference
188     *
189     * @param slotId
190     * @param numberList
191     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
192     */
193    int32_t InviteToConference(int32_t slotId, const std::vector<std::string> &numberList) override;
194
195    /**
196     * KickOutFromConference
197     *
198     * @param CellularCallInfo
199     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
200     */
201    int32_t KickOutFromConference(const CellularCallInfo &callInfo) override;
202
203    /**
204     * Hang Up All Connection
205     *
206     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
207     */
208    int32_t HangUpAllConnection() override;
209
210    /**
211     * Hang Up All Connection
212     *
213     * @param slotId
214     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
215     */
216    int32_t HangUpAllConnection(int32_t slotId) override;
217
218    int32_t SetReadyToCall(int32_t slotId, int32_t callType, bool isReadyToCall) override;
219
220    /**
221     * IMS Send Update Call Media Mode Request
222     *
223     * @param CellularCallInfo
224     * @param ImsCallMode
225     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
226     */
227    int32_t SendUpdateCallMediaModeRequest(const CellularCallInfo &callInfo, ImsCallMode mode) override;
228
229    /**
230     * IMS Send Update Call Media Mode Response
231     *
232     * @param CellularCallInfo
233     * @param ImsCallMode
234     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
235     */
236    int32_t SendUpdateCallMediaModeResponse(const CellularCallInfo &callInfo, ImsCallMode mode) override;
237
238    /**
239     * Cancel Call Upgrade
240     *
241     * @param slotId the slot id
242     * @param callIndex the call index number.
243     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
244     */
245    int32_t CancelCallUpgrade(int32_t slotId, int32_t callIndex) override;
246
247    /**
248     * Request Camera Capabilities
249     *
250     * @param slotId the slot id
251     * @param callIndex the call index number.
252     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
253     */
254    int32_t RequestCameraCapabilities(int32_t slotId, int32_t callIndex) override;
255
256    /**
257     * Register CallManager CallBack
258     *
259     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
260     */
261    int32_t RegisterCallManagerCallBack(const sptr<ICallStatusCallback> &callback) override;
262
263    /**
264     * UnRegister CallManager CallBack
265     *
266     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
267     */
268    int32_t UnRegisterCallManagerCallBack() override;
269
270    /**
271     * StartDtmf
272     *
273     * @param Dtmf Code
274     * @param CellularCallInfo
275     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
276     */
277    int32_t StartDtmf(char cDtmfCode, const CellularCallInfo &callInfo) override;
278
279    /**
280     * StopDtmf
281     *
282     * @param CellularCallInfo
283     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
284     */
285    int32_t StopDtmf(const CellularCallInfo &callInfo) override;
286
287    int32_t PostDialProceed(const CellularCallInfo &callInfo, const bool proceed) override;
288
289    /**
290     * SendDtmf
291     *
292     * @param Dtmf Code
293     * @param CellularCallInfo
294     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
295     */
296    int32_t SendDtmf(char cDtmfCode, const CellularCallInfo &callInfo) override;
297
298    /**
299     * Start Rtt
300     *
301     * @param slotId
302     * @param msg
303     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
304     */
305    int32_t StartRtt(int32_t slotId, const std::string &msg) override;
306
307    /**
308     * Stop Rtt
309     *
310     * @param slotId
311     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
312     */
313    int32_t StopRtt(int32_t slotId) override;
314
315    /**
316     * Set Call Transfer
317     *
318     * @param slotId
319     * @param CallTransferInfo
320     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
321     */
322    int32_t SetCallTransferInfo(int32_t slotId, const CallTransferInfo &cfInfo) override;
323
324    /**
325     * confirm whether IMS can set call transfer time.
326     *
327     * @param slotId[in], The slot id
328     * @param result[out], The result of can set or not
329     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
330     */
331    int32_t CanSetCallTransferTime(int32_t slotId, bool &result) override;
332
333    /**
334     * Get Call Transfer
335     *
336     * @param slotId
337     * @param CallTransferType
338     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
339     */
340    int32_t GetCallTransferInfo(int32_t slotId, CallTransferType type) override;
341
342    /**
343     * Set Call Waiting
344     *
345     * @param slotId
346     * @param activate
347     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
348     */
349    int32_t SetCallWaiting(int32_t slotId, bool activate) override;
350
351    /**
352     * Inquire Call Waiting
353     *
354     * @param slotId
355     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
356     */
357    int32_t GetCallWaiting(int32_t slotId) override;
358
359    /**
360     * Set Call Restriction
361     *
362     * @param slotId
363     * @param CallRestrictionInfo
364     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
365     */
366    int32_t SetCallRestriction(int32_t slotId, const CallRestrictionInfo &crInfo) override;
367
368    /**
369     * Inquire Call Restriction
370     *
371     * @param slotId
372     * @param CallRestrictionType
373     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
374     */
375    int32_t GetCallRestriction(int32_t slotId, CallRestrictionType facType) override;
376
377    /**
378     * @brief Set the call restriction password of the specified account
379     *
380     * @param slotId[in] the slot id
381     * @param facType[in] indicate the call restriction type, just like all incoming, all outgoing .etc
382     * @param oldPassword[in] indicate the call restriction old password
383     * @param newPassword[in] indicate the call restriction new password
384     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
385     */
386    int32_t SetCallRestrictionPassword(
387        int32_t slotId, CallRestrictionType facType, const char *oldPassword, const char *newPassword) override;
388
389    /**
390     * Set Domain Preference Mode
391     *
392     * @param slotId
393     * @param mode
394     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
395     */
396    int32_t SetDomainPreferenceMode(int32_t slotId, int32_t mode) override;
397
398    /**
399     * Get Domain Preference Mode
400     *
401     * @param slotId
402     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
403     */
404    int32_t GetDomainPreferenceMode(int32_t slotId) override;
405
406    /**
407     * Set Ims Switch Status
408     *
409     * @param slotId
410     * @param active
411     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
412     */
413    int32_t SetImsSwitchStatus(int32_t slotId, bool active) override;
414
415    /**
416     * Get Ims Switch Status
417     *
418     * @param slotId
419     * @param enabled
420     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
421     */
422    int32_t GetImsSwitchStatus(int32_t slotId, bool &enabled) override;
423
424    /**
425     * Set Ims Config
426     *
427     * @param slotId
428     * @param ImsConfigItem
429     * @param value
430     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
431     */
432    int32_t SetImsConfig(int32_t slotId, ImsConfigItem item, const std::string &value) override;
433
434    /**
435     * Set VoNR Switch State
436     *
437     * @param slotId
438     * @param state
439     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
440     */
441    virtual int32_t SetVoNRState(int32_t slotId, int32_t state) override;
442
443    /**
444     * Get VoNR Switch State
445     *
446     * @param slotId
447     * @param state
448     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
449     */
450    virtual int32_t GetVoNRState(int32_t slotId, int32_t &state) override;
451
452    /**
453     * Set Ims Config
454     *
455     * @param slotId
456     * @param ImsConfigItem
457     * @param value
458     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
459     */
460    int32_t SetImsConfig(int32_t slotId, ImsConfigItem item, int32_t value) override;
461
462    /**
463     * Get Ims Config
464     *
465     * @param slotId
466     * @param ImsConfigItem
467     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
468     */
469    int32_t GetImsConfig(int32_t slotId, ImsConfigItem item) override;
470
471    /**
472     * Set Ims Feature Value
473     *
474     * @param slotId
475     * @param FeatureType
476     * @param value
477     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
478     */
479    int32_t SetImsFeatureValue(int32_t slotId, FeatureType type, int32_t value) override;
480
481    /**
482     * Get Ims Feature Value
483     *
484     * @param slotId
485     * @param FeatureType
486     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
487     */
488    int32_t GetImsFeatureValue(int32_t slotId, FeatureType type) override;
489
490    /**
491     * ControlCamera
492     *
493     * @param slotId[in], The slot id
494     * @param index Indicates the call index number.
495     * @param cameraId
496     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
497     */
498    int32_t ControlCamera(int32_t slotId, int32_t index, const std::string &cameraId) override;
499
500    /**
501     * SetPreviewWindow
502     *
503     * @param slotId[in], The slot id
504     * @param index Indicates the call index number.
505     * @param surfaceID Surface id of window object
506     * @param surface The surface object of window
507     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
508     */
509    int32_t SetPreviewWindow(
510        int32_t slotId, int32_t index, const std::string &surfaceId, sptr<Surface> surface) override;
511
512    /**
513     * SetDisplayWindow
514     *
515     * @param slotId[in], The slot id
516     * @param index Indicates the call index number.
517     * @param surfaceID Surface id of window object
518     * @param surface The surface object of window
519     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
520     */
521    int32_t SetDisplayWindow(
522        int32_t slotId, int32_t index, const std::string &surfaceId, sptr<Surface> surface) override;
523
524    /**
525     * SetCameraZoom
526     *
527     * @param zoomRatio
528     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
529     */
530    int32_t SetCameraZoom(float zoomRatio) override;
531
532    /**
533     * SetPausePicture
534     *
535     * @param slotId[in], The slot id
536     * @param index Indicates the call index number.
537     * @param path
538     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
539     */
540    int32_t SetPausePicture(int32_t slotId, int32_t index, const std::string &path) override;
541
542    /**
543     * SetDeviceDirection
544     *
545     * @param slotId[in], The slot id
546     * @param index Indicates the call index number.
547     * @param rotation
548     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
549     */
550    int32_t SetDeviceDirection(int32_t slotId, int32_t index, int32_t rotation) override;
551
552    /**
553     * SetMute
554     *
555     * @param mute
556     * @param slotId
557     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
558     */
559    int32_t SetMute(int32_t slotId, int32_t mute) override;
560
561    /**
562     * GetMute
563     *
564     * @param slotId
565     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
566     */
567    int32_t GetMute(int32_t slotId) override;
568
569    /**
570     * Close Unfinished ussd
571     *
572     * @param slotId
573     * @return Returns TELEPHONY_SUCCESS on success, others on failure.
574     */
575    int32_t CloseUnFinishedUssd(int32_t slotId) override;
576
577    int32_t ClearAllCalls(const std::vector<CellularCallInfo> &infos) override;
578
579    /**
580     * Is need choose IMS for execute
581     *
582     * @param slotId
583     * @return bool
584     */
585    bool IsNeedIms(int32_t slotId) const;
586
587    /**
588     * Get CSControl
589     *
590     * @param slotId
591     * @return shared_ptr CSControl
592     */
593    std::shared_ptr<CSControl> GetCsControl(int32_t slotId);
594
595    /**
596     * Get IMControl
597     *
598     * @param slotId
599     * @return shared_ptr CSControl
600     */
601    std::shared_ptr<IMSControl> GetImsControl(int32_t slotId);
602
603    /**
604     * Get SatelliteControl
605     *
606     * @param slotId
607     * @return shared_ptr SatelliteControl
608     */
609    std::shared_ptr<SatelliteControl> GetSatelliteControl(int32_t slotId);
610
611    /**
612     * Set SetCsControl
613     *
614     * @param slotId
615     * @param  shared_ptr CSControl
616     */
617    void SetCsControl(int32_t slotId, const std::shared_ptr<CSControl> &csControl);
618
619    /**
620     * Set IMSControl
621     *
622     * @param slotId
623     * @param  shared_ptr IMSControl
624     */
625    void SetImsControl(int32_t slotId, const std::shared_ptr<IMSControl> &imsControl);
626
627    /**
628     * Set SatelliteControl
629     *
630     * @param slotId
631     * @param  shared_ptr SatelliteControl
632     */
633    void SetSatelliteControl(int32_t slotId, const std::shared_ptr<SatelliteControl> &satelliteControl);
634
635    /**
636     * Get Handler
637     *
638     * @param slotId
639     * @return CellularCallHandler
640     */
641    std::shared_ptr<CellularCallHandler> GetHandler(int32_t slotId);
642
643    void SetSrvccState(int32_t srvccState);
644
645    int32_t GetSrvccState();
646
647#ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
648    /**
649     * Get call manager service
650     */
651    void StartCallManagerService();
652#endif
653
654private:
655    /**
656     * Init service
657     *
658     * @return whether init success
659     */
660    bool Init();
661
662    /**
663     * Register Handler
664     */
665    void RegisterCoreServiceHandler();
666
667    /**
668     * Create Handler
669     */
670    void CreateHandler();
671
672    /**
673     * Handler Reset UnRegister
674     */
675    void HandlerResetUnRegister();
676
677    /**
678     * SendEventRegisterHandler
679     */
680    void SendEventRegisterHandler();
681
682    /**
683     * Is Valid Slot Id
684     *
685     * @param slotId
686     * @return bool
687     */
688    bool IsValidSlotId(int32_t slotId) const;
689
690    /**
691     * Check whether IMS should be used firstly for emergency call
692     */
693    bool UseImsForEmergency(const CellularCallInfo &callInfo, bool isEcc);
694
695    /**
696     * Handle CallManager exception
697     */
698    void HandleCallManagerException();
699
700    void HangUpWithCellularCallRestart(const std::vector<CellularCallInfo> &infos);
701
702    int32_t SetControl(const CellularCallInfo &info);
703
704    int32_t DialNormalCall(const CellularCallInfo &callInfo, bool isEcc);
705
706    void HandleCellularControlException(const CellularCallInfo &callInfo);
707
708    CallReportInfo EncapsulationCallReportInfo(const CellularCallInfo &callInfo);
709
710private:
711    enum class SatelliteState {
712        SATELLITE_OFF,
713        SATELLITE_ON,
714    };
715
716    int64_t bindTime_ = 0L;
717    int64_t endTime_ = 0L;
718    int64_t spendTime_ = 0L;
719    ServiceRunningState state_;
720    std::mutex handlerMapMutex_;
721    std::map<int32_t, std::shared_ptr<CellularCallHandler>> handlerMap_;
722    int32_t srvccState_ = SrvccState::SRVCC_NONE;
723    std::map<int32_t, std::shared_ptr<CSControl>> csControlMap_;
724    std::map<int32_t, std::shared_ptr<IMSControl>> imsControlMap_;
725    std::map<int32_t, std::shared_ptr<SatelliteControl>> satelliteControlMap_;
726    sptr<NetworkSearchCallBackBase> networkSearchCallBack_;
727    sptr<ISystemAbilityStatusChange> statusChangeListener_ = nullptr;
728    sptr<ISystemAbilityStatusChange> callManagerListener_ = nullptr;
729    std::mutex mutex_;
730
731private:
732    class SystemAbilityStatusChangeListener : public OHOS::SystemAbilityStatusChangeStub {
733    public:
734        SystemAbilityStatusChangeListener() = default;
735        explicit SystemAbilityStatusChangeListener(std::shared_ptr<CellularCallHandler> &cellularCallHandler);
736        ~SystemAbilityStatusChangeListener() = default;
737        virtual void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
738        virtual void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
739
740    private:
741        std::shared_ptr<CellularCallHandler> cellularCallHandler_ = nullptr;
742        int32_t count_ = 0;
743    };
744};
745} // namespace Telephony
746} // namespace OHOS
747
748#endif // CELLULAR_CALL_SERVICE_H
749