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 "psetwrapper.h"

    20 #include "psetcliwrapper.h"

    21 #include "psetcallwaitingwrapper.h"

    22 #include "psetcalldivertingwrapper.h"

    23 #include "psetnetworkwrapper.h"

    24 #include "psetcallbarringwrapper.h"

    25 #include "logging.h"

    26 

    27 

    28 PSetWrapper::PSetWrapper(QObject *parent):

    29         QObject(parent),

    30         m_wrapperCli(NULL),

    31         m_callWaitingWrapper(NULL),

    32         m_callDivertingWrapper(NULL),

    33         m_networkWrapper(NULL)

    34 {

    35     DPRINT << "DUMMY WRAPPER";

    36 }

    37 

    38 PSetWrapper::~PSetWrapper()

    39 {

    40     DPRINT << "DUMMY WRAPPER";

    41 

    42     delete m_wrapperCli;

    43     delete m_callWaitingWrapper;

    44     delete m_callDivertingWrapper;

    45     delete m_networkWrapper;

    46 

    47 }

    48 

    49 PSetCliWrapper& PSetWrapper::cliWrapper()

    50 {

    51     DPRINT << "DUMMY WRAPPER";

    52     

    53     if( !m_wrapperCli ){

    54         m_wrapperCli = new PSetCliWrapper(*m_psetContainer, this);

    55     }

    56 

    57     return *m_wrapperCli;

    58 }

    59 

    60 

    61 PSetCallWaitingWrapper& PSetWrapper::callWaitingWrapper()

    62 {

    63     DPRINT << "DUMMY WRAPPER";

    64         

    65     if( !m_callWaitingWrapper ){

    66         m_callWaitingWrapper = new PSetCallWaitingWrapper(*m_psetContainer, this);

    67     }

    68 

    69     return *m_callWaitingWrapper;

    70 }

    71 

    72 

    73 PSetCallDivertingWrapper& PSetWrapper::callDivertingWrapper()

    74 {

    75     DPRINT << "DUMMY WRAPPER";

    76     

    77     if( !m_callWaitingWrapper ){

    78         m_callDivertingWrapper = new PSetCallDivertingWrapper(*m_psetContainer, this);

    79     }

    80 

    81     return *m_callDivertingWrapper;

    82 }

    83 

    84 PSetNetworkWrapper& PSetWrapper::networkWrapper()

    85 {

    86     DPRINT << "DUMMY WRAPPER";

    87     

    88     if (!m_networkWrapper) {

    89         m_networkWrapper = new PSetNetworkWrapper(*m_psetContainer, this);

    90     }

    91 

    92     return *m_networkWrapper;

    93 }

    94 

    95 class PSetCliWrapperPrivate {

    96     PSetCliWrapperPrivate(){}

    97 };

    98 

    99 PSetCliWrapper::PSetCliWrapper( CPsetContainer &psetContainer,

   100         QObject *parent):

   101     QObject(parent), m_privateImpl(NULL)

   102 {

   103     DPRINT << "DUMMY WRAPPER";

   104 }

   105 

   106 PSetCliWrapper::~PSetCliWrapper()

   107 {

   108     DPRINT << "DUMMY WRAPPER";

   109 }

   110 

   111 // --------  Wrapper interface  --------- //

   112 void PSetCliWrapper::getColpMode()

   113 {

   114     DPRINT << "DUMMY WRAPPER";

   115 }

   116 

   117 void PSetCliWrapper::getClipMode()

   118 {

   119     DPRINT << "DUMMY WRAPPER";

   120 }

   121 

   122 void PSetCliWrapper::getClirMode()

   123 {

   124     DPRINT << "DUMMY WRAPPER";

   125 }

   126 

   127 void PSetCliWrapper::getColrMode()

   128 {

   129     DPRINT << "DUMMY WRAPPER";

   130 }

   131 

   132 void PSetCliWrapper::getCnap()

   133 {

   134     DPRINT << "DUMMY WRAPPER";

   135 }

   136 

   137 void PSetCliWrapper::cancelAll()

   138 {

   139     DPRINT << "DUMMY WRAPPER";

   140 }

   141 

   142 class PSetCallWaitingWrapperPrivate {

   143     PSetCallWaitingWrapperPrivate(){}

   144 };

   145 

   146 PSetCallWaitingWrapper::PSetCallWaitingWrapper(

   147         CPsetContainer &psetContainer,

   148         QObject *parent) : QObject(parent), m_privateImpl(NULL)

   149 {

   150     DPRINT << "DUMMY WRAPPER";

   151 }

   152 

   153 PSetCallWaitingWrapper::~PSetCallWaitingWrapper()

   154 {

   155     DPRINT << "DUMMY WRAPPER";

   156 }

   157 

   158 // --------  Wrapper interface  --------- //

   159 void PSetCallWaitingWrapper::setCallWaiting( PsCallWaitingCommand aSetting,

   160                                             int aBasicServiceGroup )

   161 {

   162     DPRINT << "DUMMY WRAPPER";

   163 }

   164 

   165 void PSetCallWaitingWrapper::getCallWaitingStatus()

   166 {

   167     DPRINT << "DUMMY WRAPPER";

   168 }

   169 

   170 void PSetCallWaitingWrapper::cancelProcess()

   171 {

   172     DPRINT << "DUMMY WRAPPER";

   173 }

   174 

   175 PSetCallDivertingWrapper::PSetCallDivertingWrapper(

   176         CPsetContainer &psetContainer, QObject *parent) :

   177     QObject(parent), m_DefaultNumberListCDes(NULL)

   178 {

   179     DPRINT << "DUMMY WRAPPER";

   180 }

   181 

   182 PSetCallDivertingWrapper::~PSetCallDivertingWrapper()

   183 {

   184     DPRINT << "DUMMY WRAPPER";

   185 }

   186 

   187 // --------  Wrapper interface  --------- //

   188 

   189 int PSetCallDivertingWrapper::setCallDiverting(

   190         PSCallDivertingCommand& aSetting, int aBasicServiceGroup)

   191 {

   192     DPRINT << "DUMMY WRAPPER";

   193     return 0;

   194 }

   195 

   196 void PSetCallDivertingWrapper::getCallDivertingStatus(

   197         const PsServiceGroup aServiceGroup, const PsCallDivertingCondition aCondition,

   198         int aBsc)

   199 {

   200     DPRINT << "DUMMY WRAPPER";

   201 }

   202 

   203 void PSetCallDivertingWrapper::cancelProcess()

   204 {

   205     DPRINT << "DUMMY WRAPPER";

   206 }

   207 

   208 void PSetCallDivertingWrapper::getDefaultNumbers(QStringList &aDefNumbers)

   209 {

   210     DPRINT << "DUMMY WRAPPER";

   211     aDefNumbers = m_DefaultnumberListQSList;

   212 }

   213 

   214 void PSetCallDivertingWrapper::setNewDefaultNumber(QString aNumber)

   215 {

   216     DPRINT << "DUMMY WRAPPER";

   217     m_DefaultnumberListQSList.append(aNumber);

   218 }

   219 

   220 void PSetCallDivertingWrapper::getVoiceMailBoxNumber(QString &/*aVmbxNumber*/)

   221 {

   222     DPRINT << "DUMMY WRAPPER";

   223 }

   224 

   225 PSetNetworkWrapper::PSetNetworkWrapper(

   226     CPsetContainer &psetContainer, QObject *parent)

   227     : QObject(parent)

   228 {

   229     DPRINT << "DUMMY WRAPPER";

   230 }

   231 

   232 PSetNetworkWrapper::~PSetNetworkWrapper()

   233 {

   234     DPRINT << "DUMMY WRAPPER";

   235 }

   236 

   237 void PSetNetworkWrapper::getNetworkAccessMode() const

   238 {

   239     DPRINT << "DUMMY WRAPPER";

   240 }

   241 

   242 void PSetNetworkWrapper::setNetworkAccessMode(

   243     PSetNetworkWrapper::NetworkAccessMode mode)

   244 {

   245     DPRINT << "DUMMY WRAPPER";

   246 }

   247 

   248 void PSetNetworkWrapper::getAvailableNetworks()

   249 {

   250     DPRINT << "DUMMY WRAPPER";

   251 }

   252 

   253 PSetNetworkWrapper::ErrorCode PSetNetworkWrapper::getNetworkSelectionMode(

   254     PSetNetworkWrapper::NetworkSelectionMode& mode) const

   255 {

   256     DPRINT << "DUMMY WRAPPER";

   257 }

   258 

   259 void PSetNetworkWrapper::selectNetwork(

   260     const PSetNetworkWrapper::NetworkInfo& info)

   261 {

   262     DPRINT << "DUMMY WRAPPER";

   263 }

   264 

   265 void PSetNetworkWrapper::cancelRequest()

   266 {

   267     DPRINT << "DUMMY WRAPPER";

   268 }

   269 

   270 class PSetCallBarringWrapperPrivate {

   271 public:

   272     PSetCallBarringWrapperPrivate() {}

   273     ~PSetCallBarringWrapperPrivate() {}

   274 };

   275 

   276 PSetCallBarringWrapper::PSetCallBarringWrapper(

   277     CPsetContainer &psetContainer,

   278     QObject *parent)

   279     :

   280     QObject(parent)

   281 {

   282     DPRINT << "DUMMY PSetCallBarringWrapper";

   283 }

   284 

   285 

   286 PSetCallBarringWrapper::~PSetCallBarringWrapper()

   287 {

   288     DPRINT << "DUMMY PSetCallBarringWrapper";

   289 }

   290 

   291 

   292 // End of File.