• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
32 namespace OHOS {
33 namespace Telephony {
34 enum class ServiceRunningState { STATE_STOPPED, STATE_RUNNING };
35 
36 class 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 
42 public:
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      * GetVideoCallWaiting
361      *
362      * @param slotId
363      * @param enabled
364      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
365      */
366     int32_t GetVideoCallWaiting(int32_t slotId, bool &enabled) override;
367 
368     /**
369      * Set Call Restriction
370      *
371      * @param slotId
372      * @param CallRestrictionInfo
373      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
374      */
375     int32_t SetCallRestriction(int32_t slotId, const CallRestrictionInfo &crInfo) override;
376 
377     /**
378      * Inquire Call Restriction
379      *
380      * @param slotId
381      * @param CallRestrictionType
382      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
383      */
384     int32_t GetCallRestriction(int32_t slotId, CallRestrictionType facType) override;
385 
386     /**
387      * @brief Set the call restriction password of the specified account
388      *
389      * @param slotId[in] the slot id
390      * @param facType[in] indicate the call restriction type, just like all incoming, all outgoing .etc
391      * @param oldPassword[in] indicate the call restriction old password
392      * @param newPassword[in] indicate the call restriction new password
393      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
394      */
395     int32_t SetCallRestrictionPassword(
396         int32_t slotId, CallRestrictionType facType, const char *oldPassword, const char *newPassword) override;
397 
398     /**
399      * Set Domain Preference Mode
400      *
401      * @param slotId
402      * @param mode
403      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
404      */
405     int32_t SetDomainPreferenceMode(int32_t slotId, int32_t mode) override;
406 
407     /**
408      * Get Domain Preference Mode
409      *
410      * @param slotId
411      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
412      */
413     int32_t GetDomainPreferenceMode(int32_t slotId) override;
414 
415     /**
416      * Set Carrier Vt Config
417      *
418      * @param slotId
419      * @param active
420      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
421      */
422     int32_t GetCarrierVtConfig(int32_t slotId, bool &active) override;
423 
424     /**
425      * Set Ims Switch Status
426      *
427      * @param slotId
428      * @param active
429      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
430      */
431     int32_t SetImsSwitchStatus(int32_t slotId, bool active) override;
432 
433     /**
434      * Get Ims Switch Status
435      *
436      * @param slotId
437      * @param enabled
438      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
439      */
440     int32_t GetImsSwitchStatus(int32_t slotId, bool &enabled) override;
441 
442     /**
443      * Set Ims Config
444      *
445      * @param slotId
446      * @param ImsConfigItem
447      * @param value
448      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
449      */
450     int32_t SetImsConfig(int32_t slotId, ImsConfigItem item, const std::string &value) override;
451 
452     /**
453      * Set VoNR Switch State
454      *
455      * @param slotId
456      * @param state
457      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
458      */
459     virtual int32_t SetVoNRState(int32_t slotId, int32_t state) override;
460 
461     /**
462      * Get VoNR Switch State
463      *
464      * @param slotId
465      * @param state
466      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
467      */
468     virtual int32_t GetVoNRState(int32_t slotId, int32_t &state) override;
469 
470     /**
471      * Set Ims Config
472      *
473      * @param slotId
474      * @param ImsConfigItem
475      * @param value
476      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
477      */
478     int32_t SetImsConfig(int32_t slotId, ImsConfigItem item, int32_t value) override;
479 
480     /**
481      * Get Ims Config
482      *
483      * @param slotId
484      * @param ImsConfigItem
485      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
486      */
487     int32_t GetImsConfig(int32_t slotId, ImsConfigItem item) override;
488 
489     /**
490      * Set Ims Feature Value
491      *
492      * @param slotId
493      * @param FeatureType
494      * @param value
495      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
496      */
497     int32_t SetImsFeatureValue(int32_t slotId, FeatureType type, int32_t value) override;
498 
499     /**
500      * Get Ims Feature Value
501      *
502      * @param slotId
503      * @param FeatureType
504      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
505      */
506     int32_t GetImsFeatureValue(int32_t slotId, FeatureType type) override;
507 
508     /**
509      * ControlCamera
510      *
511      * @param slotId[in], The slot id
512      * @param index Indicates the call index number.
513      * @param cameraId
514      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
515      */
516     int32_t ControlCamera(int32_t slotId, int32_t index, const std::string &cameraId) override;
517 
518     /**
519      * SetPreviewWindow
520      *
521      * @param slotId[in], The slot id
522      * @param index Indicates the call index number.
523      * @param surfaceID Surface id of window object
524      * @param surface The surface object of window
525      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
526      */
527     int32_t SetPreviewWindow(
528         int32_t slotId, int32_t index, const std::string &surfaceId, sptr<Surface> surface) override;
529 
530     /**
531      * SetDisplayWindow
532      *
533      * @param slotId[in], The slot id
534      * @param index Indicates the call index number.
535      * @param surfaceID Surface id of window object
536      * @param surface The surface object of window
537      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
538      */
539     int32_t SetDisplayWindow(
540         int32_t slotId, int32_t index, const std::string &surfaceId, sptr<Surface> surface) override;
541 
542     /**
543      * SetCameraZoom
544      *
545      * @param zoomRatio
546      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
547      */
548     int32_t SetCameraZoom(float zoomRatio) override;
549 
550     /**
551      * SetPausePicture
552      *
553      * @param slotId[in], The slot id
554      * @param index Indicates the call index number.
555      * @param path
556      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
557      */
558     int32_t SetPausePicture(int32_t slotId, int32_t index, const std::string &path) override;
559 
560     /**
561      * SetDeviceDirection
562      *
563      * @param slotId[in], The slot id
564      * @param index Indicates the call index number.
565      * @param rotation
566      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
567      */
568     int32_t SetDeviceDirection(int32_t slotId, int32_t index, int32_t rotation) override;
569 
570     /**
571      * SetMute
572      *
573      * @param mute
574      * @param slotId
575      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
576      */
577     int32_t SetMute(int32_t slotId, int32_t mute) override;
578 
579     /**
580      * GetMute
581      *
582      * @param slotId
583      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
584      */
585     int32_t GetMute(int32_t slotId) override;
586 
587     /**
588      * Close Unfinished ussd
589      *
590      * @param slotId
591      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
592      */
593     int32_t CloseUnFinishedUssd(int32_t slotId) override;
594 
595     int32_t ClearAllCalls(const std::vector<CellularCallInfo> &infos) override;
596 
597     /**
598      * Is need choose IMS for execute
599      *
600      * @param slotId
601      * @return bool
602      */
603     bool IsNeedIms(int32_t slotId) const;
604 
605     /**
606      * Get CSControl
607      *
608      * @param slotId
609      * @return shared_ptr CSControl
610      */
611     std::shared_ptr<CSControl> GetCsControl(int32_t slotId);
612 
613     /**
614      * Get IMControl
615      *
616      * @param slotId
617      * @return shared_ptr CSControl
618      */
619     std::shared_ptr<IMSControl> GetImsControl(int32_t slotId);
620 
621     /**
622      * Get SatelliteControl
623      *
624      * @param slotId
625      * @return shared_ptr SatelliteControl
626      */
627     std::shared_ptr<SatelliteControl> GetSatelliteControl(int32_t slotId);
628 
629     /**
630      * Set SetCsControl
631      *
632      * @param slotId
633      * @param  shared_ptr CSControl
634      */
635     void SetCsControl(int32_t slotId, const std::shared_ptr<CSControl> &csControl);
636 
637     /**
638      * Set IMSControl
639      *
640      * @param slotId
641      * @param  shared_ptr IMSControl
642      */
643     void SetImsControl(int32_t slotId, const std::shared_ptr<IMSControl> &imsControl);
644 
645     /**
646      * Set SatelliteControl
647      *
648      * @param slotId
649      * @param  shared_ptr SatelliteControl
650      */
651     void SetSatelliteControl(int32_t slotId, const std::shared_ptr<SatelliteControl> &satelliteControl);
652 
653     /**
654      * Get Handler
655      *
656      * @param slotId
657      * @return CellularCallHandler
658      */
659     std::shared_ptr<CellularCallHandler> GetHandler(int32_t slotId);
660 
661     void SetSrvccState(int32_t srvccState);
662 
663     int32_t GetSrvccState();
664 
665     void setRadioOnFlag(bool flag, int32_t slotId);
666 
667     bool isRadioOnFlag(int32_t slotId);
668 
669 #ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
670     /**
671      * Get call manager service
672      */
673     void StartCallManagerService();
674 #endif
675 
676     /**
677      * Send ussd response to modem
678      *
679      * @param slotId
680      * @param  content the content need send to modem
681      * @return Returns TELEPHONY_SUCCESS on success, others on failure.
682      */
683     int32_t SendUssdResponse(int32_t slotId, const std::string &content) override;
684 
685     /**
686      * Is mmi code
687      *
688      * @param slotId
689      * @param  number the phone number
690      * @return Returns true on number is mmi code,else return false.
691      */
692     bool IsMmiCode(int32_t slotId, std::string &number) override;
693 
694 private:
695     /**
696      * Init service
697      *
698      * @return whether init success
699      */
700     bool Init();
701 
702     /**
703      * Register Handler
704      */
705     void RegisterCoreServiceHandler();
706 
707     /**
708      * Create Handler
709      */
710     void CreateHandler();
711 
712     /**
713      * Handler Reset UnRegister
714      */
715     void HandlerResetUnRegister();
716 
717     /**
718      * SendEventRegisterHandler
719      */
720     void SendEventRegisterHandler();
721 
722     /**
723      * Is Valid Slot Id
724      *
725      * @param slotId
726      * @return bool
727      */
728     bool IsValidSlotId(int32_t slotId) const;
729 
730     /**
731      * Check whether IMS should be used firstly for emergency call
732      */
733     bool UseImsForEmergency(const CellularCallInfo &callInfo, bool isEcc);
734 
735     /**
736      * Handle CallManager exception
737      */
738     void HandleCallManagerException();
739 
740     void HangUpWithCellularCallRestart(const std::vector<CellularCallInfo> &infos);
741 
742     int32_t SetControl(const CellularCallInfo &info);
743 
744     int32_t DialNormalCall(const CellularCallInfo &callInfo, bool isEcc);
745 
746     void HandleCellularControlException(const CellularCallInfo &callInfo);
747 
748     CallReportInfo EncapsulationCallReportInfo(const CellularCallInfo &callInfo);
749 
750 private:
751     enum class SatelliteState {
752         SATELLITE_OFF,
753         SATELLITE_ON,
754     };
755 
756     int64_t bindTime_ = 0L;
757     int64_t endTime_ = 0L;
758     int64_t spendTime_ = 0L;
759     ServiceRunningState state_;
760     std::mutex handlerMapMutex_;
761     std::map<int32_t, std::shared_ptr<CellularCallHandler>> handlerMap_;
762     int32_t srvccState_ = SrvccState::SRVCC_NONE;
763     std::map<int32_t, std::shared_ptr<CSControl>> csControlMap_;
764     std::map<int32_t, std::shared_ptr<IMSControl>> imsControlMap_;
765     std::map<int32_t, std::shared_ptr<SatelliteControl>> satelliteControlMap_;
766     std::map<int32_t, bool> isRadioOn_;
767     sptr<NetworkSearchCallBackBase> networkSearchCallBack_;
768     sptr<ISystemAbilityStatusChange> statusChangeListener_ = nullptr;
769     sptr<ISystemAbilityStatusChange> callManagerListener_ = nullptr;
770     std::mutex mutex_;
771 
772 private:
773     class SystemAbilityStatusChangeListener : public OHOS::SystemAbilityStatusChangeStub {
774     public:
775         SystemAbilityStatusChangeListener() = default;
776         explicit SystemAbilityStatusChangeListener(std::shared_ptr<CellularCallHandler> &cellularCallHandler);
777         ~SystemAbilityStatusChangeListener() = default;
778         virtual void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
779         virtual void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
780 
781     private:
782         std::shared_ptr<CellularCallHandler> cellularCallHandler_ = nullptr;
783         int32_t count_ = 0;
784     };
785 };
786 } // namespace Telephony
787 } // namespace OHOS
788 
789 #endif // CELLULAR_CALL_SERVICE_H
790