Mercurial Mercurial > oss > FCL > sf > app > phone / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
phoneengine/phoneservices/src/dialservice.cpp
changeset 50 377c906a8701
parent 46 bc5a64e5bc3c
child 78 baacf668fe89
equal deleted inserted replaced
46:bc5a64e5bc3c 50:377c906a8701 
     1 /*!
 
     1 /*!
 
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
 
     3 * All rights reserved.
 
     3 * All rights reserved.
 
     4 * This component and the accompanying materials are made available
 
     4 * This component and the accompanying materials are made available
 
     5 * under the terms of "Eclipse Public License v1.0"
 
     5 * under the terms of "Eclipse Public License v1.0"
 
     6 * which accompanies this distribution, and is available
 
     6 * which accompanies this distribution, and is available
 
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
    19 #include <e32base.h>
 
    19 #include <e32base.h>
 
    20 #include <qregexp.h>
 
    20 #include <qregexp.h>
 
    21 #include <featmgr.h>
 
    21 #include <featmgr.h>
 
    22 #include <settingsinternalcrkeys.h>
 
    22 #include <settingsinternalcrkeys.h>
 
    23 #include <xqsettingsmanager.h>
 
    23 #include <xqsettingsmanager.h>
 
       
    24 #include <e32capability.h>
 
    24 #include "dialservice.h"
 
    25 #include "dialservice.h"
 
    25 #include "qtphonelog.h"
 
    26 #include "qtphonelog.h"
 
    26 
    27 
    27 // CONSTANTS
 
    28 // CONSTANTS
 
    28 const int MaxPrefixStringLength = 10;
 
    29 const XQSettingsKey dialPrefixMode(XQSettingsKey::TargetCentralRepository, KCRUidTelephonySettings.iUid, KSettingsDialPrefixChangeMode);
 
    29 const XQSettingsKey dialPrefixMode(XQSettingsKey::TargetCentralRepository, KCRUidNetworkSettings.iUid, KSettingsDialPrefixChangeMode);
 
    30 const XQSettingsKey dialPrefixString(XQSettingsKey::TargetCentralRepository, KCRUidTelephonySettings.iUid, KSettingsDialPrefixText);
 
    30 const XQSettingsKey dialPrefixString(XQSettingsKey::TargetCentralRepository, KCRUidNetworkSettings.iUid, KSettingsDialPrefixText);
 
    31 
    31 
    32 DialService::DialService(MPECallControlIF &call, MPECallSettersIF &parameters, QObject* parent) :
 
    32 DialService::DialService(MPECallControlIF &call, MPECallSettersIF &parameters, QObject* parent) : 
    33     XQServiceProvider(QLatin1String("phoneui.com.nokia.symbian.ICallDial"), parent), m_call (call), m_parameters (parameters), m_settingsManager(0)
 
    33     XQServiceProvider(QLatin1String("com.nokia.symbian.ICallDial"), parent), m_call (call), m_parameters (parameters), m_settingsManager(0)
 
       
    34 {
 
    34 {
 
    35     publishAll();
 
    35     publishAll();
 
    36     m_settingsManager = new XQSettingsManager(this);
 
    36     m_settingsManager = new XQSettingsManager(this);
 
    37     Q_ASSERT(m_settingsManager != 0);
 
    37     Q_ASSERT(m_settingsManager != 0);
 
    38 }
 
    38 }
 
    42 }
 
    42 }
 
    43 
    43 
    44 int DialService::dial(const QString& number)
 
    44 int DialService::dial(const QString& number)
 
    45 {
 
    45 {
 
    46     PHONE_DEBUG2("DialService::dial number:", number);
 
    46     PHONE_DEBUG2("DialService::dial number:", number);
 
       
    47     if (!hasCapability()) {
 
       
    48         return KErrPermissionDenied;
 
       
    49     }
 
    47     QString phoneNumber = modifyPhoneNumber(number);
 
    50     QString phoneNumber = modifyPhoneNumber(number);
 
    48     TPtrC16 numberPtr(reinterpret_cast<const TUint16*>(phoneNumber.utf16()));
 
    51     TPtrC16 numberPtr(reinterpret_cast<const TUint16*>(phoneNumber.utf16()));
 
    49     m_parameters.SetPhoneNumber (numberPtr);
 
    52     m_parameters.SetPhoneNumber (numberPtr);
 
    50     m_parameters.SetCallTypeCommand (EPECallTypeCSVoice);
 
    53     m_parameters.SetCallTypeCommand (EPECallTypeCSVoice);
 
    51     return m_call.HandleDialServiceCall ();
 
    54     return m_call.HandleDialServiceCall ();
 
    52 }
 
    55 }
 
    53 
    56 
    54 int DialService::dial(const QString& number, int contactId)
 
    57 int DialService::dial(const QString& number, int contactId)
 
    55 {
 
    58 {
 
    56     PHONE_DEBUG4("DialService::dial number:", number, "contactId:", contactId);
 
    59     PHONE_DEBUG4("DialService::dial number:", number, "contactId:", contactId);
 
       
    60 	if (!hasCapability()) {
 
       
    61 		return KErrPermissionDenied;
 
       
    62     }
 
    57     QString phoneNumber = modifyPhoneNumber(number);
 
    63     QString phoneNumber = modifyPhoneNumber(number);
 
    58     TPtrC16 numberPtr (reinterpret_cast<const TUint16*>(phoneNumber.utf16()));
 
    64     TPtrC16 numberPtr (reinterpret_cast<const TUint16*>(phoneNumber.utf16()));
 
    59     m_parameters.SetPhoneNumber (numberPtr);
 
    65     m_parameters.SetPhoneNumber (numberPtr);
 
    60     m_parameters.SetCallTypeCommand (EPECallTypeCSVoice);
 
    66     m_parameters.SetCallTypeCommand (EPECallTypeCSVoice);
 
    61     m_parameters.SetContactId2 (contactId);
 
    67     m_parameters.SetContactId2 (contactId);
 
    62     return m_call.HandleDialServiceCall (); 
    68     return m_call.HandleDialServiceCall ();
 
    63 }
 
    69 }
 
    64 
    70 
    65 void DialService::dialVideo(const QString& number)
 
    71 int DialService::dialVideo(const QString& number)
 
    66 {
 
    72 {
 
    67     PHONE_DEBUG2("DialService::dialVideo number:", number);
 
    73     PHONE_DEBUG2("DialService::dialVideo number:", number);
 
       
    74 	if (!hasCapability()) {
 
       
    75 		return KErrPermissionDenied;
 
       
    76     }
 
    68     QString phoneNumber = modifyPhoneNumber(number);
 
    77     QString phoneNumber = modifyPhoneNumber(number);
 
    69     TPtrC16 numberPtr(reinterpret_cast<const TUint16*>(phoneNumber.utf16()));
 
    78     TPtrC16 numberPtr(reinterpret_cast<const TUint16*>(phoneNumber.utf16()));
 
    70     m_parameters.SetPhoneNumber (numberPtr);
 
    79     m_parameters.SetPhoneNumber (numberPtr);
 
    71     m_parameters.SetCallTypeCommand (EPECallTypeVideo);
 
    80     m_parameters.SetCallTypeCommand (EPECallTypeVideo);
 
    72     m_call.HandleDialServiceCall ();
 
    81     return m_call.HandleDialServiceCall ();
 
    73 }
 
    82 }
 
    74 
    83 
    75 void DialService::dialVideo(const QString& number, int contactId)
 
    84 int DialService::dialVideo(const QString& number, int contactId)
 
    76 {
 
    85 {
 
    77     PHONE_DEBUG4("DialService::dialVideo number:", number, "contactId:", contactId);
 
    86     PHONE_DEBUG4("DialService::dialVideo number:", number, "contactId:", contactId);
 
       
    87     if (!hasCapability()) {
 
       
    88 		return KErrPermissionDenied;
 
       
    89     }
 
    78     QString phoneNumber = modifyPhoneNumber(number);
 
    90     QString phoneNumber = modifyPhoneNumber(number);
 
    79     TPtrC16 numberPtr (reinterpret_cast<const TUint16*>(phoneNumber.utf16()));
 
    91     TPtrC16 numberPtr (reinterpret_cast<const TUint16*>(phoneNumber.utf16()));
 
    80     m_parameters.SetPhoneNumber (numberPtr);
 
    92     m_parameters.SetPhoneNumber (numberPtr);
 
    81     m_parameters.SetCallTypeCommand (EPECallTypeVideo);
 
    93     m_parameters.SetCallTypeCommand (EPECallTypeVideo);
 
    82     m_parameters.SetContactId2 (contactId);
 
    94     m_parameters.SetContactId2 (contactId);
 
    83     m_call.HandleDialServiceCall ();    
    95     return m_call.HandleDialServiceCall ();
 
    84 }
 
    96 }
 
    85 
    97 
    86 void DialService::dialVoip(const QString& address)
 
    98 int DialService::dialVoip(const QString& address)
 
    87 {
 
    99 {
 
    88     PHONE_DEBUG2("DialService::dialVoip number:", address);
 
   100     PHONE_DEBUG2("DialService::dialVoip number:", address);
 
       
   101     if (!hasCapability()) {
 
       
   102 		return KErrPermissionDenied;
 
       
   103     }
 
    89     TPtrC16 numberPtr(reinterpret_cast<const TUint16*>(address.utf16 ()));
 
   104     TPtrC16 numberPtr(reinterpret_cast<const TUint16*>(address.utf16 ()));
 
    90     m_parameters.SetPhoneNumber(numberPtr);
 
   105     m_parameters.SetPhoneNumber(numberPtr);
 
    91     m_parameters.SetCallTypeCommand(EPECallTypeVoIP);
 
   106     m_parameters.SetCallTypeCommand(EPECallTypeVoIP);
 
    92     m_call.HandleDialServiceCall();    
   107     return m_call.HandleDialServiceCall();
 
    93 }
 
   108 }
 
    94 
   109 
    95 void DialService::dialVoip(const QString& address, int contactId)
 
   110 int DialService::dialVoip(const QString& address, int contactId)
 
    96 {
 
   111 {
 
    97     PHONE_DEBUG4("DialService::dialVoip number:", address, "contactId:", contactId);
 
   112     PHONE_DEBUG4("DialService::dialVoip number:", address, "contactId:", contactId);
 
       
   113     if (!hasCapability()) {
 
       
   114 		return KErrPermissionDenied;
 
       
   115     }
 
    98     TPtrC16 numberPtr (reinterpret_cast<const TUint16*>(address.utf16 ()));
 
   116     TPtrC16 numberPtr (reinterpret_cast<const TUint16*>(address.utf16 ()));
 
    99     m_parameters.SetPhoneNumber(numberPtr);
 
   117     m_parameters.SetPhoneNumber(numberPtr);
 
   100     m_parameters.SetCallTypeCommand(EPECallTypeVoIP);
 
   118     m_parameters.SetCallTypeCommand(EPECallTypeVoIP);
 
   101     m_parameters.SetContactId2(contactId);
 
   119     m_parameters.SetContactId2(contactId);
 
   102     m_call.HandleDialServiceCall();    
   120     return m_call.HandleDialServiceCall();
 
   103 }
 
   121 }
 
   104 
   122 
   105 void DialService::dialVoipService(const QString& address, int serviceId)
 
   123 int DialService::dialVoipService(const QString& address, int serviceId)
 
   106 {
 
   124 {
 
   107     PHONE_DEBUG4("DialService::dialVoipService number:", address, "serviceId:", serviceId);
 
   125     PHONE_DEBUG4("DialService::dialVoipService number:", address, "serviceId:", serviceId);
 
       
   126     if (!hasCapability()) {
 
       
   127 		return KErrPermissionDenied;
 
       
   128     }
 
   108     TPtrC16 numberPtr (reinterpret_cast<const TUint16*>(address.utf16 ()));
 
   129     TPtrC16 numberPtr (reinterpret_cast<const TUint16*>(address.utf16 ()));
 
   109     m_parameters.SetPhoneNumber(numberPtr);
 
   130     m_parameters.SetPhoneNumber(numberPtr);
 
   110     m_parameters.SetCallTypeCommand(EPECallTypeVoIP);
 
   131     m_parameters.SetCallTypeCommand(EPECallTypeVoIP);
 
   111     m_parameters.SetServiceIdCommand(serviceId);
 
   132     m_parameters.SetServiceIdCommand(serviceId);
 
   112     m_call.HandleDialServiceCall();    
   133     return m_call.HandleDialServiceCall();
 
   113 }
 
   134 }
 
   114 
   135 
   115 void DialService::dialVoipService(
 
   136 int DialService::dialVoipService(
 
   116         const QString& address, int serviceId, int contactId)
 
   137         const QString& address, int serviceId, int contactId)
 
   117 {
 
   138 {
 
   118     PHONE_DEBUG2("DialService::dialVoipService number:", address);
 
   139     PHONE_DEBUG2("DialService::dialVoipService number:", address);
 
   119     PHONE_DEBUG2("DialService::dialVoipService serviceId:", serviceId);
 
   140     PHONE_DEBUG2("DialService::dialVoipService serviceId:", serviceId);
 
   120     PHONE_DEBUG2("DialService::dialVoipService contactId:", contactId);
 
   141     PHONE_DEBUG2("DialService::dialVoipService contactId:", contactId);
 
       
   142     if (!hasCapability()) {
 
       
   143 		return KErrPermissionDenied;
 
       
   144     }
 
   121     TPtrC16 numberPtr (reinterpret_cast<const TUint16*>(address.utf16 ()));
 
   145     TPtrC16 numberPtr (reinterpret_cast<const TUint16*>(address.utf16 ()));
 
   122     m_parameters.SetPhoneNumber(numberPtr);
 
   146     m_parameters.SetPhoneNumber(numberPtr);
 
   123     m_parameters.SetCallTypeCommand(EPECallTypeVoIP);
 
   147     m_parameters.SetCallTypeCommand(EPECallTypeVoIP);
 
   124     m_parameters.SetServiceIdCommand(serviceId);
 
   148     m_parameters.SetServiceIdCommand(serviceId);
 
   125     m_parameters.SetContactId2(contactId);
 
   149     m_parameters.SetContactId2(contactId);
 
   126     m_call.HandleDialServiceCall();    
   150     return m_call.HandleDialServiceCall();
 
   127 }
 
   151 }
 
   128 
   152 
   129 QString DialService::modifyPhoneNumber(const QString &number)
 
   153 QString DialService::modifyPhoneNumber(const QString &number)
 
   130 {
 
   154 {
 
       
   155     PHONE_DEBUG2("DialService::modifyPhoneNumber number:", number);
 
   131     QString modifiedNumber = simplified(number);
 
   156     QString modifiedNumber = simplified(number);
 
   132     modifiedNumber = japanPrefixModifications(modifiedNumber);
 
   157     modifiedNumber = japanPrefixModifications(modifiedNumber);
 
   133 
   158 
   134     return modifiedNumber;
 
   159     return modifiedNumber;
 
   135 }
 
   160 }
 
   141     simplifiedNumber.remove(rx);
 
   166     simplifiedNumber.remove(rx);
 
   142     return simplifiedNumber;
 
   167     return simplifiedNumber;
 
   143 }
 
   168 }
 
   144 
   169 
   145 QString DialService::japanPrefixModifications(const QString &number)
 
   170 QString DialService::japanPrefixModifications(const QString &number)
 
   146 {    
   171 {
 
       
   172     PHONE_DEBUG2("DialService::japanPrefixModifications number:", number);
 
   147     bool checkPrefix = FeatureManager::FeatureSupported(KFeatureIdJapanPrefixChange);
 
   173     bool checkPrefix = FeatureManager::FeatureSupported(KFeatureIdJapanPrefixChange);
 
   148     if(checkPrefix == false) {
 
   174     if(checkPrefix == false) {
 
   149     	  // prefix change setting is off so don't play with the number
 
   175     	  // prefix change setting is off so don't play with the number
 
   150         return number;
 
   176         return number;
 
   151     }
 
   177     }
 
   152     
   178 
   153     QString modifiedNumber = number;
 
   179     QString modifiedNumber = number;
 
   154     
   180 
   155     int prefixMode = m_settingsManager->readItemValue(dialPrefixMode, XQSettingsManager::TypeInt).toInt();
 
   181     int prefixMode = m_settingsManager->readItemValue(dialPrefixMode, XQSettingsManager::TypeInt).toInt();
 
       
   182     PHONE_DEBUG2("DialService::japanPrefixModifications prefixMode:", prefixMode);
 
       
   183 
   156     if((m_settingsManager->error() == XQSettingsManager::NoError) && (prefixMode > 0)) {
 
   184     if((m_settingsManager->error() == XQSettingsManager::NoError) && (prefixMode > 0)) {
 
   157         // No error fetching value and setting is on
 
   185         // No error fetching value and setting is on
 
   158         QString prefixString = m_settingsManager->readItemValue(dialPrefixString, XQSettingsManager::TypeString).toString();
 
   186         QString prefixString = m_settingsManager->readItemValue(dialPrefixString, XQSettingsManager::TypeString).toString();
 
       
   187         PHONE_DEBUG2("DialService::japanPrefixModifications prefixString:", prefixString);
 
   159 
   188 
   160         if(m_settingsManager->error() == XQSettingsManager::NoError) {
 
   189         if(m_settingsManager->error() == XQSettingsManager::NoError) {
 
   161             if(modifiedNumber.startsWith("+")) {
 
   190             if(modifiedNumber.startsWith("+")) {
 
   162                 modifiedNumber = modifiedNumber.replace(0, prefixString.length(), prefixString);
 
   191                 modifiedNumber = modifiedNumber.remove(0, 1);
 
   163             }        	
   192                 modifiedNumber = modifiedNumber.insert(0, prefixString);
 
       
   193             }
 
   164         }
 
   194         }
 
   165     }
 
   195     }
 
   166                 	
   196 
       
   197     PHONE_DEBUG2("DialService::japanPrefixModifications modifiedNumber:", modifiedNumber);
 
   167     return modifiedNumber;
 
   198     return modifiedNumber;
 
   168 }
 
   199 }
 
       
   200 
       
   201 bool DialService::hasCapability()
 
       
   202 {
 
       
   203     XQRequestInfo req = requestInfo();
 
       
   204     QSet<int> caps = req.clientCapabilities();
 
       
   205 
       
   206     if (!caps.contains(ECapabilityNetworkServices)) {
 
       
   207         PHONE_TRACE1("NetworkServices capability missing");
 
       
   208         return false;
 
       
   209     }
 
       
   210     if (!caps.contains(ECapabilityNetworkControl)) {
 
       
   211         PHONE_TRACE1("NetworkControl capability missing");
 
       
   212         return false;
 
       
   213     }
 
       
   214 	return true;
 
       
   215 }
FCL/sf/app/phone