src/CallSettingsManager.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (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         if(__pCallSettingDataService != null)
 140         {
 141         return __pCallSettingDataService->IsCallToBeRejected(phoneNumber);
 142 }
 143         else
 144         {
 145                 return false;
 146         }
 147 }
 148
 149 bool
 150 SettingsManager::GetUnknownRejectStatus(void)
 151 {
 152         int unknownRejectStatus = -1;
 153
 154         vconf_get_bool(VCONFKEY_CISSAPPL_AUTO_REJECT_UNKNOWN_BOOL, &unknownRejectStatus);
 155
 156         bool retVal = unknownRejectStatus;
 157         return retVal;
 158 }
 159
 160 void
 161 SettingsManager::NotifyForwardingEventListeners(ForwardResponseType responseType, bool isCallSuccessful, CallForwardCondition callFwdCondition, const Tizen::Base::String& callFwdNumber, bool isCallForwardActivated, int noReplyWaitTime)
 162 {
 163         IEnumeratorT<ISettingsEventListener*>* pListenerEnum = null;
 164         result r = E_FAILURE;
 165         if (__pSettingsEventListener != null)
 166         {
 167                 pListenerEnum = __pSettingsEventListener->GetEnumeratorN();
 168                 //TryReturn(pListenerEnum != null, GetLastResult(), "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 169
 170                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
 171                 {
 172                         ISettingsEventListener* pListener;
 173                         r = pListenerEnum->GetCurrent(pListener);
 174                         //TryCatch(r == E_SUCCESS, , "[%s] Propagated.", GetErrorMessage(r));
 175                         if (responseType == SET_CALLFORWARD_RESPONSE)
 176                         {
 177                                 pListener->HandleSetCallForwardResponse(isCallSuccessful, callFwdCondition, callFwdNumber, isCallForwardActivated, noReplyWaitTime);
 178                         }
 179                         else
 180                         {
 181                                 pListener->HandleGetCallForwardResponse(isCallSuccessful, callFwdCondition, callFwdNumber, isCallForwardActivated, noReplyWaitTime);
 182                         }
 183                 }
 184         }
 185 }
 186
 187 void
 188 SettingsManager::NotifyBarringEventListeners(BarringResponseType responseType, bool isCallSuccessful, CallBarringType callBarringType, bool isBarringActivated)
 189 {
 190         IEnumeratorT<ISettingsEventListener*>* pListenerEnum = null;
 191         result r = E_FAILURE;
 192         if (__pSettingsEventListener != null)
 193         {
 194                 pListenerEnum = __pSettingsEventListener->GetEnumeratorN();
 195                 //TryReturn(pListenerEnum != null, GetLastResult(), "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 196
 197                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
 198                 {
 199                         ISettingsEventListener* pListener;
 200                         r = pListenerEnum->GetCurrent(pListener);
 201                         //TryCatch(r == E_SUCCESS, , "[%s] Propagated.", GetErrorMessage(r));
 202                         if (responseType == SET_CALLBARRING_RESPONSE)
 203                         {
 204                                 pListener->HandleSetCallBarringResponse(isCallSuccessful, callBarringType, isBarringActivated);
 205                         }
 206                         else
 207                         {
 208                                 pListener->HandleGetCallBarringResponse(isCallSuccessful, callBarringType, isBarringActivated);
 209                         }
 210                 }
 211         }
 212 }
 213
 214 void
 215 SettingsManager::NotifyWaitingEventListeners(WaitingResponseType responseType, bool isCallSuccessful, bool isCallWaitingActivated)
 216 {
 217         IEnumeratorT<ISettingsEventListener*>* pListenerEnum = null;
 218         result r = E_FAILURE;
 219         if (__pSettingsEventListener != null)
 220         {
 221                 pListenerEnum = __pSettingsEventListener->GetEnumeratorN();
 222                 //TryReturn(pListenerEnum != null, GetLastResult(), "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 223
 224                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
 225                 {
 226                         ISettingsEventListener* pListener;
 227                         r = pListenerEnum->GetCurrent(pListener);
 228                         //TryCatch(r == E_SUCCESS, , "[%s] Propagated.", GetErrorMessage(r));
 229                         if (responseType == SET_CALLWAITING_RESPONSE)
 230                         {
 231                                 pListener->HandleSetCallWaitingResponse(isCallSuccessful, isCallWaitingActivated);
 232                         }
 233                         else
 234                         {
 235                                 pListener->HandleGetCallWaitingResponse(isCallSuccessful, isCallWaitingActivated);
 236                         }
 237                 }
 238                 delete pListenerEnum;
 239         }
 240 }
 241
 242 IMapT<int,String>*
 243 SettingsManager::GetRejectMessageListN(void)
 244 {
 245         int messagesCount;
 246         char* pMessage = null;
 247         HashMapT<int,String> *pMessageMap = null;
 248
 249         int retval = vconf_get_int(VCONFKEY_CISSAPPL_REJECT_CALL_MSG_INT, &messagesCount);
 250         if (retval == 0 && messagesCount > 0)
 251         {
 252                 pMessageMap = new (std::nothrow) HashMapT<int,String>();
 253                 pMessageMap->Construct(messagesCount);
 254                 for (int index = 0; index < messagesCount; index++)
 255                 {
 256                         int keyForMsg = index;
 257                         String *pMessageStr = new (std::nothrow) String();
 258                         switch (index)
 259                         {
 260                         case 0:
 261                         {
 262                                 pMessage = vconf_get_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG1_STR);
 263                         }
 264                         break;
 265
 266                         case 1:
 267                         {
 268                                 pMessage = vconf_get_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG2_STR);
 269                         }
 270                         break;
 271
 272                         case 2:
 273                         {
 274                                 pMessage = vconf_get_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG3_STR);
 275                         }
 276                         break;
 277
 278                         case 3:
 279                         {
 280                                 pMessage = vconf_get_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG4_STR);
 281                         }
 282                         break;
 283
 284                         case 4:
 285                         {
 286                                 pMessage = vconf_get_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG5_STR);
 287                         }
 288                         break;
 289
 290                         case 5:
 291                         {
 292                                 pMessage = vconf_get_str(VCONFKEY_CISSAPPL_USER_CREATE_MSG6_STR);
 293                         }
 294                         break;
 295
 296                         default:
 297                         {
 298                                 delete pMessageMap;
 299                                 pMessageMap = null;
 300                                 delete pMessageStr;
 301                                 pMessageStr = null;
 302                                 return null;
 303                         }
 304                         break;
 305                         }
 306                         //todo:Chk if this is allowed outside the call settings library
 307                         if((pMessage != null) && (String(pMessage).IsEmpty() == false))
 308                         {
 309                         bindtextdomain("ug-setting-call-efl", "/usr/ug/res/locale");
 310                         pMessageStr->Append(dgettext("ug-setting-call-efl", pMessage));
 311                         pMessageMap->Add(keyForMsg, *pMessageStr);
 312                 }
 313         }
 314         }
 315         return pMessageMap;
 316 }
 317
 318 result
 319 SettingsManager::SetCallState(CallState callState)
 320 {
 321         AppLogDebug("Enter %d",callState);
 322         result r = E_FAILURE;
 323         int retVal = vconf_set_int(VCONFKEY_CALL_STATE, callState);
 324         if (retVal == 0)
 325         {
 326                 AppLogDebug("Success");
 327                 r = E_SUCCESS;
 328         }
 329         return r;
 330 }
 331 void
 332 SettingsManager::AddSystemEventListener(void)
 333 {
 334         Tizen::System::SettingInfo::AddSettingEventListener(*this);
 335 }
 336
 337 void
 338 SettingsManager::RemoveSystemEventListener(void)
 339 {
 340         Tizen::System::SettingInfo::RemoveSettingEventListener(*this);
 341 }
 342
 343 void
 344 SettingsManager::OnSettingChanged(Tizen::Base::String& key)
 345 {
 346         AppLogDebug("Enter");
 347         //Flight mode changed
 348         if(key.Equals(String(SETTINGS_FLIGHT_MODE_STR)))
 349         {
 350                 bool flightMode = false;
 351                 SettingInfo::GetValue(key, flightMode);
 352                 if(flightMode == true)
 353                 {
 354                         // Notify if some active call is going on
 355                         IEnumeratorT<ISettingsEventListener*>* pListenerEnum = null;
 356                         result r = E_FAILURE;
 357                         if (__pSettingsEventListener != null)
 358                         {
 359                                 pListenerEnum = __pSettingsEventListener->GetEnumeratorN();
 360                                 //TryReturn(pListenerEnum != null, GetLastResult(), "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 361
 362                                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
 363                                 {
 364                                         ISettingsEventListener* pListener;
 365                                         r = pListenerEnum->GetCurrent(pListener);
 366                                         pListener->HandleFlightMode(true);
 367
 368                                 }
 369                         }
 370
 371                 }
 372         }
 373 }
 374
 375 bool
 376 SettingsManager::GetFlightModeStatus(void)
 377 {
 378     result r = E_SUCCESS;
 379
 380     String key(SETTINGS_FLIGHT_MODE_STR);
 381     bool flightMode = false;
 382
 383     r = SettingInfo::GetValue(key, flightMode);
 384     TryCatch(r == E_SUCCESS, , "GetFlightModeStatus: To get a value is failed");
 385
 386     return flightMode;
 387
 388    CATCH:
 389     return flightMode;
 390 }
 391