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/tmsserver/src/tmsserversession.cpp
changeset 12 5a06f39ad45b
parent 0 71ca22bcf22a
child 14 80975da52420
equal deleted inserted replaced
0:71ca22bcf22a 12:5a06f39ad45b 
    17 
    17 
    18 #include <AudioPreference.h>
 
    18 #include <AudioPreference.h>
 
    19 #include "tmsutility.h"
 
    19 #include "tmsutility.h"
 
    20 #include "tmsclientserver.h"
 
    20 #include "tmsclientserver.h"
 
    21 #include "tmsshared.h"
 
    21 #include "tmsshared.h"
 
       
    22 #include "tmsaudioinbandtoneplayer.h"
 
       
    23 #include "tmsrtplayer.h"
 
    22 #include "tmsserversession.h"
 
    24 #include "tmsserversession.h"
 
    23 
    25 
    24 using namespace TMS;
 
    26 using namespace TMS;
 
    25 
    27 
    26 const TUint KArrayExpandSize = 8;
 
    28 const TUint KArrayExpandSize = 8;
 
    48     {
 
    50     {
 
    49     TRACE_PRN_FN_ENT;
 
    51     TRACE_PRN_FN_ENT;
 
    50 
    52 
    51     iServer.DropSession(); // will start shutdown if no more sessions left
 
    53     iServer.DropSession(); // will start shutdown if no more sessions left
 
    52     delete iDevSound;
 
    54     delete iDevSound;
 
       
    55     delete iInbandTonePlayer;
 
    53 
    56 
    54     if (iMsgQueue.Handle() > 0)
 
    57     if (iMsgQueue.Handle() > 0)
 
    55         {
 
    58         {
 
    56         iMsgQueue.Close();
 
    59         iMsgQueue.Close();
 
    57         }
 
    60         }
 
    97 //
 
   100 //
 
    98 void TMSServerSession::ServiceL(const RMessage2& aMessage)
 
   101 void TMSServerSession::ServiceL(const RMessage2& aMessage)
 
    99     {
 
   102     {
 
   100     TRAPD(err, DispatchMessageL(aMessage));
 
   103     TRAPD(err, DispatchMessageL(aMessage));
 
   101 
   104 
   102     if (err != KErrNone)
 
   105     if (err != TMS_RESULT_SUCCESS)
 
   103         {
 
   106         {
 
   104         aMessage.Complete(err);
 
   107         aMessage.Complete(err);
 
   105         }
 
   108         }
 
   106     }
 
   109     }
 
   107 
   110 
   141         case ETMSGetAvailableOutputs:
 
   144         case ETMSGetAvailableOutputs:
 
   142             iServer.GetAvailableOutputs(aMessage);
 
   145             iServer.GetAvailableOutputs(aMessage);
 
   143             break;
 
   146             break;
 
   144         case ETMSStartRoutingNotifier:
 
   147         case ETMSStartRoutingNotifier:
 
   145             iServer.StartRoutingNotifierL();
 
   148             iServer.StartRoutingNotifierL();
 
   146             aMessage.Complete(KErrNone);
 
   149             aMessage.Complete(TMS_RESULT_SUCCESS);
 
   147             break;
 
   150             break;
 
   148         case ETMSCancelRoutingNotifier:
 
   151         case ETMSCancelRoutingNotifier:
 
   149             iServer.CancelRoutingNotifier();
 
   152             iServer.CancelRoutingNotifier();
 
   150             aMessage.Complete(KErrNone);
 
   153             aMessage.Complete(TMS_RESULT_SUCCESS);
 
   151             break;
 
   154             break;
 
   152         case ETMSStartGlobalEffectNotifier:
 
   155         case ETMSStartGlobalEffectNotifier:
 
   153             iServer.StartCenRepHandlerL();
 
   156             iServer.StartCenRepHandlerL();
 
   154             aMessage.Complete(KErrNone);
 
   157             aMessage.Complete(TMS_RESULT_SUCCESS);
 
   155             break;
 
   158             break;
 
   156         case ETMSCancelGlobalEffectNotifier:
 
   159         case ETMSCancelGlobalEffectNotifier:
 
   157             iServer.CancelCenRepHandler();
 
   160             iServer.CancelCenRepHandler();
 
   158             aMessage.Complete(KErrNone);
 
   161             aMessage.Complete(TMS_RESULT_SUCCESS);
 
   159             break;
 
   162             break;
 
   160         case ETMSSetMsgQueueHandle:
 
   163         case ETMSSetMsgQueueHandle:
 
   161             SetMessageQueueHandleL(aMessage);
 
   164             SetMessageQueueHandleL(aMessage);
 
   162             break;
 
   165             break;
 
   163         case ETMSSetGlobalVol:
 
   166         case ETMSSetGlobalVol:
 
   176             iServer.GetGain(aMessage);
 
   179             iServer.GetGain(aMessage);
 
   177             break;
 
   180             break;
 
   178         case ETMSGetMaxGlobalGain:
 
   181         case ETMSGetMaxGlobalGain:
 
   179             iServer.GetMaxGain(aMessage);
 
   182             iServer.GetMaxGain(aMessage);
 
   180             break;
 
   183             break;
 
       
   184         case ETMSRingToneInitDefault:
 
       
   185             iHasRtPlayer = ETrue;
 
       
   186             iServer.OpenRingTonePlayerFromProfileL(aMessage);
 
       
   187             break;
 
       
   188         case ETMSRingToneInitFile:
 
       
   189             iHasRtPlayer = ETrue;
 
       
   190             iServer.OpenRingTonePlayerFromFileL(aMessage);
 
       
   191             break;
 
       
   192         case ETMSRingToneInitSequence:
 
       
   193             iHasRtPlayer = ETrue;
 
       
   194             iServer.OpenRingToneSequencePlayerL(aMessage);
 
       
   195             break;
 
       
   196         case ETMSRingToneInitBeepOnce:
 
       
   197             iHasRtPlayer = ETrue;
 
       
   198             iServer.OpenRingToneBeepOnceL();
 
       
   199             aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   200             break;
 
       
   201         case ETMSRingToneInitSilent:
 
       
   202             iHasRtPlayer = ETrue;
 
       
   203             iServer.OpenRingToneSilentL();
 
       
   204             aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   205             break;
 
       
   206         case ETMSRingToneInitUnsecureVoIP:
 
       
   207             iHasRtPlayer = ETrue;
 
       
   208             iServer.OpenRingToneUnsecureVoipL();
 
       
   209             aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   210             break;
 
       
   211         case ETMSRingToneDeinit:
 
       
   212             iServer.DeinitRingTonePlayer();
 
       
   213             NotifyClient(ECmdRingToneDeinitComplete, KErrNone);
 
       
   214             iHasRtPlayer = EFalse;
 
       
   215             aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   216             break;
 
       
   217         case ETMSRingTonePlay:
 
       
   218             iHasRtPlayer = ETrue; //will play w/o prior initialization
 
       
   219             iServer.PlayRingToneL();
 
       
   220             aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   221             break;
 
       
   222         case ETMSRingTonePause:
 
       
   223             iServer.PauseVideoRingTone();
 
       
   224             aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   225             break;
 
       
   226         case ETMSRingToneStop:
 
       
   227             iServer.StopRingTone();
 
       
   228             aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   229             break;
 
       
   230         case ETMSRingToneMute:
 
       
   231             iServer.MuteRingTone();
 
       
   232             aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   233             break;
 
       
   234         case ETMSStartDTMFNotifier:
 
       
   235             iServer.StartDTMFNotifierL();
 
       
   236             aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   237             break;
 
       
   238         case ETMSCancelDTMFNotifier:
 
       
   239             iServer.CancelDTMFNotifier();
 
       
   240             aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   241             break;
 
       
   242         case ETMSStartDTMF:
 
       
   243             iServer.StartDTMF(aMessage);
 
       
   244             break;
 
       
   245         case ETMSStopDTMF:
 
       
   246             iServer.StopDTMF(aMessage);
 
       
   247             break;
 
       
   248         case ETMSContinueDTMF:
 
       
   249             iServer.ContinueSendingDTMF(aMessage);
 
       
   250             break;
 
       
   251         case ETMSStartInbandTone:
 
       
   252             StartInbandTone(aMessage);
 
       
   253             break;
 
       
   254         case ETMSStopInbandTone:
 
       
   255             StopInbandTone(aMessage);
 
       
   256             break;
 
   181         default:
 
   257         default:
 
   182             User::Leave(KErrNotSupported);
 
   258             User::Leave(KErrNotSupported);
 
   183             break;
 
   259             break;
 
   184         }
 
   260         }
 
   185     }
 
   261     }
 
   190 // Open message queue for handling server notifications back to the client.
 
   266 // Open message queue for handling server notifications back to the client.
 
   191 // -----------------------------------------------------------------------------
 
   267 // -----------------------------------------------------------------------------
 
   192 //
 
   268 //
 
   193 void TMSServerSession::SetMessageQueueHandleL(const RMessage2& aMessage)
 
   269 void TMSServerSession::SetMessageQueueHandleL(const RMessage2& aMessage)
 
   194     {
 
   270     {
 
   195     gint status = KErrNone;
 
   271     gint status = TMS_RESULT_SUCCESS;
 
   196     if (iMsgQueue.Handle() <= 0)
 
   272     if (iMsgQueue.Handle() <= 0)
 
   197         {
 
   273         {
 
   198         status = iMsgQueue.Open(aMessage, 0);
 
   274         status = iMsgQueue.Open(aMessage, 0);
 
   199         }
 
   275         }
 
   200     if (status != KErrNone)
 
   276     if (status != TMS_RESULT_SUCCESS)
 
   201         {
 
   277         {
 
   202         User::Leave(KErrArgument);
 
   278         User::Leave(KErrArgument);
 
   203         }
 
   279         }
 
   204     aMessage.Complete(KErrNone);
 
   280     aMessage.Complete(TMS_RESULT_SUCCESS);
 
   205     }
 
   281     }
 
   206 
   282 
   207 // -----------------------------------------------------------------------------
 
   283 // -----------------------------------------------------------------------------
 
   208 // TMSServerSession::SetVolLevel
 
   284 // TMSServerSession::SetVolLevel
 
   209 // -----------------------------------------------------------------------------
 
   285 // -----------------------------------------------------------------------------
 
   210 //
 
   286 //
 
   211 void TMSServerSession::SetVolLevel(const RMessage2& aMessage)
 
   287 void TMSServerSession::SetVolLevel(const RMessage2& aMessage)
 
   212     {
 
   288     {
 
   213     TInt level = aMessage.Int0();
 
   289     TInt level = aMessage.Int0();
 
   214     iServer.SetLevel(this, TRUE, level);
 
   290     iServer.SetLevel(this, TRUE, level);
 
   215     aMessage.Complete(KErrNone);
 
   291     aMessage.Complete(TMS_RESULT_SUCCESS);
 
   216     }
 
   292     }
 
   217 
   293 
   218 // -----------------------------------------------------------------------------
 
   294 // -----------------------------------------------------------------------------
 
   219 // TMSServerSession::SetMicGain
 
   295 // TMSServerSession::SetMicGain
 
   220 // -----------------------------------------------------------------------------
 
   296 // -----------------------------------------------------------------------------
 
   221 //
 
   297 //
 
   222 void TMSServerSession::SetMicGain(const RMessage2& aMessage)
 
   298 void TMSServerSession::SetMicGain(const RMessage2& aMessage)
 
   223     {
 
   299     {
 
   224     TInt gain = aMessage.Int0();
 
   300     TInt gain = aMessage.Int0();
 
   225     iServer.SetGain(this, gain);
 
   301     iServer.SetGain(this, gain);
 
   226     aMessage.Complete(KErrNone);
 
   302     aMessage.Complete(TMS_RESULT_SUCCESS);
 
   227     }
 
   303     }
 
   228 
   304 
   229 // -----------------------------------------------------------------------------
 
   305 // -----------------------------------------------------------------------------
 
   230 // TMSServerSession::HandleGlobalEffectChange
 
   306 // TMSServerSession::HandleGlobalEffectChange
 
   231 // -----------------------------------------------------------------------------
 
   307 // -----------------------------------------------------------------------------
 
   232 //
 
   308 //
 
   233 void TMSServerSession::HandleGlobalEffectChange(TInt globalevent)
 
   309 void TMSServerSession::HandleGlobalEffectChange(TInt globalevent)
 
   234     {
 
   310     {
 
   235     TRACE_PRN_FN_ENT;
 
   311     TRACE_PRN_FN_ENT;
 
   236     iMsgBuffer.iRequest = ECmdGlobalEffectChange;
 
       
   237     iMsgBuffer.iStatus = KErrNone;
 
       
   238     iMsgBuffer.iInt = globalevent;
 
   312     iMsgBuffer.iInt = globalevent;
 
   239     NotifyClient();
 
   313     NotifyClient(ECmdGlobalEffectChange);
 
   240     TRACE_PRN_FN_EXT;
 
   314     TRACE_PRN_FN_EXT;
 
   241     }
 
   315     }
 
   242 
   316 
   243 // -----------------------------------------------------------------------------
 
   317 // -----------------------------------------------------------------------------
 
   244 // TMSServerSession::HandleRoutingChange
 
   318 // TMSServerSession::HandleRoutingChange
 
   245 // -----------------------------------------------------------------------------
 
   319 // -----------------------------------------------------------------------------
 
   246 //
 
   320 //
 
   247 void TMSServerSession::HandleRoutingChange(TRoutingMsgBufPckg routinginfo)
 
   321 void TMSServerSession::HandleRoutingChange(TRoutingMsgBufPckg routinginfo)
 
   248     {
 
   322     {
 
   249     TRACE_PRN_FN_ENT;
 
   323     TRACE_PRN_FN_ENT;
 
   250     iMsgBuffer.iRequest = ECmdGlobalRoutingChange;
 
       
   251     iMsgBuffer.iStatus = KErrNone;
 
       
   252     iMsgBuffer.iInt = routinginfo().iEvent;
 
   324     iMsgBuffer.iInt = routinginfo().iEvent;
 
   253     iMsgBuffer.iUint = routinginfo().iOutput;
 
   325     iMsgBuffer.iUint = routinginfo().iOutput;
 
   254     NotifyClient();
 
   326     NotifyClient(ECmdGlobalRoutingChange);
 
   255     TRACE_PRN_FN_EXT;
 
   327     TRACE_PRN_FN_EXT;
 
   256     }
 
   328     }
 
   257 
   329 
   258 // -----------------------------------------------------------------------------
 
   330 // -----------------------------------------------------------------------------
 
   259 // TMSServerSession::GetTMSCallSessionHandleL
 
   331 // TMSServerSession::GetTMSCallSessionHandleL
 
   278 // -----------------------------------------------------------------------------
 
   350 // -----------------------------------------------------------------------------
 
   279 //
 
   351 //
 
   280 void TMSServerSession::GetCodecsCountL(const RMessage2& aMessage,
 
   352 void TMSServerSession::GetCodecsCountL(const RMessage2& aMessage,
 
   281         TMSStreamType strmType)
 
   353         TMSStreamType strmType)
 
   282     {
 
   354     {
 
   283     TInt err = KErrNone;
 
   355     TInt err = TMS_RESULT_SUCCESS;
 
   284     TInt codecsCount = 0;
 
   356     TInt codecsCount = 0;
 
   285 
   357 
   286     RArray<TFourCC>* codecs;
 
   358     RArray<TFourCC>* codecs;
 
   287     iServer.GetSupportedCodecs(strmType, codecs);
 
   359     iServer.GetSupportedCodecs(strmType, codecs);
 
   288 
   360 
   313             else
 
   385             else
 
   314                 {
 
   386                 {
 
   315                 err = KErrNotSupported;
 
   387                 err = KErrNotSupported;
 
   316                 }
 
   388                 }
 
   317 
   389 
   318 #ifdef __WINSCW__
 
       
   319             // Support for adaptation stubs
 
       
   320             codecs->Append(KMccFourCCIdG711);
 
       
   321             codecs->Append(KMccFourCCIdG729);
 
       
   322             codecs->Append(KMccFourCCIdILBC);
 
       
   323             codecs->Append(KMccFourCCIdAMRNB);
 
       
   324 #endif
 
       
   325             codecsCount = codecs->Count();
 
   390             codecsCount = codecs->Count();
 
   326             }
 
   391             }
 
   327 
   392 
   328         delete iDevSound;
 
   393         delete iDevSound;
 
   329         iDevSound = NULL;
 
   394         iDevSound = NULL;
 
   337 #else
 
   402 #else
 
   338     p().iUint = KTMSG711FrameLen20ms;
 
   403     p().iUint = KTMSG711FrameLen20ms;
 
   339 #endif //__WINSCW__
 
   404 #endif //__WINSCW__
 
   340     p().iStatus = err;
 
   405     p().iStatus = err;
 
   341     aMessage.WriteL(0, p);
 
   406     aMessage.WriteL(0, p);
 
   342     aMessage.Complete(KErrNone);
 
   407     aMessage.Complete(TMS_RESULT_SUCCESS);
 
   343     }
 
   408     }
 
   344 
   409 
   345 // -----------------------------------------------------------------------------
 
   410 // -----------------------------------------------------------------------------
 
   346 // TMSServerSession::GetSupportedEncodersL
 
   411 // TMSServerSession::GetSupportedEncodersL
 
   347 //
 
   412 //
 
   371         }
 
   436         }
 
   372 
   437 
   373     aMessage.WriteL(0, dataCopyBuffer->Ptr(0));
 
   438     aMessage.WriteL(0, dataCopyBuffer->Ptr(0));
 
   374     CleanupStack::PopAndDestroy(&stream);
 
   439     CleanupStack::PopAndDestroy(&stream);
 
   375     CleanupStack::PopAndDestroy(dataCopyBuffer);
 
   440     CleanupStack::PopAndDestroy(dataCopyBuffer);
 
   376     aMessage.Complete(KErrNone);
 
   441     aMessage.Complete(TMS_RESULT_SUCCESS);
 
   377 
   442 
   378     TRACE_PRN_FN_EXT;
 
   443     TRACE_PRN_FN_EXT;
 
   379     }
 
   444     }
 
   380 
   445 
   381 // -----------------------------------------------------------------------------
 
   446 // -----------------------------------------------------------------------------
 
   384 //
 
   449 //
 
   385 void TMSServerSession::SetOutput(const RMessage2& aMessage)
 
   450 void TMSServerSession::SetOutput(const RMessage2& aMessage)
 
   386     {
 
   451     {
 
   387     TInt output = aMessage.Int0();
 
   452     TInt output = aMessage.Int0();
 
   388     iServer.SetOutput(this, output);
 
   453     iServer.SetOutput(this, output);
 
   389     aMessage.Complete(KErrNone);
 
   454     aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   455     }
 
       
   456 
       
   457 // -----------------------------------------------------------------------------
 
       
   458 // TMSServerSession::StartInbandTone
 
       
   459 //
 
       
   460 // -----------------------------------------------------------------------------
 
       
   461 //
 
       
   462 void TMSServerSession::StartInbandTone(const RMessage2& aMessage)
 
       
   463     {
 
       
   464     if (!iInbandTonePlayer)
 
       
   465         {
 
       
   466         //TODO: Add inband tone observer
 
       
   467         iInbandTonePlayer = TMSAudioInbandTonePlayer::NewL();
 
       
   468         }
 
       
   469 
       
   470     if (iInbandTonePlayer)
 
       
   471         {
 
       
   472         TMSInbandToneType tonetype = (TMSInbandToneType) aMessage.Int0();
 
       
   473         iInbandTonePlayer->PlayInbandTone(tonetype);
 
       
   474         }
 
       
   475 
       
   476     //TODO: Move to inband tone observer callback
 
       
   477     NotifyClient(ECmdInbandToneStarted);
 
       
   478     aMessage.Complete(TMS_RESULT_SUCCESS);
 
       
   479     }
 
       
   480 
       
   481 // -----------------------------------------------------------------------------
 
       
   482 // TMSServerSession::StopInbandTone
 
       
   483 //
 
       
   484 // -----------------------------------------------------------------------------
 
       
   485 //
 
       
   486 void TMSServerSession::StopInbandTone(const RMessage2& aMessage)
 
       
   487     {
 
       
   488     if (iInbandTonePlayer)
 
       
   489         {
 
       
   490         iInbandTonePlayer->Cancel();
 
       
   491         }
 
       
   492 
       
   493     //TODO: Move to inband tone observer callback
 
       
   494     NotifyClient(ECmdInbandToneStopped);
 
       
   495     aMessage.Complete(TMS_RESULT_SUCCESS);
 
   390     }
 
   496     }
 
   391 
   497 
   392 // -----------------------------------------------------------------------------
 
   498 // -----------------------------------------------------------------------------
 
   393 // TMSServerSession::NotifyClient
 
   499 // TMSServerSession::NotifyClient
 
   394 // -----------------------------------------------------------------------------
 
   500 // -----------------------------------------------------------------------------
 
   395 //
 
   501 //
 
   396 void TMSServerSession::NotifyClient()
 
   502 void TMSServerSession::NotifyClient(const TInt aCommand, const TInt aStatus)
 
   397     {
 
   503     {
 
       
   504     if (aCommand == ECmdRingToneOpenComplete ||
 
       
   505             aCommand == ECmdRingToneOpenComplete)
 
       
   506         {
 
       
   507         if (!iHasRtPlayer)
 
       
   508             {
 
       
   509             return;
 
       
   510             }
 
       
   511         }
 
       
   512 
       
   513     iMsgBuffer.iRequest = aCommand;
 
       
   514     iMsgBuffer.iStatus = aStatus;
 
   398     if (iMsgQueue.Handle() > 0)
 
   515     if (iMsgQueue.Handle() > 0)
 
   399         {
 
   516         {
 
   400         iMsgQueue.Send(iMsgBuffer);
 
   517         iMsgQueue.Send(iMsgBuffer);
 
   401         }
 
   518         }
 
   402     }
 
   519     }
FCL/sf/mw/mmmw