Symaptic: os/mm/devsoundextensions/drmaudioplayer/DRMPlayUtility/src/drmaudioplayeradaptation.cpp@bde4ae8d615e

     1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   DRM PlayUtility

    15 *

    16 */

    18 #include <e32std.h>

    19 #include <mmf/common/mmfcontrollerframework.h>

    20 #include <mmfaudio.h> // MAudioLoadingObserver

    21 #include <AudioOutputMessageTypes.h>

    22 #include "drmaudioplayeradaptation.h"

    24 // This is the UID defined by custom interface builder

    25 const TUid KUidCustomInterfaceBuilderImpl = {0x10207A8E};

    27 // -----------------------------------------------------------------------------

    28 //

    29 //

    30 // -----------------------------------------------------------------------------

    31 //

    32 CDrmAudioPlayerAdaptation* CDrmAudioPlayerAdaptation::NewL( MDrmAudioPlayerCallback& aCallback,

    33                                                             TInt aPriority,

    34                                                             TMdaPriorityPreference aPref )

    35     {

    36     CDrmAudioPlayerAdaptation* self = new(ELeave) CDrmAudioPlayerAdaptation( aCallback );

    37     CleanupStack::PushL(self);

    38     self->ConstructL( aPriority, aPref );

    39     CleanupStack::Pop(self);

    40     return self;

    41     }

    43 // -----------------------------------------------------------------------------

    44 //

    45 //

    46 // -----------------------------------------------------------------------------

    47 //

    48 CDrmAudioPlayerAdaptation::CDrmAudioPlayerAdaptation(MDrmAudioPlayerCallback& aCallback)

    49     :iCallback(&aCallback)

    50     {}

    53 // -----------------------------------------------------------------------------

    54 //

    55 //

    56 // -----------------------------------------------------------------------------

    57 //

    58 void CDrmAudioPlayerAdaptation::ConstructL( TInt aPriority, TMdaPriorityPreference aPref )

    59     {

    61     if( iMdaPlayUtil )

    62         {

    63         delete iMdaPlayUtil;

    64         iMdaPlayUtil = NULL;

    65         }

    67     iMdaPlayUtil = CMdaAudioPlayerUtility::NewL( *this,

    68                                                  aPriority,

    69                                                  aPref);

    70     }

    73 // -----------------------------------------------------------------------------

    74 //

    75 //

    76 // -----------------------------------------------------------------------------

    77 //

    78 CDrmAudioPlayerAdaptation::~CDrmAudioPlayerAdaptation()

    79     {

    81     // Delete DMA play utility

    82     if( iMdaPlayUtil )

    83         iMdaPlayUtil->Close();

    84     delete iMdaPlayUtil;

    85     }

    88 // -----------------------------------------------------------------------------

    89 //

    90 //

    91 // -----------------------------------------------------------------------------

    92 //

    93 CDrmAudioPlayerAdaptation* CDrmAudioPlayerAdaptation::NewFilePlayerL( const TDesC& aFileName,

    94                                                 MDrmAudioPlayerCallback& aCallback,

    95                                                 TInt aPriority,

    96                                                 TMdaPriorityPreference aPref)

    97     {

    99     CDrmAudioPlayerAdaptation* self = new(ELeave) CDrmAudioPlayerAdaptation( aCallback );

   100     CleanupStack::PushL(self);

   101     self->ConstructNewFilePlayerL( aFileName, aPriority, aPref );

   102     CleanupStack::Pop(self);

   104     return self;

   105     }

   107 // -----------------------------------------------------------------------------

   108 //

   109 //

   110 // -----------------------------------------------------------------------------

   111 //

   112 void CDrmAudioPlayerAdaptation::ConstructNewFilePlayerL( const TDesC& aFileName,

   113                                                             TInt aPriority,

   114                                                             TMdaPriorityPreference aPref )

   115     {

   117     if( iMdaPlayUtil )

   118         {

   119         delete iMdaPlayUtil;

   120         iMdaPlayUtil = NULL;

   121         }

   122     iMdaPlayUtil = CMdaAudioPlayerUtility::NewFilePlayerL( aFileName,

   123                                                                    *this,

   124                                                                    aPriority,

   125                                                                    aPref);

   126     }

   129 // -----------------------------------------------------------------------------

   130 //

   131 //

   132 // -----------------------------------------------------------------------------

   133 //

   134 CDrmAudioPlayerAdaptation* CDrmAudioPlayerAdaptation::NewDesPlayerL( const TDesC8& aData,

   135                                                 MDrmAudioPlayerCallback& aCallback,

   136                                                 TInt aPriority,

   137                                                 TMdaPriorityPreference aPref)

   138     {

   140     CDrmAudioPlayerAdaptation* self = new(ELeave) CDrmAudioPlayerAdaptation( aCallback );

   141     CleanupStack::PushL(self);

   142     self->ConstructNewDesPlayerL( aData, aPriority, aPref );

   143     CleanupStack::Pop(self);

   145     return self;

   146     }

   149 // -----------------------------------------------------------------------------

   150 //

   151 //

   152 // -----------------------------------------------------------------------------

   153 //

   154 void CDrmAudioPlayerAdaptation::ConstructNewDesPlayerL( const TDesC8& aData,

   155                                                         TInt aPriority,

   156                                                         TMdaPriorityPreference aPref )

   157     {

   159     if( iMdaPlayUtil )

   160         {

   161         delete iMdaPlayUtil;

   162         iMdaPlayUtil = NULL;

   163         }

   164     iMdaPlayUtil = CMdaAudioPlayerUtility::NewDesPlayerL( aData,

   165                                                           *this,

   166                                                           aPriority,

   167                                                           aPref);

   168     }

   171 // -----------------------------------------------------------------------------

   172 //

   173 //

   174 // -----------------------------------------------------------------------------

   175 //

   176 CDrmAudioPlayerAdaptation* CDrmAudioPlayerAdaptation::NewDesPlayerReadOnlyL( const TDesC8& aData,

   177                                                         MDrmAudioPlayerCallback& aCallback,

   178                                                         TInt aPriority,

   179                                                         TMdaPriorityPreference aPref)

   180     {

   182     CDrmAudioPlayerAdaptation* self = new(ELeave) CDrmAudioPlayerAdaptation( aCallback );

   183     CleanupStack::PushL(self);

   184     self->ConstructNewDesPlayerReadOnlyL( aData, aPriority, aPref );

   185     CleanupStack::Pop(self);

   187     return self;

   188     }

   191 // -----------------------------------------------------------------------------

   192 //

   193 //

   194 // -----------------------------------------------------------------------------

   195 //

   196 void CDrmAudioPlayerAdaptation::ConstructNewDesPlayerReadOnlyL( const TDesC8& aData,

   197                                                         TInt aPriority,

   198                                                         TMdaPriorityPreference aPref )

   199     {

   201     delete this->iMdaPlayUtil;

   202     this->iMdaPlayUtil = NULL;

   203     this->iMdaPlayUtil = CMdaAudioPlayerUtility::NewDesPlayerReadOnlyL( aData,

   204                                                                   *this,

   205                                                                   aPriority,

   206                                                                   aPref);

   207     }

   210 // -----------------------------------------------------------------------------

   211 //

   212 //

   213 // -----------------------------------------------------------------------------

   214 //

   215 void CDrmAudioPlayerAdaptation::OpenFileL(const TDesC &aFileName)

   216     {

   217     iMdaPlayUtil->OpenFileL( aFileName );

   218     }

   221 // -----------------------------------------------------------------------------

   222 //

   223 //

   224 // -----------------------------------------------------------------------------

   225 //

   226 void CDrmAudioPlayerAdaptation::OpenFileL(const RFile& aFile)

   227     {

   228     iMdaPlayUtil->OpenFileL( aFile );

   229     }

   232 // -----------------------------------------------------------------------------

   233 //

   234 //

   235 // -----------------------------------------------------------------------------

   236 //

   237 void CDrmAudioPlayerAdaptation::OpenFileL(const TMMSource& aSource)

   238     {

   239     iMdaPlayUtil->OpenFileL( aSource );

   240     }

   243 // -----------------------------------------------------------------------------

   244 //

   245 //

   246 // -----------------------------------------------------------------------------

   247 //

   248 void CDrmAudioPlayerAdaptation::OpenDesL(const TDesC8& aDes)

   249     {

   250     iMdaPlayUtil->OpenDesL(aDes);

   251     }

   254 // -----------------------------------------------------------------------------

   255 //

   256 //

   257 // -----------------------------------------------------------------------------

   258 //

   259 void CDrmAudioPlayerAdaptation::OpenUrlL( const TDesC& aUrl, TInt aIapId, const TDesC8& aMimeType )

   260     {

   261     iMdaPlayUtil->OpenUrlL( aUrl, aIapId, aMimeType);

   262     }

   265 // -----------------------------------------------------------------------------

   266 //

   267 //

   268 // -----------------------------------------------------------------------------

   269 //

   270 void CDrmAudioPlayerAdaptation::Play()

   271     {

   272     iMdaPlayUtil->Play();

   273     }

   276 // -----------------------------------------------------------------------------

   277 //

   278 //

   279 // -----------------------------------------------------------------------------

   280 //

   281 void CDrmAudioPlayerAdaptation::Stop()

   282     {

   283     iMdaPlayUtil->Stop();

   284     }

   286 // -----------------------------------------------------------------------------

   287 //

   288 //

   289 // -----------------------------------------------------------------------------

   290 //

   291 void CDrmAudioPlayerAdaptation::SetVolume( const TInt aVolume )

   292     {

   293     iMdaPlayUtil->SetVolume( aVolume );

   294     }

   297 // -----------------------------------------------------------------------------

   298 //

   299 //

   300 // -----------------------------------------------------------------------------

   301 //

   302 void CDrmAudioPlayerAdaptation::SetRepeats( TInt aRepeatNumberOfTimes,

   303                                             const TTimeIntervalMicroSeconds& aTrailingSilence )

   304     {

   305     iMdaPlayUtil->SetRepeats( aRepeatNumberOfTimes, aTrailingSilence );

   306     }

   309 // -----------------------------------------------------------------------------

   310 //

   311 //

   312 // -----------------------------------------------------------------------------

   313 //

   314 void CDrmAudioPlayerAdaptation::SetVolumeRamp( const TTimeIntervalMicroSeconds& aRampDuration )

   315     {

   316     iMdaPlayUtil->SetVolumeRamp( aRampDuration );

   317     }

   320 // -----------------------------------------------------------------------------

   321 //

   322 //

   323 // -----------------------------------------------------------------------------

   324 //

   325 const TTimeIntervalMicroSeconds& CDrmAudioPlayerAdaptation::Duration()

   326     {

   327     return iMdaPlayUtil->Duration();

   328     }

   331 // -----------------------------------------------------------------------------

   332 //

   333 //

   334 // -----------------------------------------------------------------------------

   335 //

   336 TInt CDrmAudioPlayerAdaptation::MaxVolume()

   337     {

   338     return iMdaPlayUtil->MaxVolume();

   339     }

   342 // API Additions since version 7.0

   344 // -----------------------------------------------------------------------------

   345 //

   346 //

   347 // -----------------------------------------------------------------------------

   348 //

   349 TInt CDrmAudioPlayerAdaptation::Pause()

   350     {

   351     return iMdaPlayUtil->Pause();

   352     }

   355 // -----------------------------------------------------------------------------

   356 //

   357 //

   358 // -----------------------------------------------------------------------------

   359 //

   360 void CDrmAudioPlayerAdaptation::Close()

   361     {

   362     iMdaPlayUtil->Close();

   363     }

   366 // -----------------------------------------------------------------------------

   367 //

   368 //

   369 // -----------------------------------------------------------------------------

   370 //

   371 TInt CDrmAudioPlayerAdaptation::GetPosition(TTimeIntervalMicroSeconds& aPosition)

   372     {

   373     return iMdaPlayUtil->GetPosition(aPosition);

   374     }

   377 // -----------------------------------------------------------------------------

   378 //

   379 //

   380 // -----------------------------------------------------------------------------

   381 //

   382 void CDrmAudioPlayerAdaptation::SetPosition( const TTimeIntervalMicroSeconds& aPosition )

   383     {

   384     iMdaPlayUtil->SetPosition(aPosition);

   385     }

   388 // -----------------------------------------------------------------------------

   389 //

   390 //

   391 // -----------------------------------------------------------------------------

   392 //

   393 TInt CDrmAudioPlayerAdaptation::SetPriority( TInt aPriority, TMdaPriorityPreference aPref )

   394     {

   395     return iMdaPlayUtil->SetPriority( aPriority, aPref );

   396     }

   399 // -----------------------------------------------------------------------------

   400 //

   401 //

   402 // -----------------------------------------------------------------------------

   403 //

   404 TInt CDrmAudioPlayerAdaptation::GetVolume(TInt& aVolume)

   405     {

   406     return iMdaPlayUtil->GetVolume(aVolume);

   407     }

   410 // -----------------------------------------------------------------------------

   411 //

   412 //

   413 // -----------------------------------------------------------------------------

   414 //

   415 TInt CDrmAudioPlayerAdaptation::GetNumberOfMetaDataEntries( TInt& aNumEntries )

   416     {

   417     return iMdaPlayUtil->GetNumberOfMetaDataEntries( aNumEntries);

   418     }

   421 // -----------------------------------------------------------------------------

   422 //

   423 //

   424 // -----------------------------------------------------------------------------

   425 //

   426 CMMFMetaDataEntry* CDrmAudioPlayerAdaptation::GetMetaDataEntryL( const TInt aMetaDataIndex )

   427     {

   428     return iMdaPlayUtil->GetMetaDataEntryL(aMetaDataIndex);

   429     }

   432 // -----------------------------------------------------------------------------

   433 //

   434 //

   435 // -----------------------------------------------------------------------------

   436 //

   437 TInt CDrmAudioPlayerAdaptation::SetPlayWindow(const TTimeIntervalMicroSeconds& aStart,

   438                                                 const TTimeIntervalMicroSeconds& aEnd)

   439     {

   440     return iMdaPlayUtil->SetPlayWindow(aStart,aEnd);

   441     }

   444 // -----------------------------------------------------------------------------

   445 //

   446 //

   447 // -----------------------------------------------------------------------------

   448 //

   449 TInt CDrmAudioPlayerAdaptation::ClearPlayWindow()

   450     {

   451     return iMdaPlayUtil->ClearPlayWindow();

   452     }

   455 // -----------------------------------------------------------------------------

   456 //

   457 //

   458 // -----------------------------------------------------------------------------

   459 //

   460 TInt CDrmAudioPlayerAdaptation::SetBalance( const TInt aBalance )

   461     {

   462     return iMdaPlayUtil->SetBalance(aBalance);

   463     }

   466 // -----------------------------------------------------------------------------

   467 //

   468 //

   469 // -----------------------------------------------------------------------------

   470 //

   471 TInt CDrmAudioPlayerAdaptation::GetBalance(TInt& aBalance)

   472     {

   473     return iMdaPlayUtil->GetBalance(aBalance);

   474     }

   477 // -----------------------------------------------------------------------------

   478 //

   479 //

   480 // -----------------------------------------------------------------------------

   481 //

   482 TInt CDrmAudioPlayerAdaptation::GetBitRate(TUint& aBitRate)

   483     {

   484     return iMdaPlayUtil->GetBitRate(aBitRate);

   485     }

   488 // -----------------------------------------------------------------------------

   489 //

   490 //

   491 // -----------------------------------------------------------------------------

   492 //

   493 void CDrmAudioPlayerAdaptation::RegisterForAudioLoadingNotification(MAudioLoadingObserver& aCallback)

   494     {

   495     iMdaPlayUtil->RegisterForAudioLoadingNotification(aCallback);

   496     }

   499 // -----------------------------------------------------------------------------

   500 //

   501 //

   502 // -----------------------------------------------------------------------------

   503 //

   504 void CDrmAudioPlayerAdaptation::GetAudioLoadingProgressL( TInt& aPercentageProgress )

   505     {

   506     iMdaPlayUtil->GetAudioLoadingProgressL(aPercentageProgress);

   507     }

   510 // -----------------------------------------------------------------------------

   511 //

   512 //

   513 // -----------------------------------------------------------------------------

   514 //

   515 const CMMFControllerImplementationInformation& CDrmAudioPlayerAdaptation::ControllerImplementationInformationL()

   516     {

   517     return iMdaPlayUtil->ControllerImplementationInformationL();

   518     }

   521 // -----------------------------------------------------------------------------

   522 //

   523 //

   524 // -----------------------------------------------------------------------------

   525 //

   526 TInt CDrmAudioPlayerAdaptation::CustomCommandSync(const TMMFMessageDestinationPckg& aDestination,

   527                         TInt aFunction,

   528                         const TDesC8& aDataTo1,

   529                         const TDesC8& aDataTo2,

   530                         TDes8& aDataFrom)

   531     {

   532     return iMdaPlayUtil->CustomCommandSync( aDestination,

   533                                             aFunction,

   534                                             aDataTo1,

   535                                             aDataTo2,

   536                                             aDataFrom );

   538     }

   541 // -----------------------------------------------------------------------------

   542 //

   543 //

   544 // -----------------------------------------------------------------------------

   545 //

   546 TInt CDrmAudioPlayerAdaptation::CustomCommandSync(  const TMMFMessageDestinationPckg& aDestination,

   547                                                     TInt aFunction,

   548                                                     const TDesC8& aDataTo1,

   549                                                     const TDesC8& aDataTo2 )

   550     {

   551     return iMdaPlayUtil->CustomCommandSync( aDestination,

   552                                             aFunction,

   553                                             aDataTo1,

   554                                             aDataTo2 );

   556     }

   559 // -----------------------------------------------------------------------------

   560 //

   561 //

   562 // -----------------------------------------------------------------------------

   563 //

   564 void CDrmAudioPlayerAdaptation::CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination,

   565                                                    TInt aFunction,

   566                                                    const TDesC8& aDataTo1,

   567                                                    const TDesC8& aDataTo2,

   568                                                    TDes8& aDataFrom,

   569                                                    TRequestStatus& aStatus)

   570     {

   571     iMdaPlayUtil->CustomCommandAsync( aDestination,

   572                                         aFunction,

   573                                         aDataTo1,

   574                                         aDataTo2,

   575                                         aDataFrom,

   576                                         aStatus);

   578     }

   581 // -----------------------------------------------------------------------------

   582 //

   583 //

   584 // -----------------------------------------------------------------------------

   585 //

   586 void CDrmAudioPlayerAdaptation::CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination,

   587                                                    TInt aFunction,

   588                                                    const TDesC8& aDataTo1,

   589                                                    const TDesC8& aDataTo2,

   590                                                    TRequestStatus& aStatus)

   591     {

   592     iMdaPlayUtil->CustomCommandAsync( aDestination,

   593                                         aFunction,

   594                                         aDataTo1,

   595                                         aDataTo2,

   596                                         aStatus);

   597     }

   600 // -----------------------------------------------------------------------------

   601 //

   602 //

   603 // -----------------------------------------------------------------------------

   604 //

   605 TBool CDrmAudioPlayerAdaptation::IsValidCustomCommandDestination(TUid aDestinationUid, TDesC8& aParam)

   606     {

   607     TBool retValue(ETrue);

   609     if( aDestinationUid == KUidInterfaceMMFDRMControl)

   610         {

   611         retValue = EFalse;

   612         }

   613     else if( aDestinationUid == KUidCustomInterfaceBuilderImpl )

   614         {

   615         TRAPD(err, retValue = CheckCustomInterfaceBuilderImplL(aParam));

   616         if(err != KErrNone)

   617             {

   618             retValue = EFalse;

   619             }

   620         }

   621     return retValue;

   622     }

   623 TBool CDrmAudioPlayerAdaptation::CheckCustomInterfaceBuilderImplL(const TDesC8& aParam)

   624     {

   625     TBool retValue(ETrue);

   626     RDesReadStream stream(aParam);

   627     CleanupClosePushL(stream);

   628     TUid paramUid;

   629     paramUid.iUid = stream.ReadInt32L();

   630     CleanupStack::PopAndDestroy(&stream);

   631     if ( paramUid == KUidAudioOutput )

   632         {

   633         retValue = EFalse;

   634         }

   635     return retValue;

   636     }

   639 // -----------------------------------------------------------------------------

   640 //

   641 //

   642 // -----------------------------------------------------------------------------

   643 //

   644 void CDrmAudioPlayerAdaptation::MapcInitComplete( TInt aError, const TTimeIntervalMicroSeconds& aDuration )

   645     {

   646     iCallback->MdapcInitComplete( aError, aDuration );

   647     }

   650 // -----------------------------------------------------------------------------

   651 //

   652 //

   653 // -----------------------------------------------------------------------------

   654 //

   655 void CDrmAudioPlayerAdaptation::MapcPlayComplete( TInt aError )

   656     {

   657     iCallback->MdapcPlayComplete( aError );

   658     }

   660 // End of File

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--