1 /*

     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:

    15  *

    16  */

    17 

    18 

    19 #include <etelmm.h>

    20 #include <xqsysinfo.h>

    21 #include <xqsettingsmanager.h>

    22 #include <xqsettingskey.h>

    23 #include <e32base.h>

    24 #include <etelmm.h>

    25 #include <exterror.h>               

    26 #include <gsmerror.h>

    27 #include <settingsinternalcrkeys.h>

    28 #include <LogsDomainCRKeys.h>

    29 #include <BTSapDomainPSKeys.h>

    30 #include <NumberGroupingCRKeys.h>

    31 #include <QPluginLoader>

    32 #include <cppluginplatinterface.h>

    33 #include <hbglobal.h>

    34 #include <CoreApplicationUIsSDKCRKeys.h>

    35 #include "cptelephonyutilsdefs.h"

    36 #include "cpplugincommon.h"

    37 #include "cppluginlogging.h"

    38 

    39 const int CenrepKeyValueOff = 0;

    40 const int CenrepKeyValueOn = 1;

    41 

    42 const int SoftRejectTextDefault = 0; 

    43 const int SoftRejectTextUserDefined = 1; 

    44 

    45 /*!

    46   Tools::loadCpPlugin

    47 */

    48 CpPluginPlatInterface* Tools::loadCpPlugin(const QString& name)

    49 {

    50     QPluginLoader loader("\\resource\\qt\\plugins\\controlpanel\\"+name+".qtplugin");

    51     return qobject_cast<CpPluginPlatInterface*> (loader.instance());

    52 }

    53 

    54 /*!

    55   Tools::unloadCpPlugin

    56 */

    57 bool Tools::unloadCpPlugin(const QString& name)

    58 {

    59     QPluginLoader loader("\\resource\\qt\\plugins\\controlpanel\\"+name+".qtplugin");

    60     return loader.unload();

    61 }

    62 

    63 /*!

    64   Tools::voipSupported

    65 */

    66 bool Tools::voipSupported()

    67 {

    68     return XQSysInfo::isSupported(KFeatureIdCommonVoip);

    69 }

    70 

    71 /*!

    72   Tools::videoSupported

    73 */

    74 bool Tools::videoSupported()

    75 {

    76     return XQSysInfo::isSupported(KFeatureIdCsVideoTelephony);

    77 }

    78 

    79 /*!

    80   Tools::convertEtelMobileServiceCode

    81 */

    82 BasicServiceGroups Tools::convertEtelMobileServiceCode(int serviceCode)

    83 {

    84     DPRINT;

    85 

    86     switch (serviceCode) {

    87         case RMobilePhone::EAllServices:

    88             return AllTeleAndBearer;

    89         case RMobilePhone::EAllTele:

    90             return AllTele;

    91         case RMobilePhone::EVoiceService:

    92         case RMobilePhone::ETelephony:

    93             return Telephony;

    94         case RMobilePhone::EAllDataTele:

    95             return AllDataTele;

    96         case RMobilePhone::EFaxService:

    97             return Fax;

    98         case RMobilePhone::EShortMessageService:

    99             return Sms;

   100         case RMobilePhone::EAllDataExSms:

   101             return AllDataExSms;

   102         case RMobilePhone::EAllTeleExcSms:

   103             return AllTeleExcSms;

   104         case RMobilePhone::EAllPlmnTele:

   105             return AllPlmnTele;

   106         case RMobilePhone::EPlmnTele1:

   107             return PlmnTele1;

   108         case RMobilePhone::EPlmnTele2:

   109             return PlmnTele2;

   110         case RMobilePhone::EPlmnTele3:

   111             return PlmnTele3;

   112         case RMobilePhone::EPlmnTele4:

   113             return PlmnTele4;

   114         case RMobilePhone::EPlmnTele5:

   115             return PlmnTele5;

   116         case RMobilePhone::EPlmnTele6:

   117             return PlmnTele6;

   118         case RMobilePhone::EPlmnTele7:

   119             return PlmnTele7;

   120         case RMobilePhone::EPlmnTele8:

   121             return PlmnTele8;

   122         case RMobilePhone::EPlmnTele9:

   123             return PlmnTele9;

   124         case RMobilePhone::EPlmnTeleA:

   125             return PlmnTeleA;

   126         case RMobilePhone::EPlmnTeleB:

   127             return PlmnTeleB;

   128         case RMobilePhone::EPlmnTeleC:

   129             return PlmnTeleC;

   130         case RMobilePhone::EPlmnTeleD:

   131             return PlmnTeleD;

   132         case RMobilePhone::EPlmnTeleE:

   133             return PlmnTeleE;

   134         case RMobilePhone::EPlmnTeleF:

   135             return PlmnTeleF;

   136         case RMobilePhone::EAllBearer:

   137             return AllBearer;

   138         case RMobilePhone::EAllAsync:

   139             return AllAsync;

   140         case RMobilePhone::EAllSync:

   141             return AllSync;

   142         case RMobilePhone::ECircuitDataService:

   143         case RMobilePhone::ESyncData:

   144             return SyncData;

   145         case RMobilePhone::EPacketDataService:

   146         case RMobilePhone::EAsyncData:

   147             return AsyncData;

   148         case RMobilePhone::EPacketData:

   149             return PacketData;

   150         case RMobilePhone::EPadAccess:

   151             return PadAccess;

   152         case RMobilePhone::EAllPlmnBearer:

   153             return AllPlmnBearer;

   154         case RMobilePhone::EPlmnBearerServ1:

   155             return PlmnBearerServ1;

   156         case RMobilePhone::EPlmnBearerServ2:

   157             return PlmnBearerServ2;

   158         case RMobilePhone::EPlmnBearerServ3:

   159             return PlmnBearerServ3;

   160         case RMobilePhone::EPlmnBearerServ4:

   161             return PlmnBearerServ4;

   162         case RMobilePhone::EPlmnBearerServ5:

   163             return PlmnBearerServ5;

   164         case RMobilePhone::EPlmnBearerServ6:

   165             return PlmnBearerServ6;

   166         case RMobilePhone::EPlmnBearerServ7:

   167             return PlmnBearerServ7;

   168         case RMobilePhone::EPlmnBearerServ8:

   169             return PlmnBearerServ8;

   170         case RMobilePhone::EPlmnBearerServ9:

   171             return PlmnBearerServ9;

   172         case RMobilePhone::EPlmnBearerServA:

   173             return PlmnBearerServA;

   174         case RMobilePhone::EPlmnBearerServB:

   175             return PlmnBearerServB;

   176         case RMobilePhone::EPlmnBearerServC:

   177             return PlmnBearerServC;

   178         case RMobilePhone::EPlmnBearerServD:

   179             return PlmnBearerServD;

   180         case RMobilePhone::EPlmnBearerServE:

   181             return PlmnBearerServE;

   182         case RMobilePhone::EPlmnBearerServF:

   183             return PlmnBearerServF;

   184         case RMobilePhone::EAuxVoiceService:

   185         case RMobilePhone::EAltTele:

   186             return AltTele;

   187         case RMobilePhone::EServiceUnspecified:

   188         default:

   189             qDebug() << "CpPhoneNotes::convertEtelMobileServiceCode, DEFAULT";

   190             return Unknown;

   191     }

   192 }

   193 

   194 /*!

   195   Tools::errorCodeTextMapping.

   196  */

   197 bool Tools::errorCodeTextMapping(const int errorcode, QString &errorText)

   198 {

   199     DPRINT;

   200     errorText.clear();

   201     bool errorTextFound(true);

   202 

   203     switch(errorcode){

   204         case KErrGsmSSSubscriptionViolation:

   205             errorText = hbTrId("Barring operation not successful. Contact your service provider");

   206             break;

   207         case KErrGsmSSUnknownSubscriber:

   208         case KErrGsmSSAbsentSubscriber:

   209         case KErrGsmSSIllegalOperation:

   210         case KErrGsmSSIllegalSubscriber:

   211         case KErrGsmSSIllegalEquipment:

   212         case KErrGsmSSCallBarred:

   213         case KErrGsmSSDataMissing:

   214             errorText = hbTrId("Not allowed");

   215             break;

   216         case KErrGsmSSIncompatibility:

   217             errorText = hbTrId("Services in conflict");

   218             break;

   219         case KErrGsmSSSystemFailure:

   220             errorText = hbTrId("Result unknown");

   221             break;

   222         case KErrGsmSSUnexpectedDataValue:

   223         case KErrGsmSSResourcesUnavailable:

   224             errorText = hbTrId("Request rejected");

   225             break;

   226         case KErrGsmSSNegativePasswordCheck:

   227         case KErrGsmSSPasswordRegistrationFailure:

   228             errorText = hbTrId("Password error");

   229             break;

   230         case KErrGsmSSPasswordAttemptsViolation:

   231             errorText = hbTrId("Password blocked");

   232             break;

   233         case KErrGsmSMSNoNetworkService:

   234         case KErrGsmNoService:

   235             errorText = hbTrId("No network coverage");

   236             break;

   237         case KErrSsActivationDataLost:

   238             errorText = hbTrId("Check network services");

   239             break;

   240         case KErrGsmOfflineOpNotAllowed:

   241             if(XQSysInfo::isSupported(KFeatureIdOfflineMode)){

   242                 XQSettingsManager *xqsettingsManager = new XQSettingsManager();

   243                 XQSettingsKey key(XQSettingsKey::TargetPublishAndSubscribe,

   244                         KPSUidBluetoothSapConnectionState.iUid,

   245                         KBTSapConnectionState);

   246                 QVariant startupValue = xqsettingsManager->readItemValue(key);

   247                 int value = startupValue.toInt();

   248                 delete xqsettingsManager;

   249                 xqsettingsManager = NULL;

   250                 if (value == EBTSapConnected){

   251                     errorText = hbTrId("Operation not possible in SIM access profile mode");

   252                 } else {

   253                     errorText = hbTrId("Operation not possible in Off-line mode");

   254                 }

   255             } else {

   256                 errorText = hbTrId("Not done");

   257             }

   258             break;

   259         case KErrGsmSSUnknownAlphabet:

   260             errorText = hbTrId("Invalid phone number");

   261             break;

   262         default:

   263             errorText = hbTrId("Not done");

   264             break;

   265     }

   266 

   267     return errorTextFound;

   268 }

   269 

   270 CpSettingsWrapper::CpSettingsWrapper(QObject *parent): 

   271     QObject(parent)

   272 {

   273     m_Settings = new XQSettingsManager();

   274 }

   275 

   276 CpSettingsWrapper::~CpSettingsWrapper()

   277 {

   278     delete m_Settings;

   279 }

   280 

   281 bool CpSettingsWrapper::showCallDuration()

   282 {

   283     bool showDuration; 

   284     if (CenrepKeyValueOn == readCenrepValue(KCRUidLogs.iUid, KLogsShowCallDuration).toInt()) {

   285         showDuration = true; 

   286     } else {

   287         showDuration = false;

   288     }

   289     

   290     DPRINT << "show call duration:" << showDuration;

   291     return showDuration;

   292 }

   293 

   294 int CpSettingsWrapper::setShowCallDuration(bool value)

   295 {

   296     int cenrepValue; 

   297     DPRINT << "show call duration:" << value;

   298 

   299     if (value) {

   300         cenrepValue = CenrepKeyValueOn;

   301     } else {

   302         cenrepValue = CenrepKeyValueOff; 

   303     }

   304     return writeCenrepValue(KCRUidLogs.iUid, KLogsShowCallDuration, cenrepValue );

   305 }

   306 

   307 void CpSettingsWrapper::readSoftRejectText(QString &text, bool &userDefined )

   308 {

   309     if (SoftRejectTextDefault ==

   310         readCenrepValue(KCRUidTelephonySettings.iUid, KSettingsSoftRejectDefaultInUse ).toInt()) {

   311         userDefined = false; 

   312     } else {

   313         userDefined = true; 

   314     }

   315         

   316     text = readCenrepString(KCRUidTelephonySettings.iUid, KSettingsSoftRejectText);

   317     DPRINT << "text:" << text << " ,userDefined:" << userDefined;

   318 }

   319 

   320 int CpSettingsWrapper::writeSoftRejectText(const QString &text, bool userDefined )

   321 {

   322     int err = writeCenrepValue(KCRUidTelephonySettings.iUid, KSettingsSoftRejectText, text);

   323     int cenrepValue; 

   324     if (userDefined) {

   325         cenrepValue = SoftRejectTextUserDefined; 

   326     } else {

   327         cenrepValue = SoftRejectTextDefault; 

   328     }

   329     err |= writeCenrepValue(KCRUidTelephonySettings.iUid, KSettingsSoftRejectDefaultInUse, cenrepValue);

   330     DPRINT << "text:" << text << " ,userDefined:" << userDefined << " , err:" << err;

   331     return err;

   332 }

   333 

   334  bool CpSettingsWrapper::numberGroupingSupported() const

   335  {

   336      return readCenrepValue(KCRUidNumberGrouping.iUid, KNumberGrouping).toBool();

   337  }

   338 

   339 QVariant CpSettingsWrapper::readCenrepValue(

   340     const long int uid, const unsigned long int key) const

   341 {

   342     XQSettingsKey settingsKey(XQSettingsKey::TargetCentralRepository, uid, key);

   343     QVariant ret = m_Settings->readItemValue(settingsKey);

   344     DPRINT << "ret: " << ret;

   345     return ret;

   346 }

   347 

   348 QString CpSettingsWrapper::readCenrepString(

   349     const long int uid, const unsigned long int key) const

   350 {

   351     XQSettingsKey settingsKey(XQSettingsKey::TargetCentralRepository, uid, key);

   352     QString text = m_Settings->readItemValue(settingsKey, XQSettingsManager::TypeString).toString();

   353     DPRINT << "text: " << text;

   354     return text;

   355 }

   356 

   357 int CpSettingsWrapper::writeCenrepValue(

   358     const long int uid, const unsigned long int key, const QVariant &settingsKeyValue ) const

   359 {

   360     DPRINT << "uid:" << uid << ", key:" << key << ", settingsKeyValue:" << settingsKeyValue;

   361     XQSettingsKey settingsKey(XQSettingsKey::TargetCentralRepository, uid, key);

   362     int err = m_Settings->writeItemValue(settingsKey, settingsKeyValue );

   363     DPRINT << "err: " << err;

   364     return err;

   365 }

   366 

   367 bool CpSettingsWrapper::isFeatureCallWaitingDistiquishNotProvisionedEnabled()

   368 {

   369     bool enabled = readCenrepValue(KCRUidPhoneSettings.iUid, KPSetCallWaiting).toBool();

   370     DPRINT << "enabled: " << enabled;

   371     return enabled;

   372 }

   373 

   374 bool CpSettingsWrapper::isPhoneOffline() const

   375 {

   376     bool offLinesupport(false);

   377     if (XQSysInfo::isSupported(KFeatureIdOfflineMode)) {

   378         offLinesupport = !readCenrepValue(

   379                 KCRUidCoreApplicationUIs.iUid, 

   380                 KCoreAppUIsNetworkConnectionAllowed).toBool();

   381     }

   382     return offLinesupport;

   383 }