Mercurial Mercurial > oss > FCL > sf > mw > mmmw / 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.
mmserv/tms/tmscallserver/src/callcsadpt.cpp
changeset 12 5a06f39ad45b
parent 0 71ca22bcf22a
equal deleted inserted replaced
0:71ca22bcf22a 12:5a06f39ad45b 
    24 #include "callcsadpt.h"
 
    24 #include "callcsadpt.h"
 
    25 #include "tmsutility.h"
 
    25 #include "tmsutility.h"
 
    26 #include "tmsshared.h"
 
    26 #include "tmsshared.h"
 
    27 #include "tmsclientserver.h"
 
    27 #include "tmsclientserver.h"
 
    28 #include "tarsettings.h"
 
    28 #include "tarsettings.h"
 
       
    29 #include "cpeaudiodtmftoneplayer.h"
 
       
    30 #include "cspdtmfprovider.h"
 
       
    31 #include "dtmfnotifier.h"
 
    29 
    32 
    30 using namespace TMS;
 
    33 using namespace TMS;
 
    31 
    34 
    32 // -----------------------------------------------------------------------------
 
    35 // -----------------------------------------------------------------------------
 
    33 // CallCSAdpt::CallCSAdpt
 
    36 // TMSCallCSAdpt::TMSCallCSAdpt
 
    34 //
 
    37 //
 
    35 // -----------------------------------------------------------------------------
 
    38 // -----------------------------------------------------------------------------
 
    36 //
 
    39 //
 
    37 CallCSAdpt::CallCSAdpt()
 
    40 TMSCallCSAdpt::TMSCallCSAdpt()
 
    38     {
 
    41     {
 
    39     TRACE_PRN_FN_ENT;
 
    42     TRACE_PRN_FN_ENT;
 
    40 
    43 
    41     iCSDownlink = NULL;
 
    44     iCSDownlink = NULL;
 
    42     iCSUplink = NULL;
 
    45     iCSUplink = NULL;
 
    43     iRouting = NULL;
 
    46     iRouting = NULL;
 
    44 
    47     iDTMFDnlinkPlayer = NULL;
 
    45     TRACE_PRN_FN_EXT;
 
    48     iDTMFUplinkPlayer = NULL;
 
    46     }
 
    49     iDTMFNotifier = NULL;
 
    47 
    50 
    48 // -----------------------------------------------------------------------------
 
    51     TRACE_PRN_FN_EXT;
 
    49 // CallCSAdpt::~CallCSAdpt
 
    52     }
 
    50 //
 
    53 
    51 // -----------------------------------------------------------------------------
 
    54 // -----------------------------------------------------------------------------
 
    52 //
 
    55 // TMSCallCSAdpt::~TMSCallCSAdpt
 
    53 CallCSAdpt::~CallCSAdpt()
 
    56 //
 
       
    57 // -----------------------------------------------------------------------------
 
       
    58 //
 
       
    59 TMSCallCSAdpt::~TMSCallCSAdpt()
 
    54     {
 
    60     {
 
    55     TRACE_PRN_FN_ENT;
 
    61     TRACE_PRN_FN_ENT;
 
    56     delete iCSDownlink;
 
    62     delete iCSDownlink;
 
    57     delete iCSUplink;
 
    63     delete iCSUplink;
 
    58     delete iRouting;
 
    64     delete iRouting;
 
    59     delete iTarSettings;
 
    65     delete iTarSettings;
 
       
    66     delete iDTMFDnlinkPlayer;
 
       
    67     delete iDTMFUplinkPlayer;
 
       
    68     delete iDTMFNotifier;
 
    60 
    69 
    61     if (iMsgQueueUp.Handle() > 0)
 
    70     if (iMsgQueueUp.Handle() > 0)
 
    62         {
 
    71         {
 
    63         iMsgQueueUp.Close();
 
    72         iMsgQueueUp.Close();
 
    64         }
 
    73         }
 
    70 
    79 
    71     TRACE_PRN_FN_EXT;
 
    80     TRACE_PRN_FN_EXT;
 
    72     }
 
    81     }
 
    73 
    82 
    74 // -----------------------------------------------------------------------------
 
    83 // -----------------------------------------------------------------------------
 
    75 // CallCSAdpt::PostConstruct
 
    84 // TMSCallCSAdpt::PostConstruct
 
    76 //
 
    85 //
 
    77 // -----------------------------------------------------------------------------
 
    86 // -----------------------------------------------------------------------------
 
    78 //
 
    87 //
 
    79 gint CallCSAdpt::PostConstruct()
 
    88 gint TMSCallCSAdpt::PostConstruct()
 
    80     {
 
    89     {
 
    81     TRACE_PRN_FN_ENT;
 
    90     TRACE_PRN_FN_ENT;
 
    82     gint status(TMS_RESULT_SUCCESS);
 
    91     gint status(TMS_RESULT_SUCCESS);
 
    83     iNextStreamId = 1;
 
    92     iNextStreamId = 1;
 
    84     iUplinkInitialized = FALSE;
 
    93     iUplinkInitialized = FALSE;
 
    87     TRACE_PRN_FN_EXT;
 
    96     TRACE_PRN_FN_EXT;
 
    88     return status;
 
    97     return status;
 
    89     }
 
    98     }
 
    90 
    99 
    91 // -----------------------------------------------------------------------------
 
   100 // -----------------------------------------------------------------------------
 
    92 // CallCSAdpt::CreateStream
 
   101 // TMSCallCSAdpt::CreateStream
 
    93 //
 
   102 //
 
    94 // -----------------------------------------------------------------------------
 
   103 // -----------------------------------------------------------------------------
 
    95 //
 
   104 //
 
    96 gint CallCSAdpt::CreateStream(TMSCallType /*callType*/,
 
   105 gint TMSCallCSAdpt::CreateStream(TMSCallType /*callType*/,
 
    97         TMSStreamType strmType, gint& outStrmId)
 
   106         TMSStreamType strmType, gint& outStrmId)
 
    98     {
 
   107     {
 
    99     TRACE_PRN_FN_ENT;
 
   108     TRACE_PRN_FN_ENT;
 
   100     gint status(TMS_RESULT_SUCCESS);
 
   109     gint status(TMS_RESULT_SUCCESS);
 
   101     switch (strmType)
 
   110     switch (strmType)
 
   131     TRACE_PRN_FN_EXT;
 
   140     TRACE_PRN_FN_EXT;
 
   132     return status;
 
   141     return status;
 
   133     }
 
   142     }
 
   134 
   143 
   135 // -----------------------------------------------------------------------------
 
   144 // -----------------------------------------------------------------------------
 
   136 // CallCSAdpt::InitStream
 
   145 // TMSCallCSAdpt::InitStream
 
   137 //
 
   146 //
 
   138 // -----------------------------------------------------------------------------
 
   147 // -----------------------------------------------------------------------------
 
   139 //
 
   148 //
 
   140 gint CallCSAdpt::InitStreamL(TMSCallType /*callType*/,
 
   149 gint TMSCallCSAdpt::InitStreamL(TMSCallType /*callType*/,
 
   141         TMSStreamType strmType, gint strmId, TMSFormatType /*frmtType*/,
 
   150         TMSStreamType strmType, gint strmId, TMSFormatType /*frmtType*/,
 
   142         const RMessage2& aMessage)
 
   151         const RMessage2& aMessage)
 
   143     {
 
   152     {
 
   144     TRACE_PRN_FN_ENT;
 
   153     TRACE_PRN_FN_ENT;
 
   145     gint status(TMS_RESULT_SUCCESS);
 
   154     gint status(TMS_RESULT_SUCCESS);
 
   155                     // Third argument in TMSCallProxy::InitStream
 
   164                     // Third argument in TMSCallProxy::InitStream
 
   156                     status = iMsgQueueUp.Open(aMessage, 1);
 
   165                     status = iMsgQueueUp.Open(aMessage, 1);
 
   157                     }
 
   166                     }
 
   158                 if (status == TMS_RESULT_SUCCESS)
 
   167                 if (status == TMS_RESULT_SUCCESS)
 
   159                     {
 
   168                     {
 
   160                     TRAP(status, iCSUplink = CSUplink::NewL(*this));
 
   169                     TRAP(status, iCSUplink = TMSCSUplink::NewL(*this));
 
       
   170 
       
   171                     if (status == TMS_RESULT_SUCCESS)
 
       
   172                         {
 
       
   173                         iDTMFUplinkPlayer =  TMSDTMFProvider::NewL();
 
       
   174                         iDTMFUplinkPlayer->AddObserverL(*this);
 
       
   175                         if(!iDTMFNotifier)
 
       
   176                             {
 
       
   177                             iDTMFNotifier = TMSDtmfNotifier::NewL();
 
       
   178                             }
 
       
   179                         }
 
   161                     }
 
   180                     }
 
   162                 iStrmtype = TMS_STREAM_UPLINK;
 
   181                 iStrmtype = TMS_STREAM_UPLINK;
 
   163                 }
 
   182                 }
 
   164             else
 
   183             else
 
   165                 {
 
   184                 {
 
   175                     // Third argument in TMSCallProxy::InitStream
 
   194                     // Third argument in TMSCallProxy::InitStream
 
   176                     status = iMsgQueueDn.Open(aMessage, 1);
 
   195                     status = iMsgQueueDn.Open(aMessage, 1);
 
   177                     }
 
   196                     }
 
   178                 if (status == TMS_RESULT_SUCCESS)
 
   197                 if (status == TMS_RESULT_SUCCESS)
 
   179                     {
 
   198                     {
 
   180                     TRAP(status, iCSDownlink = CSDownlink::NewL(*this));
 
   199                     TRAP(status, iCSDownlink = TMSCSDownlink::NewL(*this));
 
   181                     if (status == TMS_RESULT_SUCCESS)
 
   200                     if (status == TMS_RESULT_SUCCESS)
 
   182                         {
 
   201                         {
 
   183                         TRAP(status, iRouting =
 
   202                         TRAP(status, iRouting =
 
   184                              CTelephonyAudioRouting::NewL(*this));
 
   203                              CTelephonyAudioRouting::NewL(*this));
 
   185                         if (status == TMS_RESULT_SUCCESS)
 
   204                         if (status == TMS_RESULT_SUCCESS)
 
   186                             {
 
   205                             {
 
   187                             iTarSettings = TarSettings::NewL();
 
   206                             iTarSettings = TMSTarSettings::NewL();
 
       
   207                             }
 
       
   208                         if (status == TMS_RESULT_SUCCESS)
 
       
   209                             {
 
       
   210                             TRAP(status, iDTMFDnlinkPlayer =
 
       
   211                                  TMSAudioDtmfTonePlayer::NewL(*this,
 
       
   212                                  KAudioPrefKeyDownDTMF,
 
       
   213                                  KAudioPriorityDtmfKeyPress));
 
       
   214                             if(!iDTMFNotifier)
 
       
   215                                 {
 
       
   216                                 iDTMFNotifier = TMSDtmfNotifier::NewL();
 
       
   217                                 }
 
   188                             }
 
   218                             }
 
   189                         }
 
   219                         }
 
   190                     }
 
   220                     }
 
   191                 iStrmtype = TMS_STREAM_DOWNLINK;
 
   221                 iStrmtype = TMS_STREAM_DOWNLINK;
 
   192                 }
 
   222                 }
 
   204     TRACE_PRN_FN_EXT;
 
   234     TRACE_PRN_FN_EXT;
 
   205     return status;
 
   235     return status;
 
   206     }
 
   236     }
 
   207 
   237 
   208 // -----------------------------------------------------------------------------
 
   238 // -----------------------------------------------------------------------------
 
   209 // CallCSAdpt::StartStream
 
   239 // TMSCallCSAdpt::StartStream
 
   210 //
 
   240 //
 
   211 // -----------------------------------------------------------------------------
 
   241 // -----------------------------------------------------------------------------
 
   212 //
 
   242 //
 
   213 gint CallCSAdpt::StartStream(TMSCallType /*callType*/,
 
   243 gint TMSCallCSAdpt::StartStream(TMSCallType /*callType*/,
 
   214         TMSStreamType strmType, gint strmId)
 
   244         TMSStreamType strmType, gint strmId)
 
   215     {
 
   245     {
 
   216     TRACE_PRN_FN_ENT;
 
   246     TRACE_PRN_FN_ENT;
 
   217     gint status(TMS_RESULT_SUCCESS);
 
   247     gint status(TMS_RESULT_SUCCESS);
 
   218     switch (strmType)
 
   248     switch (strmType)
 
   236     TRACE_PRN_FN_EXT;
 
   266     TRACE_PRN_FN_EXT;
 
   237     return status;
 
   267     return status;
 
   238     }
 
   268     }
 
   239 
   269 
   240 // -----------------------------------------------------------------------------
 
   270 // -----------------------------------------------------------------------------
 
   241 // CallCSAdpt::PauseStream
 
   271 // TMSCallCSAdpt::PauseStream
 
   242 //
 
   272 //
 
   243 // -----------------------------------------------------------------------------
 
   273 // -----------------------------------------------------------------------------
 
   244 //
 
   274 //
 
   245 gint CallCSAdpt::PauseStream(TMSCallType /*callType*/,
 
   275 gint TMSCallCSAdpt::PauseStream(TMSCallType /*callType*/,
 
   246         TMSStreamType /*strmType*/, gint /*strmId*/)
 
   276         TMSStreamType /*strmType*/, gint /*strmId*/)
 
   247     {
 
   277     {
 
   248     TRACE_PRN_FN_ENT;
 
   278     TRACE_PRN_FN_ENT;
 
   249     gint status(TMS_RESULT_SUCCESS);
 
   279     gint status(TMS_RESULT_SUCCESS);
 
   250     TRACE_PRN_FN_EXT;
 
   280     TRACE_PRN_FN_EXT;
 
   251     return status;
 
   281     return status;
 
   252     }
 
   282     }
 
   253 
   283 
   254 // -----------------------------------------------------------------------------
 
   284 // -----------------------------------------------------------------------------
 
   255 // CallCSAdpt::StopStream
 
   285 // TMSCallCSAdpt::StopStream
 
   256 //
 
   286 //
 
   257 // -----------------------------------------------------------------------------
 
   287 // -----------------------------------------------------------------------------
 
   258 //
 
   288 //
 
   259 gint CallCSAdpt::StopStream(TMSCallType /*callType*/, TMSStreamType strmType,
 
   289 gint TMSCallCSAdpt::StopStream(TMSCallType /*callType*/, TMSStreamType strmType,
 
   260         gint strmId)
 
   290         gint strmId)
 
   261     {
 
   291     {
 
   262     TRACE_PRN_FN_ENT;
 
   292     TRACE_PRN_FN_ENT;
 
   263     gint status(TMS_RESULT_SUCCESS);
 
   293     gint status(TMS_RESULT_SUCCESS);
 
   264     switch (strmType)
 
   294     switch (strmType)
 
   286     TRACE_PRN_FN_EXT;
 
   316     TRACE_PRN_FN_EXT;
 
   287     return status;
 
   317     return status;
 
   288     }
 
   318     }
 
   289 
   319 
   290 // -----------------------------------------------------------------------------
 
   320 // -----------------------------------------------------------------------------
 
   291 // CallCSAdpt::DeinitStream
 
   321 // TMSCallCSAdpt::DeinitStream
 
   292 //
 
   322 //
 
   293 // -----------------------------------------------------------------------------
 
   323 // -----------------------------------------------------------------------------
 
   294 //
 
   324 //
 
   295 gint CallCSAdpt::DeinitStream(TMSCallType /*callType*/,
 
   325 gint TMSCallCSAdpt::DeinitStream(TMSCallType /*callType*/,
 
   296         TMSStreamType strmType, gint strmId)
 
   326         TMSStreamType strmType, gint strmId)
 
   297     {
 
   327     {
 
   298     TRACE_PRN_FN_ENT;
 
   328     TRACE_PRN_FN_ENT;
 
   299     gint status(TMS_RESULT_SUCCESS);
 
   329     gint status(TMS_RESULT_SUCCESS);
 
   300     switch (strmType)
 
   330     switch (strmType)
 
   324     TRACE_PRN_FN_EXT;
 
   354     TRACE_PRN_FN_EXT;
 
   325     return status;
 
   355     return status;
 
   326     }
 
   356     }
 
   327 
   357 
   328 // -----------------------------------------------------------------------------
 
   358 // -----------------------------------------------------------------------------
 
   329 // CallCSAdpt::DeleteStream
 
   359 // TMSCallCSAdpt::DeleteStream
 
   330 //
 
   360 //
 
   331 // -----------------------------------------------------------------------------
 
   361 // -----------------------------------------------------------------------------
 
   332 //
 
   362 //
 
   333 gint CallCSAdpt::DeleteStream(TMSCallType /*callType*/,
 
   363 gint TMSCallCSAdpt::DeleteStream(TMSCallType /*callType*/,
 
   334         TMSStreamType strmType, gint strmId)
 
   364         TMSStreamType strmType, gint strmId)
 
   335     {
 
   365     {
 
   336     TRACE_PRN_FN_ENT;
 
   366     TRACE_PRN_FN_ENT;
 
   337     gint status(TMS_RESULT_SUCCESS);
 
   367     gint status(TMS_RESULT_SUCCESS);
 
   338     switch (strmType)
 
   368     switch (strmType)
 
   358     TRACE_PRN_FN_EXT;
 
   388     TRACE_PRN_FN_EXT;
 
   359     return status;
 
   389     return status;
 
   360     }
 
   390     }
 
   361 
   391 
   362 // -----------------------------------------------------------------------------
 
   392 // -----------------------------------------------------------------------------
 
   363 // CallCSAdpt::DataXferBufferEmptied
 
   393 // TMSCallCSAdpt::DataXferBufferEmptied
 
   364 //
 
   394 //
 
   365 // -----------------------------------------------------------------------------
 
   395 // -----------------------------------------------------------------------------
 
   366 //
 
   396 //
 
   367 gint CallCSAdpt::DataXferBufferEmptied(TMSCallType /*callType*/,
 
   397 gint TMSCallCSAdpt::DataXferBufferEmptied(TMSCallType /*callType*/,
 
   368         TMSStreamType /*strmType*/, gint /*strmId*/)
 
   398         TMSStreamType /*strmType*/, gint /*strmId*/)
 
   369     {
 
   399     {
 
   370     TRACE_PRN_FN_ENT;
 
   400     TRACE_PRN_FN_ENT;
 
   371     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   401     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   372     TRACE_PRN_FN_EXT;
 
   402     TRACE_PRN_FN_EXT;
 
   373     return status;
 
   403     return status;
 
   374     }
 
   404     }
 
   375 
   405 
   376 // -----------------------------------------------------------------------------
 
   406 // -----------------------------------------------------------------------------
 
   377 // CallCSAdpt::DataXferBufferFilled
 
   407 // TMSCallCSAdpt::DataXferBufferFilled
 
   378 //
 
   408 //
 
   379 // -----------------------------------------------------------------------------
 
   409 // -----------------------------------------------------------------------------
 
   380 //
 
   410 //
 
   381 gint CallCSAdpt::DataXferBufferFilled(TMSCallType /*callType*/,
 
   411 gint TMSCallCSAdpt::DataXferBufferFilled(TMSCallType /*callType*/,
 
   382         TMSStreamType /*strmType*/, gint /*strmId*/, guint /*datasize*/)
 
   412         TMSStreamType /*strmType*/, gint /*strmId*/, guint /*datasize*/)
 
   383     {
 
   413     {
 
   384     TRACE_PRN_FN_ENT;
 
   414     TRACE_PRN_FN_ENT;
 
   385     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   415     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   386     TRACE_PRN_FN_EXT;
 
   416     TRACE_PRN_FN_EXT;
 
   387     return status;
 
   417     return status;
 
   388     }
 
   418     }
 
   389 
   419 
   390 // -----------------------------------------------------------------------------
 
   420 // -----------------------------------------------------------------------------
 
   391 // CallCSAdpt::GetDataXferBufferHndl
 
   421 // TMSCallCSAdpt::GetDataXferBufferHndl
 
   392 //
 
   422 //
 
   393 // -----------------------------------------------------------------------------
 
   423 // -----------------------------------------------------------------------------
 
   394 //
 
   424 //
 
   395 gint CallCSAdpt::GetDataXferBufferHndl(const TMSCallType /*callType*/,
 
   425 gint TMSCallCSAdpt::GetDataXferBufferHndl(const TMSCallType /*callType*/,
 
   396         const TMSStreamType /*strmType*/, const gint /*strmId*/,
 
   426         const TMSStreamType /*strmType*/, const gint /*strmId*/,
 
   397         const guint32 /*key*/, RChunk& /*chunk*/)
 
   427         const guint32 /*key*/, RChunk& /*chunk*/)
 
   398     {
 
   428     {
 
   399     TRACE_PRN_FN_ENT;
 
   429     TRACE_PRN_FN_ENT;
 
   400     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   430     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   401     TRACE_PRN_FN_EXT;
 
   431     TRACE_PRN_FN_EXT;
 
   402     return status;
 
   432     return status;
 
   403     }
 
   433     }
 
   404 
   434 
   405 // -----------------------------------------------------------------------------
 
   435 // -----------------------------------------------------------------------------
 
   406 // CallCSAdpt::GetMaxVolume
 
   436 // TMSCallCSAdpt::GetMaxVolume
 
   407 //
 
   437 //
 
   408 // -----------------------------------------------------------------------------
 
   438 // -----------------------------------------------------------------------------
 
   409 //
 
   439 //
 
   410 gint CallCSAdpt::GetMaxVolume(guint& volume)
 
   440 gint TMSCallCSAdpt::GetMaxVolume(guint& volume)
 
   411     {
 
   441     {
 
   412     TRACE_PRN_FN_ENT;
 
   442     TRACE_PRN_FN_ENT;
 
   413     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   443     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   414     if (iCSDownlink && iDnlinkInitialized)
 
   444     if (iCSDownlink && iDnlinkInitialized)
 
   415         {
 
   445         {
 
   419     TRACE_PRN_FN_EXT;
 
   449     TRACE_PRN_FN_EXT;
 
   420     return status;
 
   450     return status;
 
   421     }
 
   451     }
 
   422 
   452 
   423 // -----------------------------------------------------------------------------
 
   453 // -----------------------------------------------------------------------------
 
   424 // CallCSAdpt::SetVolume
 
   454 // TMSCallCSAdpt::SetVolume
 
   425 //
 
   455 //
 
   426 // -----------------------------------------------------------------------------
 
   456 // -----------------------------------------------------------------------------
 
   427 //
 
   457 //
 
   428 gint CallCSAdpt::SetVolume(const guint volume)
 
   458 gint TMSCallCSAdpt::SetVolume(const guint volume)
 
   429     {
 
   459     {
 
   430     TRACE_PRN_FN_ENT;
 
   460     TRACE_PRN_FN_ENT;
 
   431     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   461     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   432     if (iCSDownlink && iDnlinkInitialized)
 
   462     if (iCSDownlink && iDnlinkInitialized)
 
   433         {
 
   463         {
 
   438     TRACE_PRN_FN_EXT;
 
   468     TRACE_PRN_FN_EXT;
 
   439     return status;
 
   469     return status;
 
   440     }
 
   470     }
 
   441 
   471 
   442 // -----------------------------------------------------------------------------
 
   472 // -----------------------------------------------------------------------------
 
   443 // CallCSAdpt::GetVolume
 
   473 // TMSCallCSAdpt::GetVolume
 
   444 //
 
   474 //
 
   445 // -----------------------------------------------------------------------------
 
   475 // -----------------------------------------------------------------------------
 
   446 //
 
   476 //
 
   447 gint CallCSAdpt::GetVolume(guint& volume)
 
   477 gint TMSCallCSAdpt::GetVolume(guint& volume)
 
   448     {
 
   478     {
 
   449     TRACE_PRN_FN_ENT;
 
   479     TRACE_PRN_FN_ENT;
 
   450     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   480     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   451     if (iCSDownlink && iDnlinkInitialized)
 
   481     if (iCSDownlink && iDnlinkInitialized)
 
   452         {
 
   482         {
 
   457     TRACE_PRN_FN_EXT;
 
   487     TRACE_PRN_FN_EXT;
 
   458     return status;
 
   488     return status;
 
   459     }
 
   489     }
 
   460 
   490 
   461 // -----------------------------------------------------------------------------
 
   491 // -----------------------------------------------------------------------------
 
   462 // CallCSAdpt::GetMaxGain
 
   492 // TMSCallCSAdpt::GetMaxGain
 
   463 //
 
   493 //
 
   464 // -----------------------------------------------------------------------------
 
   494 // -----------------------------------------------------------------------------
 
   465 //
 
   495 //
 
   466 gint CallCSAdpt::GetMaxGain(guint& gain)
 
   496 gint TMSCallCSAdpt::GetMaxGain(guint& gain)
 
   467     {
 
   497     {
 
   468     TRACE_PRN_FN_ENT;
 
   498     TRACE_PRN_FN_ENT;
 
   469     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   499     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   470     if (iCSUplink && iUplinkInitialized)
 
   500     if (iCSUplink && iUplinkInitialized)
 
   471         {
 
   501         {
 
   475     TRACE_PRN_FN_EXT;
 
   505     TRACE_PRN_FN_EXT;
 
   476     return status;
 
   506     return status;
 
   477     }
 
   507     }
 
   478 
   508 
   479 // -----------------------------------------------------------------------------
 
   509 // -----------------------------------------------------------------------------
 
   480 // CallCSAdpt::SetGain
 
   510 // TMSCallCSAdpt::SetGain
 
   481 //
 
   511 //
 
   482 // -----------------------------------------------------------------------------
 
   512 // -----------------------------------------------------------------------------
 
   483 //
 
   513 //
 
   484 gint CallCSAdpt::SetGain(const guint gain)
 
   514 gint TMSCallCSAdpt::SetGain(const guint gain)
 
   485     {
 
   515     {
 
   486     TRACE_PRN_FN_ENT;
 
   516     TRACE_PRN_FN_ENT;
 
   487     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   517     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   488     if (iUplinkInitialized)
 
   518     if (iUplinkInitialized)
 
   489         {
 
   519         {
 
   494     TRACE_PRN_FN_EXT;
 
   524     TRACE_PRN_FN_EXT;
 
   495     return status;
 
   525     return status;
 
   496     }
 
   526     }
 
   497 
   527 
   498 // -----------------------------------------------------------------------------
 
   528 // -----------------------------------------------------------------------------
 
   499 // CallCSAdpt::GetGain
 
   529 // TMSCallCSAdpt::GetGain
 
   500 //
 
   530 //
 
   501 // -----------------------------------------------------------------------------
 
   531 // -----------------------------------------------------------------------------
 
   502 //
 
   532 //
 
   503 gint CallCSAdpt::GetGain(guint& gain)
 
   533 gint TMSCallCSAdpt::GetGain(guint& gain)
 
   504     {
 
   534     {
 
   505     TRACE_PRN_FN_ENT;
 
   535     TRACE_PRN_FN_ENT;
 
   506     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   536     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   507     if (iCSUplink && iUplinkInitialized)
 
   537     if (iCSUplink && iUplinkInitialized)
 
   508         {
 
   538         {
 
   512     TRACE_PRN_FN_EXT;
 
   542     TRACE_PRN_FN_EXT;
 
   513     return status;
 
   543     return status;
 
   514     }
 
   544     }
 
   515 
   545 
   516 // -----------------------------------------------------------------------------
 
   546 // -----------------------------------------------------------------------------
 
   517 // CallCSAdpt::GetGlobalMaxVolume
 
   547 // TMSCallCSAdpt::GetGlobalMaxVolume
 
   518 //
 
   548 //
 
   519 // -----------------------------------------------------------------------------
 
   549 // -----------------------------------------------------------------------------
 
   520 //
 
   550 //
 
   521 gint CallCSAdpt::GetGlobalMaxVolume(guint& volume)
 
   551 gint TMSCallCSAdpt::GetGlobalMaxVolume(guint& volume)
 
   522     {
 
   552     {
 
   523     TRACE_PRN_FN_ENT;
 
   553     TRACE_PRN_FN_ENT;
 
   524     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   554     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   525     if (iCSDownlink && iDnlinkInitialized)
 
   555     if (iCSDownlink && iDnlinkInitialized)
 
   526         {
 
   556         {
 
   530     TRACE_PRN_FN_EXT;
 
   560     TRACE_PRN_FN_EXT;
 
   531     return status;
 
   561     return status;
 
   532     }
 
   562     }
 
   533 
   563 
   534 // -----------------------------------------------------------------------------
 
   564 // -----------------------------------------------------------------------------
 
   535 // CallCSAdpt::SetGlobalVolume
 
   565 // TMSCallCSAdpt::SetGlobalVolume
 
   536 //
 
   566 //
 
   537 // -----------------------------------------------------------------------------
 
   567 // -----------------------------------------------------------------------------
 
   538 //
 
   568 //
 
   539 gint CallCSAdpt::SetGlobalVolume(const guint volume)
 
   569 gint TMSCallCSAdpt::SetGlobalVolume(const guint volume)
 
   540     {
 
   570     {
 
   541     TRACE_PRN_FN_ENT;
 
   571     TRACE_PRN_FN_ENT;
 
   542     gint status(TMS_RESULT_SUCCESS);
 
   572     gint status(TMS_RESULT_SUCCESS);
 
   543 
   573 
   544     iGlobalVol = volume;
 
   574     iGlobalVol = volume;
 
   550     TRACE_PRN_FN_EXT;
 
   580     TRACE_PRN_FN_EXT;
 
   551     return status;
 
   581     return status;
 
   552     }
 
   582     }
 
   553 
   583 
   554 // -----------------------------------------------------------------------------
 
   584 // -----------------------------------------------------------------------------
 
   555 // CallCSAdpt::GetGlobalVolume
 
   585 // TMSCallCSAdpt::GetGlobalVolume
 
   556 //
 
   586 //
 
   557 // -----------------------------------------------------------------------------
 
   587 // -----------------------------------------------------------------------------
 
   558 //
 
   588 //
 
   559 gint CallCSAdpt::GetGlobalVolume(guint& volume)
 
   589 gint TMSCallCSAdpt::GetGlobalVolume(guint& volume)
 
   560     {
 
   590     {
 
   561     TRACE_PRN_FN_ENT;
 
   591     TRACE_PRN_FN_ENT;
 
   562     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   592     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   563     if (iCSDownlink && iDnlinkInitialized)
 
   593     if (iCSDownlink && iDnlinkInitialized)
 
   564         {
 
   594         {
 
   569     TRACE_PRN_FN_EXT;
 
   599     TRACE_PRN_FN_EXT;
 
   570     return status;
 
   600     return status;
 
   571     }
 
   601     }
 
   572 
   602 
   573 // -----------------------------------------------------------------------------
 
   603 // -----------------------------------------------------------------------------
 
   574 // CallCSAdpt::GetMaxGain
 
   604 // TMSCallCSAdpt::GetMaxGain
 
   575 //
 
   605 //
 
   576 // -----------------------------------------------------------------------------
 
   606 // -----------------------------------------------------------------------------
 
   577 //
 
   607 //
 
   578 gint CallCSAdpt::GetGlobalMaxGain(guint& gain)
 
   608 gint TMSCallCSAdpt::GetGlobalMaxGain(guint& gain)
 
   579     {
 
   609     {
 
   580     TRACE_PRN_FN_ENT;
 
   610     TRACE_PRN_FN_ENT;
 
   581     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   611     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   582     if (iCSUplink && iUplinkInitialized)
 
   612     if (iCSUplink && iUplinkInitialized)
 
   583         {
 
   613         {
 
   587     TRACE_PRN_FN_EXT;
 
   617     TRACE_PRN_FN_EXT;
 
   588     return status;
 
   618     return status;
 
   589     }
 
   619     }
 
   590 
   620 
   591 // -----------------------------------------------------------------------------
 
   621 // -----------------------------------------------------------------------------
 
   592 // CallCSAdpt::SetGain
 
   622 // TMSCallCSAdpt::SetGain
 
   593 //
 
   623 //
 
   594 // -----------------------------------------------------------------------------
 
   624 // -----------------------------------------------------------------------------
 
   595 //
 
   625 //
 
   596 gint CallCSAdpt::SetGlobalGain(const guint gain)
 
   626 gint TMSCallCSAdpt::SetGlobalGain(const guint gain)
 
   597     {
 
   627     {
 
   598     TRACE_PRN_FN_ENT;
 
   628     TRACE_PRN_FN_ENT;
 
   599     gint status(TMS_RESULT_SUCCESS);
 
   629     gint status(TMS_RESULT_SUCCESS);
 
   600 
   630 
   601     iGlobalGain = gain;
 
   631     iGlobalGain = gain;
 
   607     TRACE_PRN_FN_EXT;
 
   637     TRACE_PRN_FN_EXT;
 
   608     return status;
 
   638     return status;
 
   609     }
 
   639     }
 
   610 
   640 
   611 // -----------------------------------------------------------------------------
 
   641 // -----------------------------------------------------------------------------
 
   612 // CallCSAdpt::GetGlobalGain
 
   642 // TMSCallCSAdpt::GetGlobalGain
 
   613 //
 
   643 //
 
   614 // -----------------------------------------------------------------------------
 
   644 // -----------------------------------------------------------------------------
 
   615 //
 
   645 //
 
   616 gint CallCSAdpt::GetGlobalGain(guint& gain)
 
   646 gint TMSCallCSAdpt::GetGlobalGain(guint& gain)
 
   617     {
 
   647     {
 
   618     TRACE_PRN_FN_ENT;
 
   648     TRACE_PRN_FN_ENT;
 
   619     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   649     gint status(TMS_RESULT_ILLEGAL_OPERATION);
 
   620     if (iCSUplink && iUplinkInitialized)
 
   650     if (iCSUplink && iUplinkInitialized)
 
   621         {
 
   651         {
 
   625     TRACE_PRN_FN_EXT;
 
   655     TRACE_PRN_FN_EXT;
 
   626     return status;
 
   656     return status;
 
   627     }
 
   657     }
 
   628 
   658 
   629 // -----------------------------------------------------------------------------
 
   659 // -----------------------------------------------------------------------------
 
   630 // CallCSAdpt::GetCodecMode
 
   660 // TMSCallCSAdpt::GetCodecMode
 
   631 //
 
   661 //
 
   632 // -----------------------------------------------------------------------------
 
   662 // -----------------------------------------------------------------------------
 
   633 //
 
   663 //
 
   634 gint CallCSAdpt::GetCodecMode(const TMSFormatType /*fmttype*/,
 
   664 gint TMSCallCSAdpt::GetCodecMode(const TMSFormatType /*fmttype*/,
 
   635         const TMSStreamType /*strmtype*/, gint& /*mode*/)
 
   665         const TMSStreamType /*strmtype*/, gint& /*mode*/)
 
   636     {
 
   666     {
 
   637     TRACE_PRN_FN_ENT;
 
   667     TRACE_PRN_FN_ENT;
 
   638     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   668     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   639     TRACE_PRN_FN_EXT;
 
   669     TRACE_PRN_FN_EXT;
 
   640     return status;
 
   670     return status;
 
   641     }
 
   671     }
 
   642 
   672 
   643 // -----------------------------------------------------------------------------
 
   673 // -----------------------------------------------------------------------------
 
   644 // CallCSAdpt::SetCodecMode
 
   674 // TMSCallCSAdpt::SetCodecMode
 
   645 //
 
   675 //
 
   646 // -----------------------------------------------------------------------------
 
   676 // -----------------------------------------------------------------------------
 
   647 //
 
   677 //
 
   648 gint CallCSAdpt::SetCodecMode(const TMSFormatType /*fmttype*/,
 
   678 gint TMSCallCSAdpt::SetCodecMode(const TMSFormatType /*fmttype*/,
 
   649         const TMSStreamType /*strmtype*/, const gint /*mode*/)
 
   679         const TMSStreamType /*strmtype*/, const gint /*mode*/)
 
   650     {
 
   680     {
 
   651     TRACE_PRN_FN_ENT;
 
   681     TRACE_PRN_FN_ENT;
 
   652     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   682     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   653     TRACE_PRN_FN_EXT;
 
   683     TRACE_PRN_FN_EXT;
 
   654     return status;
 
   684     return status;
 
   655     }
 
   685     }
 
   656 
   686 
   657 // -----------------------------------------------------------------------------
 
   687 // -----------------------------------------------------------------------------
 
   658 // CallCSAdpt::GetSupportedBitRatesCount
 
   688 // TMSCallCSAdpt::GetSupportedBitRatesCount
 
   659 //
 
   689 //
 
   660 // -----------------------------------------------------------------------------
 
   690 // -----------------------------------------------------------------------------
 
   661 //
 
   691 //
 
   662 gint CallCSAdpt::GetSupportedBitRatesCount(guint& /*count*/)
 
   692 gint TMSCallCSAdpt::GetSupportedBitRatesCount(guint& /*count*/)
 
   663     {
 
   693     {
 
   664     TRACE_PRN_FN_ENT;
 
   694     TRACE_PRN_FN_ENT;
 
   665     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   695     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   666     TRACE_PRN_FN_EXT;
 
   696     TRACE_PRN_FN_EXT;
 
   667     return status;
 
   697     return status;
 
   668     }
 
   698     }
 
   669 
   699 
   670 // -----------------------------------------------------------------------------
 
   700 // -----------------------------------------------------------------------------
 
   671 // CallCSAdpt::GetSupportedBitRates
 
   701 // TMSCallCSAdpt::GetSupportedBitRates
 
   672 //
 
   702 //
 
   673 // -----------------------------------------------------------------------------
 
   703 // -----------------------------------------------------------------------------
 
   674 //
 
   704 //
 
   675 gint CallCSAdpt::GetSupportedBitRates(CBufFlat*& brbuffer)
 
   705 gint TMSCallCSAdpt::GetSupportedBitRates(CBufFlat*& brbuffer)
 
   676     {
 
   706     {
 
   677     TRACE_PRN_FN_ENT;
 
   707     TRACE_PRN_FN_ENT;
 
   678     TRAPD(status, GetSupportedBitRatesL(brbuffer));
 
   708     TRAPD(status, GetSupportedBitRatesL(brbuffer));
 
   679     TRACE_PRN_FN_EXT;
 
   709     TRACE_PRN_FN_EXT;
 
   680     return status;
 
   710     return status;
 
   681     }
 
   711     }
 
   682 
   712 
   683 // -----------------------------------------------------------------------------
 
   713 // -----------------------------------------------------------------------------
 
   684 // CallCSAdpt::GetSupportedBitRatesL
 
   714 // TMSCallCSAdpt::GetSupportedBitRatesL
 
   685 //
 
   715 //
 
   686 // GetSupportedBitRates implementation which can leave.
 
   716 // GetSupportedBitRates implementation which can leave.
 
   687 // -----------------------------------------------------------------------------
 
   717 // -----------------------------------------------------------------------------
 
   688 //
 
   718 //
 
   689 void CallCSAdpt::GetSupportedBitRatesL(CBufFlat*& /*brbuffer*/)
 
   719 void TMSCallCSAdpt::GetSupportedBitRatesL(CBufFlat*& /*brbuffer*/)
 
   690     {
 
   720     {
 
   691     User::Leave(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   721     User::Leave(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   692     }
 
   722     }
 
   693 
   723 
   694 // -----------------------------------------------------------------------------
 
   724 // -----------------------------------------------------------------------------
 
   695 // CallCSAdpt::GetBitRate
 
   725 // TMSCallCSAdpt::GetBitRate
 
   696 //
 
   726 //
 
   697 // -----------------------------------------------------------------------------
 
   727 // -----------------------------------------------------------------------------
 
   698 //
 
   728 //
 
   699 gint CallCSAdpt::GetBitRate(guint& /*bitrate*/)
 
   729 gint TMSCallCSAdpt::GetBitRate(guint& /*bitrate*/)
 
   700     {
 
   730     {
 
   701     TRACE_PRN_FN_ENT;
 
   731     TRACE_PRN_FN_ENT;
 
   702     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   732     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   703     TRACE_PRN_FN_EXT;
 
   733     TRACE_PRN_FN_EXT;
 
   704     return status;
 
   734     return status;
 
   705     }
 
   735     }
 
   706 
   736 
   707 // -----------------------------------------------------------------------------
 
   737 // -----------------------------------------------------------------------------
 
   708 // CallCSAdpt::SetBitRate
 
   738 // TMSCallCSAdpt::SetBitRate
 
   709 //
 
   739 //
 
   710 // -----------------------------------------------------------------------------
 
   740 // -----------------------------------------------------------------------------
 
   711 //
 
   741 //
 
   712 gint CallCSAdpt::SetBitRate(const guint /*bitrate*/)
 
   742 gint TMSCallCSAdpt::SetBitRate(const guint /*bitrate*/)
 
   713     {
 
   743     {
 
   714     TRACE_PRN_FN_ENT;
 
   744     TRACE_PRN_FN_ENT;
 
   715     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   745     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   716     TRACE_PRN_FN_EXT;
 
   746     TRACE_PRN_FN_EXT;
 
   717     return status;
 
   747     return status;
 
   718     }
 
   748     }
 
   719 
   749 
   720 // -----------------------------------------------------------------------------
 
   750 // -----------------------------------------------------------------------------
 
   721 // CallCSAdpt::GetVAD
 
   751 // TMSCallCSAdpt::GetVAD
 
   722 //
 
   752 //
 
   723 // -----------------------------------------------------------------------------
 
   753 // -----------------------------------------------------------------------------
 
   724 //
 
   754 //
 
   725 gint CallCSAdpt::GetVAD(const TMSFormatType /*fmttype*/, gboolean& /*vad*/)
 
   755 gint TMSCallCSAdpt::GetVAD(const TMSFormatType /*fmttype*/, gboolean& /*vad*/)
 
   726     {
 
   756     {
 
   727     TRACE_PRN_FN_ENT;
 
   757     TRACE_PRN_FN_ENT;
 
   728     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   758     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   729     TRACE_PRN_FN_EXT;
 
   759     TRACE_PRN_FN_EXT;
 
   730     return status;
 
   760     return status;
 
   731     }
 
   761     }
 
   732 
   762 
   733 // -----------------------------------------------------------------------------
 
   763 // -----------------------------------------------------------------------------
 
   734 // CallCSAdpt::SetVAD
 
   764 // TMSCallCSAdpt::SetVAD
 
   735 //
 
   765 //
 
   736 // -----------------------------------------------------------------------------
 
   766 // -----------------------------------------------------------------------------
 
   737 //
 
   767 //
 
   738 gint CallCSAdpt::SetVAD(const TMSFormatType /*fmttype*/, const gboolean /*vad*/)
 
   768 gint TMSCallCSAdpt::SetVAD(const TMSFormatType /*fmttype*/, const gboolean /*vad*/)
 
   739     {
 
   769     {
 
   740     TRACE_PRN_FN_ENT;
 
   770     TRACE_PRN_FN_ENT;
 
   741     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   771     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   742     TRACE_PRN_FN_EXT;
 
   772     TRACE_PRN_FN_EXT;
 
   743     return status;
 
   773     return status;
 
   744     }
 
   774     }
 
   745 
   775 
   746 // -----------------------------------------------------------------------------
 
   776 // -----------------------------------------------------------------------------
 
   747 // CallCSAdpt::GetCNG
 
   777 // TMSCallCSAdpt::GetCNG
 
   748 //
 
   778 //
 
   749 // -----------------------------------------------------------------------------
 
   779 // -----------------------------------------------------------------------------
 
   750 //
 
   780 //
 
   751 gint CallCSAdpt::GetCNG(const TMSFormatType /*fmttype*/, gboolean& /*cng*/)
 
   781 gint TMSCallCSAdpt::GetCNG(const TMSFormatType /*fmttype*/, gboolean& /*cng*/)
 
   752     {
 
   782     {
 
   753     TRACE_PRN_FN_ENT;
 
   783     TRACE_PRN_FN_ENT;
 
   754     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   784     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   755     TRACE_PRN_FN_EXT;
 
   785     TRACE_PRN_FN_EXT;
 
   756     return status;
 
   786     return status;
 
   757     }
 
   787     }
 
   758 
   788 
   759 // -----------------------------------------------------------------------------
 
   789 // -----------------------------------------------------------------------------
 
   760 // CallCSAdpt::SetCNG
 
   790 // TMSCallCSAdpt::SetCNG
 
   761 //
 
   791 //
 
   762 // -----------------------------------------------------------------------------
 
   792 // -----------------------------------------------------------------------------
 
   763 //
 
   793 //
 
   764 gint CallCSAdpt::SetCNG(const TMSFormatType /*fmttype*/, const gboolean /*cng*/)
 
   794 gint TMSCallCSAdpt::SetCNG(const TMSFormatType /*fmttype*/,
 
   765     {
 
   795         const gboolean /*cng*/)
 
   766     TRACE_PRN_FN_ENT;
 
   796     {
 
   767     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   797     TRACE_PRN_FN_ENT;
 
   768     TRACE_PRN_FN_EXT;
 
   798     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   769     return status;
 
   799     TRACE_PRN_FN_EXT;
 
   770     }
 
   800     return status;
 
   771 
   801     }
 
   772 // -----------------------------------------------------------------------------
 
   802 
   773 // CallCSAdpt::GetPlc
 
   803 // -----------------------------------------------------------------------------
 
   774 //
 
   804 // TMSCallCSAdpt::GetPlc
 
   775 // -----------------------------------------------------------------------------
 
   805 //
 
   776 //
 
   806 // -----------------------------------------------------------------------------
 
   777 gint CallCSAdpt::GetPlc(const TMSFormatType /*fmttype*/, gboolean& /*plc*/)
 
   807 //
 
   778     {
 
   808 gint TMSCallCSAdpt::GetPlc(const TMSFormatType /*fmttype*/, gboolean& /*plc*/)
 
   779     TRACE_PRN_FN_ENT;
 
   809     {
 
   780     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   810     TRACE_PRN_FN_ENT;
 
   781     TRACE_PRN_FN_EXT;
 
   811     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   782     return status;
 
   812     TRACE_PRN_FN_EXT;
 
   783     }
 
   813     return status;
 
   784 
   814     }
 
   785 // -----------------------------------------------------------------------------
 
   815 
   786 // CallCSAdpt::SetPlc
 
   816 // -----------------------------------------------------------------------------
 
   787 //
 
   817 // TMSCallCSAdpt::SetPlc
 
   788 // -----------------------------------------------------------------------------
 
   818 //
 
   789 //
 
   819 // -----------------------------------------------------------------------------
 
   790 gint CallCSAdpt::SetPlc(const TMSFormatType /*fmttype*/, const gboolean /*plc*/)
 
   820 //
 
   791     {
 
   821 gint TMSCallCSAdpt::SetPlc(const TMSFormatType /*fmttype*/,
 
   792     TRACE_PRN_FN_ENT;
 
   822         const gboolean /*plc*/)
 
   793     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   823     {
 
   794     TRACE_PRN_FN_EXT;
 
   824     TRACE_PRN_FN_ENT;
 
   795     return status;
 
   825     gint status(TMS_RESULT_FEATURE_NOT_SUPPORTED);
 
   796     }
 
   826     TRACE_PRN_FN_EXT;
 
   797 
   827     return status;
 
   798 // -----------------------------------------------------------------------------
 
   828     }
 
   799 // CallCSAdpt::SetOutput
 
   829 
   800 //
 
   830 // -----------------------------------------------------------------------------
 
   801 // -----------------------------------------------------------------------------
 
   831 // TMSCallCSAdpt::SetOutput
 
   802 //
 
   832 //
 
   803 gint CallCSAdpt::SetOutput(TMSAudioOutput output)
 
   833 // -----------------------------------------------------------------------------
 
       
   834 //
 
       
   835 gint TMSCallCSAdpt::SetOutput(TMSAudioOutput output)
 
   804     {
 
   836     {
 
   805     TRACE_PRN_FN_ENT;
 
   837     TRACE_PRN_FN_ENT;
 
   806     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 
   838     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 
   807 
   839 
   808     if (iRouting)
 
   840     if (iRouting)
 
   822     TRACE_PRN_FN_EXT;
 
   854     TRACE_PRN_FN_EXT;
 
   823     return status;
 
   855     return status;
 
   824     }
 
   856     }
 
   825 
   857 
   826 // -----------------------------------------------------------------------------
 
   858 // -----------------------------------------------------------------------------
 
   827 // CallCSAdpt::GetOutput
 
   859 // TMSCallCSAdpt::GetOutput
 
   828 //
 
   860 //
 
   829 // -----------------------------------------------------------------------------
 
   861 // -----------------------------------------------------------------------------
 
   830 //
 
   862 //
 
   831 gint CallCSAdpt::GetOutput(TMSAudioOutput& output)
 
   863 gint TMSCallCSAdpt::GetOutput(TMSAudioOutput& output)
 
   832     {
 
   864     {
 
   833     TRACE_PRN_FN_ENT;
 
   865     TRACE_PRN_FN_ENT;
 
   834     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 
   866     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 
   835 
   867 
   836     if (iRouting)
 
   868     if (iRouting)
 
   844     TRACE_PRN_FN_EXT;
 
   876     TRACE_PRN_FN_EXT;
 
   845     return status;
 
   877     return status;
 
   846     }
 
   878     }
 
   847 
   879 
   848 // -----------------------------------------------------------------------------
 
   880 // -----------------------------------------------------------------------------
 
   849 // CallCSAdpt::GetPreviousOutput
 
   881 // TMSCallCSAdpt::GetPreviousOutput
 
   850 //
 
   882 //
 
   851 // -----------------------------------------------------------------------------
 
   883 // -----------------------------------------------------------------------------
 
   852 //
 
   884 //
 
   853 gint CallCSAdpt::GetPreviousOutput(TMSAudioOutput& output)
 
   885 gint TMSCallCSAdpt::GetPreviousOutput(TMSAudioOutput& output)
 
   854     {
 
   886     {
 
   855     TRACE_PRN_FN_ENT;
 
   887     TRACE_PRN_FN_ENT;
 
   856     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 
   888     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 
   857 
   889 
   858     if (iRouting)
 
   890     if (iRouting)
 
   865     TRACE_PRN_FN_EXT;
 
   897     TRACE_PRN_FN_EXT;
 
   866     return status;
 
   898     return status;
 
   867     }
 
   899     }
 
   868 
   900 
   869 // -----------------------------------------------------------------------------
 
   901 // -----------------------------------------------------------------------------
 
   870 // CallCSAdpt::GetAvailableOutputsL
 
   902 // TMSCallCSAdpt::GetAvailableOutputsL
 
   871 //
 
   903 //
 
   872 // -----------------------------------------------------------------------------
 
   904 // -----------------------------------------------------------------------------
 
   873 //
 
   905 //
 
   874 gint CallCSAdpt::GetAvailableOutputsL(gint& count, CBufFlat*& outputsbuffer)
 
   906 gint TMSCallCSAdpt::GetAvailableOutputsL(gint& count, CBufFlat*& outputsbuffer)
 
   875     {
 
   907     {
 
   876     TRACE_PRN_FN_ENT;
 
   908     TRACE_PRN_FN_ENT;
 
   877     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 
   909     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);
 
   878     TMSAudioOutput tmsoutput;
 
   910     TMSAudioOutput tmsoutput;
 
   879 
   911 
   901 
   933 
   902     TRACE_PRN_FN_EXT;
 
   934     TRACE_PRN_FN_EXT;
 
   903     return status;
 
   935     return status;
 
   904     }
 
   936     }
 
   905 
   937 
   906 
   938 // -----------------------------------------------------------------------------
 
   907 // From MCSPDevSoundObserver
 
   939 // TMSCallCSAdpt::StartDTMF
 
   908 
   940 //
 
   909 // -----------------------------------------------------------------------------
 
   941 // -----------------------------------------------------------------------------
 
   910 // CallCSAdpt::DownlinkInitCompleted
 
   942 //
 
   911 //
 
   943 gint TMSCallCSAdpt::StartDTMF(TMSStreamType strmtype, TDes& dtmfstring)
 
   912 // -----------------------------------------------------------------------------
 
   944     {
 
   913 //
 
   945     TRACE_PRN_FN_ENT;
 
   914 void CallCSAdpt::DownlinkInitCompleted(TInt status)
 
   946     gint status(TMS_RESULT_SUCCESS);
 
       
   947 
       
   948     TmsMsgBufPckg dtmfpckg;
 
       
   949 
       
   950     if (strmtype == TMS_STREAM_DOWNLINK && iDnlinkInitialized)
 
       
   951         {
 
       
   952         if (iDTMFDnlinkPlayer)
 
       
   953             {
 
       
   954             iDTMFDnlinkPlayer->PlayDtmfTone(dtmfstring);
 
       
   955             }
 
       
   956 
       
   957         dtmfpckg().iStatus = TMS_RESULT_SUCCESS;
 
       
   958         //TMS_EVENT_DTMF_TONE_STARTED;
 
       
   959         dtmfpckg().iRequest = ECmdDTMFOpenDnlinkComplete;
 
       
   960         if (iDTMFNotifier)
 
       
   961             {
 
       
   962             iDTMFNotifier->SetDtmf(dtmfpckg, TRUE);
 
       
   963             }
 
       
   964         }
 
       
   965     else if (strmtype == TMS_STREAM_UPLINK && iUplinkInitialized)
 
       
   966         {
 
       
   967         //use etel for uplink
 
       
   968         if (iDTMFUplinkPlayer)
 
       
   969             {
 
       
   970             status = iDTMFUplinkPlayer->SendDtmfToneString(dtmfstring);
 
       
   971             }
 
       
   972 
       
   973         dtmfpckg().iStatus = TMSUtility::EtelToTMSResult(status);
 
       
   974         //TMS_EVENT_DTMF_TONE_STARTED;
 
       
   975         dtmfpckg().iRequest = ECmdDTMFOpenUplinkComplete;
 
       
   976 
       
   977         if (iDTMFNotifier)
 
       
   978             {
 
       
   979             iDTMFNotifier->SetDtmf(dtmfpckg, TRUE);
 
       
   980             }
 
       
   981         }
 
       
   982 
       
   983     TRACE_PRN_FN_EXT;
 
       
   984     return status;
 
       
   985     }
 
       
   986 
       
   987 // -----------------------------------------------------------------------------
 
       
   988 // TMSCallCSAdpt::StopDTMF
 
       
   989 //
 
       
   990 // -----------------------------------------------------------------------------
 
       
   991 //
 
       
   992 gint TMSCallCSAdpt::StopDTMF(TMSStreamType streamtype)
 
       
   993     {
 
       
   994     TRACE_PRN_FN_ENT;
 
       
   995     gint status(TMS_RESULT_SUCCESS);
 
       
   996 
       
   997     if (streamtype == TMS_STREAM_DOWNLINK && iDTMFDnlinkPlayer)
 
       
   998         {
 
       
   999         iDTMFDnlinkPlayer->Cancel();
 
       
  1000         }
 
       
  1001     else if (streamtype == TMS_STREAM_UPLINK && iDTMFUplinkPlayer)
 
       
  1002         {
 
       
  1003         status = iDTMFUplinkPlayer->StopDtmfTone();
 
       
  1004         status = TMSUtility::EtelToTMSResult(status);
 
       
  1005         }
 
       
  1006 
       
  1007     TRACE_PRN_FN_EXT;
 
       
  1008     return status;
 
       
  1009     }
 
       
  1010 
       
  1011 // -----------------------------------------------------------------------------
 
       
  1012 // TMSCallCSAdpt::ContinueDTMF
 
       
  1013 //
 
       
  1014 // -----------------------------------------------------------------------------
 
       
  1015 //
 
       
  1016 gint TMSCallCSAdpt::ContinueDTMF(TBool continuesending)
 
       
  1017     {
 
       
  1018     TRACE_PRN_FN_ENT;
 
       
  1019     gint status(TMS_RESULT_SUCCESS);
 
       
  1020 
       
  1021     if (iDTMFUplinkPlayer)
 
       
  1022         {
 
       
  1023         status = iDTMFUplinkPlayer->ContinueDtmfStringSending(continuesending);
 
       
  1024         status = TMSUtility::EtelToTMSResult(status);
 
       
  1025         }
 
       
  1026 
       
  1027     TRACE_PRN_FN_EXT;
 
       
  1028     return status;
 
       
  1029     }
 
       
  1030 
       
  1031 //From DTMFTonePlayerObserver
 
       
  1032 // -----------------------------------------------------------------------------
 
       
  1033 // TMSCallCSAdpt::DTMFInitCompleted
 
       
  1034 //
 
       
  1035 // -----------------------------------------------------------------------------
 
       
  1036 //
 
       
  1037 void TMSCallCSAdpt::DTMFInitCompleted(TInt /*error*/)
 
       
  1038     {
 
       
  1039     TRACE_PRN_FN_ENT;
 
       
  1040     TRACE_PRN_FN_EXT;
 
       
  1041     }
 
       
  1042 
       
  1043 // -----------------------------------------------------------------------------
 
       
  1044 // TMSCallCSAdpt::DTMFToneFinished
 
       
  1045 //
 
       
  1046 // -----------------------------------------------------------------------------
 
       
  1047 //
 
       
  1048 void TMSCallCSAdpt::DTMFToneFinished(TInt error)
 
       
  1049     {
 
       
  1050     TRACE_PRN_FN_ENT;
 
       
  1051     TmsMsgBufPckg dtmfpckg;
 
       
  1052 
       
  1053     if (error == KErrUnderflow || error == KErrInUse)
 
       
  1054         {
 
       
  1055         error = TMS_RESULT_SUCCESS;
 
       
  1056         }
 
       
  1057 
       
  1058     dtmfpckg().iStatus = TMSUtility::TMSResult(error);
 
       
  1059     //TMS_EVENT_DTMF_TONE_STOPPED
 
       
  1060     dtmfpckg().iRequest = ECmdDTMFTonePlayFinished;
 
       
  1061     if (iDTMFNotifier)
 
       
  1062         {
 
       
  1063         iDTMFNotifier->SetDtmf(dtmfpckg, TRUE);
 
       
  1064         }
 
       
  1065 
       
  1066     TRACE_PRN_FN_EXT;
 
       
  1067     }
 
       
  1068 
       
  1069 // -----------------------------------------------------------------------------
 
       
  1070 // TMSCallCSAdpt::HandleDTMFEvent
 
       
  1071 //
 
       
  1072 // -----------------------------------------------------------------------------
 
       
  1073 //
 
       
  1074 void TMSCallCSAdpt::HandleDTMFEvent(
 
       
  1075         const TMSCCPDTMFObserver::TCCPDtmfEvent aEvent, const TInt aError,
 
       
  1076         const TChar /*aTone*/)
 
       
  1077     {
 
       
  1078     TRACE_PRN_FN_ENT;
 
       
  1079     TmsMsgBufPckg dtmfpckg;
 
       
  1080 
       
  1081     TRACE_PRN_N1(_L("**TMS TMSCallCSAdpt::HandleDTMFEvent error:%d"),aError);
 
       
  1082 
       
  1083     dtmfpckg().iStatus = TMSUtility::EtelToTMSResult(aError);
 
       
  1084 
       
  1085     switch (aEvent)
 
       
  1086         {
 
       
  1087             /** Unknown */
 
       
  1088         case ECCPDtmfUnknown:
 
       
  1089             break;
 
       
  1090             /** DTMF sending started manually */
 
       
  1091         case ECCPDtmfManualStart:
 
       
  1092             /** Automatic DTMF sending initialized */
 
       
  1093         case ECCPDtmfSequenceStart:
 
       
  1094             //TMS_EVENT_DTMF_TONE_STARTED
 
       
  1095             dtmfpckg().iRequest = ECmdDTMFOpenUplinkComplete;
 
       
  1096             break;
 
       
  1097 
       
  1098             /** DTMF sending stopped manually */
 
       
  1099         case ECCPDtmfManualStop:
 
       
  1100             //break;
 
       
  1101             /** DTMF sending aborted manually */
 
       
  1102         case ECCPDtmfManualAbort:
 
       
  1103             //break;
 
       
  1104             /** Automatic DTMF sending stopped */
 
       
  1105         case ECCPDtmfSequenceStop:
 
       
  1106             //break;
 
       
  1107             /** Automatic DTMF sending aborted */
 
       
  1108         case ECCPDtmfSequenceAbort:
 
       
  1109             //break;
 
       
  1110             /** There was stop mark in DTMF string */
 
       
  1111         case ECCPDtmfStopInDtmfString:
 
       
  1112             //break;
 
       
  1113             /** DTMF sending completed succesfully */
 
       
  1114         case ECCPDtmfStringSendingCompleted:
 
       
  1115             //TMS_EVENT_DTMF_TONE_STOPPED
 
       
  1116             dtmfpckg().iRequest = ECmdDTMFTonePlayFinished;
 
       
  1117             break;
 
       
  1118         default:
 
       
  1119             break;
 
       
  1120         }
 
       
  1121 
       
  1122     if (iDTMFNotifier)
 
       
  1123         {
 
       
  1124         iDTMFNotifier->SetDtmf(dtmfpckg, TRUE);
 
       
  1125         }
 
       
  1126     TRACE_PRN_FN_EXT;
 
       
  1127     }
 
       
  1128 
       
  1129 // From TMSCSPDevSoundObserver
 
       
  1130 
       
  1131 // -----------------------------------------------------------------------------
 
       
  1132 // TMSCallCSAdpt::DownlinkInitCompleted
 
       
  1133 //
 
       
  1134 // -----------------------------------------------------------------------------
 
       
  1135 //
 
       
  1136 void TMSCallCSAdpt::DownlinkInitCompleted(TInt status)
 
   915     {
 
  1137     {
 
   916     TRACE_PRN_FN_ENT;
 
  1138     TRACE_PRN_FN_ENT;
 
   917     NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status, 0);
 
  1139     NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status, 0);
 
   918     TRACE_PRN_FN_EXT;
 
  1140     TRACE_PRN_FN_EXT;
 
   919     }
 
  1141     }
 
   920 
  1142 
   921 // -----------------------------------------------------------------------------
 
  1143 // -----------------------------------------------------------------------------
 
   922 // CallCSAdpt::UplinkInitCompleted
 
  1144 // TMSCallCSAdpt::UplinkInitCompleted
 
   923 //
 
  1145 //
 
   924 // -----------------------------------------------------------------------------
 
  1146 // -----------------------------------------------------------------------------
 
   925 //
 
  1147 //
 
   926 void CallCSAdpt::UplinkInitCompleted(TInt status)
 
  1148 void TMSCallCSAdpt::UplinkInitCompleted(TInt status)
 
   927     {
 
  1149     {
 
   928     TRACE_PRN_FN_ENT;
 
  1150     TRACE_PRN_FN_ENT;
 
   929     NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status, 0);
 
  1151     NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status, 0);
 
   930     TRACE_PRN_FN_EXT;
 
  1152     TRACE_PRN_FN_EXT;
 
   931     }
 
  1153     }
 
   932 
  1154 
   933 // -----------------------------------------------------------------------------
 
  1155 // -----------------------------------------------------------------------------
 
   934 // CallCSAdpt::UplinkActivatedSuccessfully
 
  1156 // TMSCallCSAdpt::UplinkActivatedSuccessfully
 
   935 //
 
  1157 //
 
   936 // -----------------------------------------------------------------------------
 
  1158 // -----------------------------------------------------------------------------
 
   937 //
 
  1159 //
 
   938 void CallCSAdpt::UplinkActivatedSuccessfully()
 
  1160 void TMSCallCSAdpt::UplinkActivatedSuccessfully()
 
   939     {
 
  1161     {
 
   940     TRACE_PRN_FN_ENT;
 
  1162     TRACE_PRN_FN_ENT;
 
   941     NotifyClient(iUplinkStreamId, ECmdUplinkStarted, KErrNone, 0);
 
  1163     NotifyClient(iUplinkStreamId, ECmdUplinkStarted, KErrNone, 0);
 
   942     TRACE_PRN_FN_EXT;
 
  1164     TRACE_PRN_FN_EXT;
 
   943     }
 
  1165     }
 
   944 
  1166 
   945 // -----------------------------------------------------------------------------
 
  1167 // -----------------------------------------------------------------------------
 
   946 // CallCSAdpt::DownlinkActivatedSuccessfully
 
  1168 // TMSCallCSAdpt::DownlinkActivatedSuccessfully
 
   947 //
 
  1169 //
 
   948 // -----------------------------------------------------------------------------
 
  1170 // -----------------------------------------------------------------------------
 
   949 //
 
  1171 //
 
   950 void CallCSAdpt::DownlinkActivatedSuccessfully()
 
  1172 void TMSCallCSAdpt::DownlinkActivatedSuccessfully()
 
   951     {
 
  1173     {
 
   952     TRACE_PRN_FN_ENT;
 
  1174     TRACE_PRN_FN_ENT;
 
   953     NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, KErrNone, 0);
 
  1175     NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, KErrNone, 0);
 
   954     TRACE_PRN_FN_EXT;
 
  1176     TRACE_PRN_FN_EXT;
 
   955     }
 
  1177     }
 
   956 
  1178 
   957 // -----------------------------------------------------------------------------
 
  1179 // -----------------------------------------------------------------------------
 
   958 // CallCSAdpt::UplinkActivationFailed
 
  1180 // TMSCallCSAdpt::UplinkActivationFailed
 
   959 //
 
  1181 //
 
   960 // -----------------------------------------------------------------------------
 
  1182 // -----------------------------------------------------------------------------
 
   961 //
 
  1183 //
 
   962 void CallCSAdpt::UplinkActivationFailed()
 
  1184 void TMSCallCSAdpt::UplinkActivationFailed()
 
   963     {
 
  1185     {
 
   964     TRACE_PRN_FN_ENT;
 
  1186     TRACE_PRN_FN_ENT;
 
   965     NotifyClient(iUplinkStreamId, ECmdUplinkStarted, TMS_RESULT_FATAL_ERROR, 0);
 
  1187     NotifyClient(iUplinkStreamId, ECmdUplinkStarted, TMS_RESULT_FATAL_ERROR, 0);
 
   966     TRACE_PRN_FN_EXT;
 
  1188     TRACE_PRN_FN_EXT;
 
   967     }
 
  1189     }
 
   968 
  1190 
   969 // -----------------------------------------------------------------------------
 
  1191 // -----------------------------------------------------------------------------
 
   970 // CallCSAdpt::DownlinkActivationFailed
 
  1192 // TMSCallCSAdpt::DownlinkActivationFailed
 
   971 //
 
  1193 //
 
   972 // -----------------------------------------------------------------------------
 
  1194 // -----------------------------------------------------------------------------
 
   973 //
 
  1195 //
 
   974 void CallCSAdpt::DownlinkActivationFailed()
 
  1196 void TMSCallCSAdpt::DownlinkActivationFailed()
 
   975     {
 
  1197     {
 
   976     TRACE_PRN_FN_ENT;
 
  1198     TRACE_PRN_FN_ENT;
 
   977     NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted,
 
  1199     NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted,
 
   978             TMS_RESULT_FATAL_ERROR, 0);
 
  1200             TMS_RESULT_FATAL_ERROR, 0);
 
   979     TRACE_PRN_FN_EXT;
 
  1201     TRACE_PRN_FN_EXT;
 
   980     }
 
  1202     }
 
   981 
  1203 
   982 // -----------------------------------------------------------------------------
 
  1204 // -----------------------------------------------------------------------------
 
   983 // CallCSAdpt::AvailableOutputsChanged
 
  1205 // TMSCallCSAdpt::AvailableOutputsChanged
 
   984 //
 
  1206 //
 
   985 // -----------------------------------------------------------------------------
 
  1207 // -----------------------------------------------------------------------------
 
   986 //
 
  1208 //
 
   987 void CallCSAdpt::AvailableOutputsChanged(
 
  1209 void TMSCallCSAdpt::AvailableOutputsChanged(
 
   988         CTelephonyAudioRouting& /*aTelephonyAudioRouting*/)
 
  1210         CTelephonyAudioRouting& /*aTelephonyAudioRouting*/)
 
   989     {
 
  1211     {
 
   990     TRACE_PRN_FN_ENT;
 
  1212     TRACE_PRN_FN_ENT;
 
   991     TRoutingMsgBufPckg pckg;
 
  1213     TRoutingMsgBufPckg pckg;
 
   992     pckg().iEvent = TMS_EVENT_ROUTING_AVAIL_OUTPUTS_CHANGED;
 
  1214     pckg().iEvent = TMS_EVENT_ROUTING_AVAIL_OUTPUTS_CHANGED;
 
   993     iTarSettings->SetTar(pckg, ETrue);
 
  1215     iTarSettings->SetTar(pckg, ETrue);
 
   994     TRACE_PRN_FN_EXT;
 
  1216     TRACE_PRN_FN_EXT;
 
   995     }
 
  1217     }
 
   996 
  1218 
   997 // -----------------------------------------------------------------------------
 
  1219 // -----------------------------------------------------------------------------
 
   998 // CallCSAdpt::OutputChanged
 
  1220 // TMSCallCSAdpt::OutputChanged
 
   999 //
 
  1221 //
 
  1000 // -----------------------------------------------------------------------------
 
  1222 // -----------------------------------------------------------------------------
 
  1001 //
 
  1223 //
 
  1002 void CallCSAdpt::OutputChanged(CTelephonyAudioRouting& aTelephonyAudioRouting)
 
  1224 void TMSCallCSAdpt::OutputChanged(
 
       
  1225         CTelephonyAudioRouting& aTelephonyAudioRouting)
 
  1003     {
 
  1226     {
 
  1004     TRACE_PRN_FN_ENT;
 
  1227     TRACE_PRN_FN_ENT;
 
  1005     TRoutingMsgBufPckg pckg;
 
  1228     TRoutingMsgBufPckg pckg;
 
  1006     pckg().iEvent = TMS_EVENT_ROUTING_OUTPUT_CHANGED;
 
  1229     pckg().iEvent = TMS_EVENT_ROUTING_OUTPUT_CHANGED;
 
  1007     pckg().iOutput = TOTMSOUTPUT(aTelephonyAudioRouting.Output());
 
  1230     pckg().iOutput = TOTMSOUTPUT(aTelephonyAudioRouting.Output());
 
  1008     iTarSettings->SetTar(pckg, ETrue);
 
  1231     iTarSettings->SetTar(pckg, ETrue);
 
  1009     TRACE_PRN_FN_EXT;
 
  1232     TRACE_PRN_FN_EXT;
 
  1010     }
 
  1233     }
 
  1011 
  1234 
  1012 // -----------------------------------------------------------------------------
 
  1235 // -----------------------------------------------------------------------------
 
  1013 // CallCSAdpt::SetOutputComplete
 
  1236 // TMSCallCSAdpt::SetOutputComplete
 
  1014 //
 
  1237 //
 
  1015 // -----------------------------------------------------------------------------
 
  1238 // -----------------------------------------------------------------------------
 
  1016 //
 
  1239 //
 
  1017 void CallCSAdpt::SetOutputComplete(
 
  1240 void TMSCallCSAdpt::SetOutputComplete(
 
  1018         CTelephonyAudioRouting& aTelephonyAudioRouting, gint /*aError*/)
 
  1241         CTelephonyAudioRouting& aTelephonyAudioRouting, gint /*aError*/)
 
  1019     {
 
  1242     {
 
  1020     TRACE_PRN_FN_ENT;
 
  1243     TRACE_PRN_FN_ENT;
 
  1021     TRoutingMsgBufPckg pckg;
 
  1244     TRoutingMsgBufPckg pckg;
 
  1022     pckg().iEvent = TMS_EVENT_ROUTING_SET_OUTPUT_COMPLETE;
 
  1245     pckg().iEvent = TMS_EVENT_ROUTING_SET_OUTPUT_COMPLETE;
 
  1028     //TRACE_PRN_IF_ERR(aError);
 
  1251     //TRACE_PRN_IF_ERR(aError);
 
  1029     TRACE_PRN_FN_EXT;
 
  1252     TRACE_PRN_FN_EXT;
 
  1030     }
 
  1253     }
 
  1031 
  1254 
  1032 // -----------------------------------------------------------------------------
 
  1255 // -----------------------------------------------------------------------------
 
  1033 // CallCSAdpt::NotifyClient
 
  1256 // TMSCallCSAdpt::NotifyClient
 
  1034 //
 
  1257 //
 
  1035 // -----------------------------------------------------------------------------
 
  1258 // -----------------------------------------------------------------------------
 
  1036 //
 
  1259 //
 
  1037 void CallCSAdpt::NotifyClient(const gint strmId, const gint aCommand,
 
  1260 void TMSCallCSAdpt::NotifyClient(const gint strmId, const gint aCommand,
 
  1038         const gint aStatus, const gint64 /*aInt64*/)
 
  1261         const gint aStatus, const gint64 /*aInt64*/)
 
  1039     {
 
  1262     {
 
  1040     iMsgBuffer.iRequest = aCommand;
 
  1263     iMsgBuffer.iRequest = aCommand;
 
  1041     iMsgBuffer.iStatus = aStatus;
 
  1264     iMsgBuffer.iStatus = aStatus;
 
  1042 
  1265
FCL/sf/mw/mmmw