src/CallSettingsManager.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   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
   7 //
   8 //     http://floralicense.org/license/
   9 //
  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.
  15 //
  16
  17 /**
  18  * @file    CallSettingsManager.cpp
  19  * @brief   Setting Manager class
  20  */
  21 #include <libintl.h>
  22 #include <FApp.h>
  23 #include <FSocial.h>
  24 #include <FBaseColIList.h>
  25 #include "vconf.h"
  26 #include "vconf-internal-ciss-keys.h"
  27 #include "CallSettingsManager.h"
  28 #include "CallTypes.h"
  29
  30 using namespace Tizen::App;
  31 using namespace Tizen::Base;
  32 using namespace Tizen::Base::Collection;
  33 using namespace Tizen::Io;
  34 using namespace Tizen::Social;
  35 using namespace Tizen::System;
  36
  37 SettingsManager* SettingsManager::__pInstance = null;
  38
  39 SettingsManager::SettingsManager(void)
  40         : __pTapiHandle(null)
  41         , __pSettingsEventListener(null)
  42         , __pCallSettingDataService(null)
  43 {
  44
  45 }
  46
  47 SettingsManager::~SettingsManager(void)
  48 {
  49         //De-initialize the TAPI Library
  50         if(__pTapiHandle != null)
  51         {
  52                 tel_deinit(__pTapiHandle);
  53         }
  54         if (__pCallSettingDataService)
  55         {
  56                 __pCallSettingDataService->CloseDatabase();
  57                 delete __pCallSettingDataService;
  58         }
  59         if (__pSettingsEventListener != null)
  60         {
  61                 delete __pSettingsEventListener;
  62         }
  63         RemoveSystemEventListener();
  64 }
  65
  66 void SettingsManager::CreateInstance(void)
  67 {
  68         __pInstance = new (std::nothrow) SettingsManager();
  69         result r = __pInstance->Construct();
  70         if(IsFailed(r))
  71         {
  72                 delete __pInstance;
  73                 __pInstance = null;
  74                 return;
  75         }
  76         std::atexit(&(SettingsManager::DestroyInstance));
  77 }
  78
  79 void SettingsManager::DestroyInstance(void)
  80 {
  81         delete __pInstance;
  82 }
  83
  84 result
  85 SettingsManager::Construct(void)
  86 {
  87         __pCallSettingDataService = CallSettingDataService::CreateInstance();
  88         result r = __pCallSettingDataService->OpenDatabase();
  89         if(IsFailed(r))
  90         {
  91                 return E_FAILURE;
  92         }
  93         //initialize telephony
  94         __pTapiHandle = tel_init(null);
  95         SetCallState(CALL_STATE_CALL_OFF);
  96         AddSystemEventListener();
  97         return E_SUCCESS;
  98 }
  99
 100 SettingsManager*
 101 SettingsManager::GetInstance(void)
 102 {
 103         if (__pInstance == null)
 104         {
 105                 CreateInstance();
 106         }
 107         return __pInstance;
 108 }
 109
 110 void
 111 SettingsManager::AddSettingEventListener(ISettingsEventListener* pSettingsEventListener)
 112 {
 113         if (__pSettingsEventListener == null)
 114         {
 115                 __pSettingsEventListener = new (std::nothrow) ArrayListT<ISettingsEventListener*>();
 116         }
 117
 118         //Add to listeners, if not already in list.
 119         if ( (pSettingsEventListener != null)
 120                         && !(__pSettingsEventListener->Contains(pSettingsEventListener)) )
 121         {
 122                 __pSettingsEventListener->Add(pSettingsEventListener);
 123         }
 124 }
 125
 126 void
 127 SettingsManager::RemoveSettingEventListener(ISettingsEventListener* pSettingsEventListener)
 128 {
 129         if ((__pSettingsEventListener != null) && (pSettingsEventListener != null)
 130                         && __pSettingsEventListener->Contains(pSettingsEventListener))
 131         {
 132                 __pSettingsEventListener->Remove(pSettingsEventListener);
 133         }
 134 }
 135
 136 bool
 137 SettingsManager::IsCallToBeRejected(String& phoneNumber)
 138 {
 139         return __pCallSettingDataService->IsCallToBeRejected(phoneNumber);
 140 }
 141
 142 bool
 143 SettingsManager::GetUnknownRejectStatus(void)
 144 {
 145         int unknownRejectStatus = -1;
 146
 147         vconf_get_bool(VCONFKEY_CISSAPPL_AUTO_REJECT_UNKNOWN_BOOL, &unknownRejectStatus);
 148
 149         bool retVal = unknownRejectStatus;
 150         return retVal;
 151 }
 152
 153 void
 154 SettingsManager::NotifyForwardingEventListeners(ForwardResponseType responseType, bool isCallSuccessful, CallForwardCondition callFwdCondition, const Tizen::Base::String& callFwdNumber, bool isCallForwardActivated, int noReplyWaitTime)
 155 {
 156         IEnumeratorT<ISettingsEventListener*>* pListenerEnum = null;
 157         result r = E_FAILURE;
 158         if (__pSettingsEventListener != null)
 159         {
 160                 pListenerEnum = __pSettingsEventListener->GetEnumeratorN();
 161                 //TryReturn(pListenerEnum != null, GetLastResult(), "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 162
 163                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
 164                 {
 165                         ISettingsEventListener* pListener;
 166                         r = pListenerEnum->GetCurrent(pListener);
 167                         //TryCatch(r == E_SUCCESS, , "[%s] Propagated.", GetErrorMessage(r));
 168                         if (responseType == SET_CALLFORWARD_RESPONSE)
 169                         {
 170                                 pListener->HandleSetCallForwardResponse(isCallSuccessful, callFwdCondition, callFwdNumber, isCallForwardActivated, noReplyWaitTime);
 171                         }
 172                         else
 173                         {
 174                                 pListener->HandleGetCallForwardResponse(isCallSuccessful, callFwdCondition, callFwdNumber, isCallForwardActivated, noReplyWaitTime);
 175                         }
 176                 }
 177         }
 178 }
 179
 180 void
 181 SettingsManager::NotifyBarringEventListeners(BarringResponseType responseType, bool isCallSuccessful, CallBarringType callBarringType, bool isBarringActivated)
 182 {
 183         IEnumeratorT<ISettingsEventListener*>* pListenerEnum = null;
 184         result r = E_FAILURE;
 185         if (__pSettingsEventListener != null)
 186         {
 187                 pListenerEnum = __pSettingsEventListener->GetEnumeratorN();
 188                 //TryReturn(pListenerEnum != null, GetLastResult(), "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 189
 190                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
 191                 {
 192                         ISettingsEventListener* pListener;
 193                         r = pListenerEnum->GetCurrent(pListener);
 194                         //TryCatch(r == E_SUCCESS, , "[%s] Propagated.", GetErrorMessage(r));
 195                         if (responseType == SET_CALLBARRING_RESPONSE)
 196                         {
 197                                 pListener->HandleSetCallBarringResponse(isCallSuccessful, callBarringType, isBarringActivated);
 198                         }
 199                         else
 200                         {
 201                                 pListener->HandleGetCallBarringResponse(isCallSuccessful, callBarringType, isBarringActivated);
 202                         }
 203                 }
 204         }
 205 }
 206
 207 void
 208 SettingsManager::NotifyWaitingEventListeners(WaitingResponseType responseType, bool isCallSuccessful, bool isCallWaitingActivated)
 209 {
 210         IEnumeratorT<ISettingsEventListener*>* pListenerEnum = null;
 211         result r = E_FAILURE;
 212         if (__pSettingsEventListener != null)
 213         {
 214                 pListenerEnum = __pSettingsEventListener->GetEnumeratorN();
 215                 //TryReturn(pListenerEnum != null, GetLastResult(), "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 216
 217                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
 218                 {
 219                         ISettingsEventListener* pListener;
 220                         r = pListenerEnum->GetCurrent(pListener);
 221                         //TryCatch(r == E_SUCCESS, , "[%s] Propagated.", GetErrorMessage(r));
 222                         if (responseType == SET_CALLWAITING_RESPONSE)
 223                         {
 224                                 pListener->HandleSetCallWaitingResponse(isCallSuccessful, isCallWaitingActivated);
 225                         }
 226                         else
 227                         {
 228                                 pListener->HandleGetCallWaitingResponse(isCallSuccessful, isCallWaitingActivated);
 229                         }
 230                 }
 231                 delete pListenerEnum;
 232         }
 233 }
 234
 235 IMapT<int,String>*
 236 SettingsManager::GetRejectMessageListN(void)
 237 {
 238         int messagesCount;
 239         char* pMessage = null;
 240         HashMapT<int,String> *pMessageMap = null;
 241
 242         int retval = vconf_get_int(VCONFKEY_CISSAPPL_REJECT_CALL_MSG_INT, &messagesCount);
 243         if (retval == 0 && messagesCount > 0)
 244         {
 245                 pMessageMap = new (std::nothrow) HashMapT<int,String>();
 246                 pMessageMap->Construct(messagesCount);
 247                 for (int index = 0; index < messagesCount; index++)
 248                 {
 249                         int keyForMsg = index;
 250                         String *pMessageStr = new (std::nothrow) String();
 251                         switch (index)
 252                         {
 253                         case 0:
 254                         {
 255                                 pMessage = vconf_get_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG1_STR);
 256                         }
 257                         break;
 258
 259                         case 1:
 260                         {
 261                                 pMessage = vconf_get_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG2_STR);
 262                         }
 263                         break;
 264
 265                         case 2:
 266                         {
 267                                 pMessage = vconf_get_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG3_STR);
 268                         }
 269                         break;
 270
 271                         case 3:
 272                         {
 273                                 pMessage = vconf_get_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG4_STR);
 274                         }
 275                         break;
 276
 277                         case 4:
 278                         {
 279                                 pMessage = vconf_get_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG5_STR);
 280                         }
 281                         break;
 282
 283                         case 5:
 284                         {
 285                                 pMessage = vconf_get_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG6_STR);
 286                         }
 287                         break;
 288
 289                         default:
 290                         {
 291                                 delete pMessageMap;
 292                                 pMessageMap = null;
 293                                 delete pMessageStr;
 294                                 pMessageStr = null;
 295                                 return null;
 296                         }
 297                         break;
 298                         }
 299                         //todo:Chk if this is allowed outside the call settings library
 300                         if((pMessage != null) && (String(pMessage).IsEmpty() == false))
 301                         {
 302                         bindtextdomain("ug-setting-call-efl", "/usr/ug/res/locale");
 303                         pMessageStr->Append(dgettext("ug-setting-call-efl", pMessage));
 304                         pMessageMap->Add(keyForMsg, *pMessageStr);
 305                 }
 306         }
 307         }
 308         return pMessageMap;
 309 }
 310
 311 result
 312 SettingsManager::SetCallState(CallState callState)
 313 {
 314         AppLogDebug("Enter %d",callState);
 315         result r = E_FAILURE;
 316         int retVal = vconf_set_int(VCONFKEY_CALL_STATE, callState);
 317         if (retVal == 0)
 318         {
 319                 AppLogDebug("Success");
 320                 r = E_SUCCESS;
 321         }
 322         return r;
 323 }
 324 void
 325 SettingsManager::AddSystemEventListener(void)
 326 {
 327         Tizen::System::SettingInfo::AddSettingEventListener(*this);
 328 }
 329
 330 void
 331 SettingsManager::RemoveSystemEventListener(void)
 332 {
 333         Tizen::System::SettingInfo::RemoveSettingEventListener(*this);
 334 }
 335
 336 void
 337 SettingsManager::OnSettingChanged(Tizen::Base::String& key)
 338 {
 339         AppLogDebug("Enter");
 340         //Flight mode changed
 341         if(key.Equals(String(SETTINGS_FLIGHT_MODE_STR)))
 342         {
 343                 bool flightMode = false;
 344                 SettingInfo::GetValue(key, flightMode);
 345                 if(flightMode == true)
 346                 {
 347                         // Notify if some active call is going on
 348                         IEnumeratorT<ISettingsEventListener*>* pListenerEnum = null;
 349                         result r = E_FAILURE;
 350                         if (__pSettingsEventListener != null)
 351                         {
 352                                 pListenerEnum = __pSettingsEventListener->GetEnumeratorN();
 353                                 //TryReturn(pListenerEnum != null, GetLastResult(), "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 354
 355                                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
 356                                 {
 357                                         ISettingsEventListener* pListener;
 358                                         r = pListenerEnum->GetCurrent(pListener);
 359                                         pListener->HandleFlightMode(true);
 360
 361                                 }
 362                         }
 363
 364                 }
 365         }
 366 }
 367
 368 bool
 369 SettingsManager::GetFlightModeStatus(void)
 370 {
 371     result r = E_SUCCESS;
 372
 373     String key(SETTINGS_FLIGHT_MODE_STR);
 374     bool flightMode = false;
 375
 376     r = SettingInfo::GetValue(key, flightMode);
 377     TryCatch(r == E_SUCCESS, , "GetFlightModeStatus: To get a value is failed");
 378
 379     return flightMode;
 380
 381    CATCH:
 382     return flightMode;
 383 }
 384