2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
4 // Licensed under the Flora License, Version 1.0 (the License);
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
8 // http://floralicense.org/license/
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an AS IS BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
18 * @file CallTelephonyManager.h
19 * @brief This is the header file for the %TelephonyManager class.
21 * This header file contains the declarations for %TelephonyManager class.
23 #ifndef _PHN_TELEPHONY_MANAGER_H_
24 #define _PHN_TELEPHONY_MANAGER_H_
28 #include "ITapiCall.h"
29 #include "TapiUtility.h"
30 #include "CallITelephonyEventListener.h"
31 #include "CallSoundManager.h"
32 #include "CalllogManager.h"
35 class SettingsManager;
38 * @class TelephonyManager
39 * @brief TelephonyManager is a singleton class used to intialize TAPI library.
40 * And register to telephony events, interact with TAPI library.
42 class TelephonyManager
45 //Get singleton instance
46 static TelephonyManager* GetInstance(ITelephonyEventListener* pEventListener);
47 //Function to initiate (dial) an outgoing call.
48 ErrorCodes SetupMoCall(Tizen::Base::String& contactNumber, bool isEmergency);
49 //Function to end a call
50 result EndActiveCall(Tizen::Base::Long callHandle);
51 result EndDialingCall(Tizen::Base::String& contactNumber);
52 //Function to accept/reject an incoming call
53 result AnswerCall(int callHandle, bool acceptCall);
54 //Function to accept call with the given options
55 result AcceptCall(CallAnsweringOptions answerOptions,int callHandle);
56 //Function to end a conference call
57 result EndConferenceCall(void);
58 //Function to hold/retrieve a conference call
59 result HoldConferenceCall(bool holdCall);
60 //Function to join active and held call to conference
61 result JoinCall(void);
62 //Function to hold/unhold the call
63 result HoldCall(Tizen::Base::Long callHandle, bool holdCall);
64 //Function to swap the active and held call
65 result SwapCalls(void);
66 //Function to send DTMF strings
67 result SendCallDTMF(Tizen::Base::String& textToBeSent);
68 //Function to end a single call from the conference
69 result EndFromConference(int callHandle);
70 //Function to split a single call from the conference
71 result SplitFromConference(int callHandle);
72 //Function to set the mute status
73 result SetMuteStatus(bool setMute);
74 //Function to get the mute Status
75 bool IsCallMuted(void);
76 //Function to set the speaker status
77 result SetSpeakerStatus(bool setSpeaker);
78 //Function to get the speaker status
79 bool IsSpeakerOn(void);
80 //Function to check if split operation is allowed from the conference
81 bool IsSplitAllowed(void);
82 //Function to get the conference call info
83 CallInfo* GetConferenceCallInfoN(void);
84 //Get the current call list
85 Tizen::Base::Collection::IListT<CallInfo>* GetCallListN(void);
86 //Get the current call count
87 int GetCurrentCallCount(void);
88 //Start the alert in case of incoming call
89 void StartAlert(CallInfo& incomingCallInfo);
90 //Stop the alert in case of incoming call
92 //Main Callback function used while registering to TAPI
93 static void HandleCallback(TapiHandle* pHandle, const char* pNotiId, void* pData, void* pUserData);
94 //Dummy callback function used when nothing is to be done on response
95 static void HandleCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
96 //callback function for dial operation
97 static void HandleDialCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
98 //callback function for the join operation
99 static void HandleJoinCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
100 //callback function for the reject call operation
101 static void HandleRejectCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
102 //callback function for the swap calls operation
103 static void HandleSwapCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
104 //callback function for the End from conference operation
105 static void HandleEndFromConferenceCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
106 //callback function for the split from conference operation
107 static void HandleSplitFromConferenceCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
108 //callback function for Ending conference call
109 static void HandleEndConferenceCallbackResponse(TapiHandle* pHandle, int callBackResult, void* pData, void* pUserData);
110 //Check if MOCall is emergency number and returns true. Otherwise, false.
111 bool CheckIfMOCallIsEmergency(const Tizen::Base::String& contactNumber, bool isSimInitialized);
112 //Check is modem and sim are initialised successfully and MO call can be made.
113 result CheckIfMOCallIsPossible();
114 //Gets the contact for the given phonenumber.returns null if not present.
115 Tizen::Social::Contact* GetContactN(const Tizen::Base::String& phoneNumber);
116 //This function make a synchronus API call to TAPI to fetch active/waiting incoming calls.
117 CallInfo* FetchIncomingCallHandleN(const Tizen::Base::String& callHandle, const Tizen::Base::String& contactNumber);
118 //This callback function is called by TAPI each time for every single call.
119 static void HandleIncomingCallStatusCallBack(TelCallStatus_t* pCallStatus, void* pUserData);
120 //function used to process incoming call and decide whether to reject call based on call settings.
121 //Rejects the call and returns true, Else returns false.
122 bool CheckIncomingCallToBeRejected(CallInfo* pIncomingCallInfo);
124 void EndAllCalls(void);
127 //function to handle the idle callback(received when call is ended)
128 void HandleIdleCallBack(void* pData);
129 //function used to handle events for normal call disconnected.
130 bool HandleEndNormalActiveCall(CallInfo& endCallInfo);
131 //function to handle the active callback(received when call is connected)
132 void HandleActiveCallBack(void* pData);
133 //function to handle call connected successfully
134 void HandleCallConnected(unsigned int connectedCallHandle);
135 //function to handle the dial call callback
136 void HandleDialingCallBack(void* pData);
137 //function to handle ending of single participant in conference call.
138 bool HandleParticipantEndedFromConference(unsigned int participantCallHandle, CallInfo& conferenceCall);
141 //create a singleton instance
142 static void CreateInstance(ITelephonyEventListener* pEventListener);
143 //used to destroy 'TelephonyManager' instance at application exit.
144 static void DestroyInstance(void);
146 virtual ~TelephonyManager(void);
147 TelephonyManager(ITelephonyEventListener* pEventListener);
148 TelephonyManager(TelephonyManager& manager);
149 TelephonyManager& operator =(TelephonyManager& manager);
150 //perform 2nd phase initialisation
151 result Initialize(void);
152 //initialise the TAPI library
153 result InitializeTelephonyLibrary(void);
154 //register for the TAPI events
155 int RegisterEvents(void);
156 //unregister from the TAPI events
157 void UnregisterEvents(void);
158 //internal function to hold an active call
159 result HoldActiveCall(CallInfo* pActiveCallInfo, bool holdCall);
160 //internal function to make a call
161 result DialOutgoingCall(Tizen::Base::String& contactNumber, bool isEmergency);
162 //internal function to handle waiting call options when single call is present
163 result AcceptSecondCall(CallAnsweringOptions answerOptions, const int incomingCallHandle);
164 //internal function to handle waiting call options when multiple calls are present
165 result AcceptMultipleCall(CallAnsweringOptions answerOptions, const int incomingCallHandle);
166 //internal function to End Call
167 result EndCall(CallInfo& endCallInfo);
169 * This function is internally used to fetch contact person details -
170 * display name & photo id from AddressBook for the given phone number.
172 * @param[in] phoneNumber - The substring of the phoneNumber to search
173 * @return E_SUCCESS, if found else E_FAILURE.
175 result FetchContactInfoForNumber(const Tizen::Base::String& phoneNumberStr);
176 //check if given contact number is valid and returns 'E_SUCCESS', else 'E_FAILURE'.
177 result CheckValidTelePhoneNumber(const Tizen::Base::String& contactNumber);
178 //Used to save ended call Log info to Logs database.
179 void SaveCallInfoToLogsDb(CallInfo& endCallInfo);
182 static TelephonyManager* __pManager;
185 CallInfo* __pDialedCall;
187 CallInfo* __pIncomingCall;
188 //Active Calls - only 2 active calls at any time
189 //can hold both Single or Conf. Calls
190 //mapping of "Call handle" to "CallInfo"
191 Tizen::Base::Collection::HashMapT<long, CallInfo>* __pActiveCallList;
193 //Listener for telephony events
194 ITelephonyEventListener* __pEventListener;
196 SettingsManager* __pSettingsManager;
198 //handle to Telephony API
199 TapiHandle* __pTapiHandle;
200 //used to connect to Address Book APIs.
201 Tizen::Social::Addressbook* __pAddressBook;
202 //used to store previously fetched contact.
203 Tizen::Social::Contact* __pCachedContact;
208 SoundManager* __pSoundManager;
209 CallLogManager* __pCalllogMgr;
212 #endif // _PHN_TELEPHONY_MANAGER_H_