1 /*

     2 * Copyright (c) 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:  Implementation of ProgDLSource.

    15 *

    16 */

    17 

    18 

    19 #include <f32file.h>

    20 #include <e32std.h>

    21 #include <mmfdatabuffer.h>

    22 #include <mmfutilities.h>

    23 #include <mmf/common/mmfcontroller.h>

    24 #include <mmfpaniccodes.h>

    25 #include "ProgDLDataSource.h"

    26 #include "ProgDLMultimediaSource.h"

    27 #include "MmffilePriv.h"

    28 #include "FileAccess.h"

    29 #include "SinkQueueItem.h"

    30 #include "ProgDLSourceCustomCommands.h"

    31 #include <MultimediaDataSourceEvents.h>

    32 #include "ProgDLSourceUid.h"

    33 #include "AudioConfigurationPrivateCRKeys.h"

    34 

    35 #ifdef _DEBUG

    36 #define DEBPRN1(str)        RDebug::Print(str);

    37 #define DEBPRN2(str, val1)   RDebug::Print(str, val1);

    38 #define DEBPRN3(str, val1, val2)   RDebug::Print(str, val1, val2);

    39 #define DEBPRN4(str, val1, val2, val3)   RDebug::Print(str, val1, val2, val3);

    40 #define DEBPRN5(str, val1, val2, val3, val4)   RDebug::Print(str, val1, val2, val3, val4);

    41 #else

    42 #define DEBPRN1(str)

    43 #define DEBPRN2(str, val1)

    44 #define DEBPRN3(str, val1, val2)

    45 #define DEBPRN4(str, val1, val2, val3)

    46 #define DEBPRN5(str, val1, val2, val3, val4)

    47 #endif // _DEBUG

    48 

    49 const TUint KMinPlaybackDuration = 15; // 15 second

    50 

    51 void Panic(TMMFFilePanicCode aPanicCode)

    52     {

    53     _LIT(KMMFFilePanicCategory, "MMFFile");

    54     User::Panic(KMMFFilePanicCategory, aPanicCode);

    55     }

    56 

    57     /**

    58     * Constructs a CTransferBufferCopy

    59     *

    60     * @return CTransferBufferCopy*

    61 */

    62 CTransferBufferCopy* CTransferBufferCopy::NewL(TInt aMaxLength)

    63     {

    64     CTransferBufferCopy* self = new (ELeave) CTransferBufferCopy(aMaxLength);

    65     CleanupStack::PushL(self);

    66     self->ConstructL();

    67     CleanupStack::Pop(self);

    68     return self;

    69     }

    70 

    71     /**

    72     * Second phase constructor for CTransferBufferCopy

    73     *

    74     * @return void

    75 */

    76 void CTransferBufferCopy::ConstructL()

    77     {

    78     iBuffer = static_cast<TUint8*>(User::AllocL(iMaxLength));

    79     iBufferDes.Set(iBuffer,0,iMaxLength);

    80     }

    81 

    82 /************************/

    83 CProgDLSource* CProgDLSource::NewL(TUid aType )

    84     {

    85     DEBPRN1(_L("CProgDLSource::NewL"));

    86     CProgDLSource* self = new (ELeave) CProgDLSource(aType);

    87     CleanupStack::PushL(self);

    88     self->ConstructL();

    89     CleanupStack::Pop(self);

    90     return self;

    91     }

    92 

    93 CProgDLSource::CProgDLSource(TUid aType)

    94 : MDataSource(aType)

    95     {

    96     iInitData = NULL;

    97     }

    98 

    99 CProgDLSource::~CProgDLSource(void)

   100     {

   101     delete iInitData;

   102     iInitData = NULL;        

   103     }

   104 

   105 void CProgDLSource::ConstructL (void)

   106     {

   107     }

   108 

   109 // From MDataSource begins

   110 TUid CProgDLSource::DataSourceType() const

   111     {

   112     return KMmfProgDLSource;

   113     }

   114 

   115 

   116 TFourCC CProgDLSource::SourceDataTypeCode(TMediaId /*aMediaId*/ )

   117     {

   118     TFourCC fourCC;        

   119     return iMultiMediaSource->GetDataTypeCode(fourCC);

   120     }

   121 

   122 TInt CProgDLSource::SetSourceDataTypeCode(TFourCC aSourceFourCC,

   123                                                   TMediaId /*aMediaId*/ )

   124     {

   125     iMultiMediaSource->SetDataTypeCode(aSourceFourCC);

   126     return KErrNone;

   127     }

   128 

   129 void CProgDLSource::FillBufferL(CMMFBuffer* aBuffer,

   130                                         MDataSink* aConsumer,

   131                                         TMediaId aMediaId )

   132     {

   133     iMultiMediaSource->FillBufferL(aBuffer,aConsumer,aMediaId);

   134     }

   135 

   136 void CProgDLSource::BufferEmptiedL(CMMFBuffer* /*aBuffer*/ )

   137     {

   138     User::Leave(KErrUnknown);

   139     }

   140 

   141 TBool CProgDLSource::CanCreateSourceBuffer()

   142     {

   143     return EFalse;

   144     }

   145 

   146 CMMFBuffer* CProgDLSource::CreateSourceBufferL(TMediaId /*aMediaId*/,

   147                                                        TBool &/*aReference*/ )

   148     {

   149     return NULL;

   150     }

   151 

   152 TInt CProgDLSource::SourceThreadLogon( MAsyncEventHandler& /*aEventHandler*/ )

   153     {

   154     return iMultiMediaSource->Open();

   155     }

   156 

   157 void CProgDLSource::SourceThreadLogoff()

   158     {

   159     iMultiMediaSource->Close();

   160     }

   161 

   162 void CProgDLSource::SourcePrimeL()

   163     {

   164     DEBPRN1(_L("CProgDLSource::SourcePrimeL"));

   165     User::LeaveIfError(iMultiMediaSource->Prime());

   166     }

   167 

   168 void CProgDLSource::SourcePlayL()

   169     {

   170     DEBPRN1(_L("CProgDLSource::SourcePlayL"));

   171     User::LeaveIfError(iMultiMediaSource->Play());

   172     }

   173 

   174 void CProgDLSource::SourceStopL()

   175     {

   176     DEBPRN1(_L("CProgDLSource::SourceStopL"));

   177     User::LeaveIfError(iMultiMediaSource->Stop());

   178     }

   179 

   180 

   181 void CProgDLSource::ConstructSourceL(const TDesC8& aInitData )

   182     {

   183     if(iInitData)

   184         {

   185         delete iInitData;

   186         iInitData = NULL;        

   187         }

   188     iInitData = aInitData.AllocL();        

   189     }

   190 

   191 void CProgDLSource::SourceCustomCommand(TMMFMessage& aMessage)

   192     {

   193     iMultiMediaSource->SourceCustomCommand(aMessage);        

   194     }

   195 

   196 void CProgDLSource::SetMultimediaSource(CProgDLMultimediaSource& aMultimediaSource)

   197     {

   198     iMultiMediaSource = &aMultimediaSource;   

   199     }

   200 

   201 TDesC8& CProgDLSource::GetInitData()

   202     {

   203     return *iInitData;    

   204     }

   205 /****************************/

   206 

   207 

   208 EXPORT_C CProgDLMultimediaSource* CProgDLMultimediaSource::NewL(MDataSource& aDataSource)

   209     {

   210     DEBPRN1(_L("CProgDLMultimediaSource::NewL"));

   211     CProgDLMultimediaSource* self = new (ELeave) CProgDLMultimediaSource(aDataSource);

   212     CleanupStack::PushL(self);

   213     self->ConstructL();

   214     CleanupStack::Pop(self);

   215     return self;

   216     }

   217 

   218     /**

   219     Destructor.

   220 */

   221 CProgDLMultimediaSource::~CProgDLMultimediaSource() 

   222     {

   223     DEBPRN1(_L("CProgDLMultimediaSource::~CProgDLMultimediaSource() "));    

   224     delete iInitData;

   225     delete iFile;

   226     EmptySinkQueue();

   227     iHandle.Close();

   228     iFsSession.Close();

   229     delete iFileName;

   230     delete iFileExt;

   231     delete iFilePath;

   232     delete iFileDrive;

   233     

   234     

   235     delete iCAFParameters;

   236     delete iSinkQueue;

   237     delete iAudioConfigRepository;

   238     

   239     if(iMessage)

   240         {

   241         if(!iMessage->IsCompleted())

   242             {

   243             iMessage->Complete(KErrDied);

   244             delete iMessage;

   245             iMessage = NULL;

   246             }

   247         }

   248     // Get rid of everything in RArray's & close them.

   249     iRequests.ResetAndDestroy();

   250     iTransferBufferCopies.ResetAndDestroy();

   251     DEBPRN1(_L("CProgDLMultimediaSource::~CProgDLMultimediaSource() exit"));   

   252     }

   253 

   254     /**

   255     Protected constructor.

   256     

   257       The default implementation is empty.

   258 */

   259 CProgDLMultimediaSource::CProgDLMultimediaSource(MDataSource& aDataSource)

   260                                        : iSnkItemsCount(0),

   261                                        iSnkBytes(0),

   262                                        iDownloadSize(0),

   263                                        iTransferRate(0),

   264                                        //iConsumer(NULL),

   265                                        iBufferedDataSize(0),

   266                                        iDLFileSize(0),

   267                                        isDownloadComplete(EFalse),

   268                                        iFileSize(0),

   269                                        iParentDataSource(&aDataSource)

   270     {

   271     iMessage = NULL;

   272     iFile = NULL;

   273     iState = ECLOSED;

   274     iObserver = NULL;

   275     iReadRequestPending = 0;

   276     iReOpenCAF = EFalse;

   277     iObserverBitRate = 0;

   278     }

   279 

   280     /**

   281     Constructs an CProgDLMultimediaSource MDataSource.

   282     

   283       @return A pointer to the new CProgDLMultimediaSource data source.

   284 */

   285 /*MDataSource* CProgDLMultimediaSource::NewSourceL() 

   286 {

   287 CProgDLMultimediaSource* self = new (ELeave) CProgDLMultimediaSource( KMmfProgDLSource ) ;

   288 return STATIC_CAST( MDataSource*, self ) ;

   289     }*/

   290 

   291 

   292     /**

   293     Perform source construction dependant on the source construction

   294     initialisation data aInitData.

   295     

   296       @param  aInitData

   297       The TPckg<TMMFFileParams> descriptor package containing the file name and full path.

   298 */

   299 void CProgDLMultimediaSource::ConstructL() 

   300     {

   301     CProgDLSource* progDLSource = static_cast<CProgDLSource*>(iParentDataSource);    

   302     iInitData = (progDLSource->GetInitData()).AllocL();

   303     progDLSource->SetMultimediaSource(*this);

   304     ConstructL(*iInitData, ESourceMode);

   305     iSinkQueue = new(ELeave) TSglQue<CSinkQueueItem>(_FOFF(CSinkQueueItem, iLink));

   306     }

   307 

   308 

   309     /**

   310     Protected constructor.

   311     

   312       Extracts the initialisation data provided by the calling functions: ConstructSourceL() and 

   313       ConstructSinkL(). Creates a file server session and sets up file name. If there is a file name and 

   314       it cannot be found this function leaves. If there is no file name the function leaves. Does not 

   315       attempt to open the file or check whether the file exists.

   316       

   317         If aInitData contains a TMMFFileHandleParams instead of TMMFFileParams, the source/sink is constructed from 

   318         the file handle provided by the caller

   319         

   320           @param  aInitData

   321           Initialisation data packaged in a TMMFFileParams or in a TMMFFileHandleParams (File Handle)

   322 */

   323 void CProgDLMultimediaSource::ConstructL(const TDesC8& aInitData,TMMFileMode aFileMode)

   324     {

   325     User::LeaveIfError(iFsSession.Connect());

   326     // on IPCv2 we auto attach

   327     User::LeaveIfError(iFsSession.ShareAuto());

   328     

   329     User::LeaveIfError(iFsSession.ShareProtected());

   330     

   331     TBool fileInit = EFalse;

   332     HBufC* filename = NULL; 

   333     TBool filenamePushed = EFalse;

   334     

   335     iCAFParameters = new (ELeave) CCAFParameters;

   336     TBool drmContent = EFalse;

   337     RDesReadStream stream(aInitData);

   338     CleanupClosePushL(stream);

   339 

   340     iAudioConfigRepository = CRepository::NewL(KCRUidAudioConfiguration);

   341 

   342     // From Central Repository

   343     GetAudioConfiguration();

   344     

   345     TUid initUid;

   346     

   347     initUid = TUid::Uid(stream.ReadInt32L());

   348     

   349     if (initUid == KMMFileHandleSourceUid)

   350         {

   351         TPckgBuf<RFile*> fileptr;

   352         stream.ReadL(fileptr);

   353         

   354         iHandle.Duplicate(*fileptr());

   355         

   356         TInt length;

   357         length = stream.ReadInt32L();

   358         if (length>0)

   359             {

   360             iCAFParameters->iUniqueId = HBufC::NewL(length);

   361             TPtr16 ptr = iCAFParameters->iUniqueId->Des();

   362             stream.ReadL(ptr, length);

   363             }

   364         iFileHandle = ETrue;

   365         filename = HBufC::NewMaxL(KMaxFileName);

   366         TPtr ptr = filename->Des();

   367         iHandle.Name(ptr);

   368         fileInit = ETrue;

   369         drmContent = ETrue;

   370         

   371         iCAFParameters->iEnableUI = stream.ReadInt32L();

   372         }

   373     

   374     else if (initUid == KMMFileSourceUid)

   375         {

   376         TInt length;

   377         length = stream.ReadInt32L();

   378         filename = HBufC::NewMaxLC(length);

   379         TPtr ptr = filename->Des();

   380         stream.ReadL(ptr, length);

   381         

   382         length = stream.ReadInt32L();

   383         if (length>0)

   384             {

   385             iCAFParameters->iUniqueId = HBufC::NewMaxL(length);

   386             ptr.Set(iCAFParameters->iUniqueId->Des());

   387             stream.ReadL(ptr, length);

   388             }

   389         CleanupStack::Pop(filename);

   390         

   391         fileInit = ETrue;

   392         drmContent = ETrue;

   393         iFileHandle = EFalse; 

   394         iCAFParameters->iEnableUI = stream.ReadInt32L();

   395         }

   396     else

   397         {

   398         //		TODO If the UID is unknown we should reject, but  currently

   399         //		code also used for older calls that just supply filename.

   400         //		User::Leave(KErrNotSupported);

   401         }

   402     

   403     CleanupStack::PopAndDestroy(&stream);

   404     

   405     if (!fileInit && aInitData.Length() == sizeof(TMMFFileHandleParams))

   406         {

   407         TMMFFileHandleParams params;

   408         TPckgC<TMMFFileHandleParams> config(params);

   409         config.Set(aInitData);

   410         params = config();

   411         

   412         

   413         if (params.iUid == KFileHandleUid)

   414             {

   415             fileInit = ETrue;

   416             User::LeaveIfError(iHandle.Duplicate(*params.iFile));

   417             TInt pos = 0;

   418             // make sure the duplicate handle is at the start of the file - the usage of the file handle really requires this

   419             User::LeaveIfError(iHandle.Seek(ESeekStart, pos));

   420             iFileHandle = ETrue;

   421             filename = HBufC::NewMaxLC(KMaxFileName);

   422             filenamePushed = ETrue;

   423             TPtr ptr = filename->Des();

   424             User::LeaveIfError(iHandle.Name(ptr));

   425             }

   426         }

   427     

   428     if (!fileInit) // do old case as last resort

   429         {

   430         TMMFFileParams params;

   431         TPckgC<TMMFFileParams> config(params);

   432         config.Set(aInitData);

   433         params = config();

   434         

   435         filename = params.iPath.AllocL();

   436         fileInit = ETrue;

   437         }

   438     

   439     if (!filenamePushed)

   440         {

   441         // from now on it is assumed pushed.

   442         CleanupStack::PushL(filename);

   443         }

   444     

   445     TParse parser ;

   446     User::LeaveIfError(parser.Set(*filename, NULL, NULL));

   447     CleanupStack::PopAndDestroy(filename);

   448     if ( !( parser.NamePresent() ) && !( parser.ExtPresent() ) )

   449         User::Leave( KErrBadName ) ;

   450     

   451     iFullFileName.Copy( parser.FullName() ) ;	

   452     iFileName = parser.Name().AllocL() ;

   453     iFileExt = parser.Ext().AllocL() ;

   454     iFilePath = parser.Path().AllocL() ;

   455     iFileDrive = parser.Drive().AllocL() ;

   456     

   457     // in order to simulate old behaviour we are not passing error out

   458     // but will try to create Content again during PrimeL()

   459     if (fileInit && drmContent && aFileMode==ESourceMode)

   460         {

   461         TInt contentError;

   462         if (iFileHandle)

   463             {

   464             TRAP(contentError, 

   465                 iFile = CContentFile::NewL(iHandle, UniqueId(), iCAFParameters->iEnableUI);

   466             );

   467             }

   468         else

   469             {

   470             // Open for read-only access

   471             TRAP(contentError,

   472                 iFile = CContentFile::NewL(iFsSession, iFullFileName, UniqueId(), EFileShareAny, iCAFParameters->iEnableUI);

   473             );

   474             }

   475         }

   476     }

   477     

   478     

   479 /**

   480 @deprecated

   481 

   482 Returns an RFile handle to the current file.

   483 

   484 If there is no current file, one is created. If the file exists then it is opened with read access 

   485 if it is read only, write access otherwise. If the file does not exist then it is opened with

   486 write access.

   487 

   488 @leave KErrNotReady

   489 The file is not open.

   490 

   491 @return A handle to the current file.

   492 */

   493 RFile& CProgDLMultimediaSource::FileL()

   494     {

   495     if (!iFile)

   496         User::Leave(KErrNotReady);

   497     if (iFileHandle)

   498         return iHandle;

   499     else

   500         return iFile->FileL();

   501     }

   502             

   503 /** 

   504 Returns the file name of the current file.

   505 

   506   Note: This will give the wrong answer if the file is renamed!

   507   

   508     @return The FileName (without extension).

   509 */

   510 const TDesC& CProgDLMultimediaSource::FileName() const

   511     {

   512     return *iFileName ;

   513     }

   514             

   515 /**

   516 Returns the extension of the current file.

   517 

   518 Note: This will give the wrong answer if the file is renamed!

   519 

   520 @return The File Extension.

   521 */

   522 const TDesC& CProgDLMultimediaSource::Extension() const 

   523     {

   524     return *iFileExt ;

   525     }

   526             

   527 /** 

   528 Returns the path of the current file.

   529 

   530 Note: This will give the wrong answer if the file is renamed!

   531 

   532 @return The FilePath (without filename and extension)

   533 */

   534 const TDesC& CProgDLMultimediaSource::FilePath() const 

   535     {

   536     return *iFilePath ;

   537     }

   538 

   539 /** 

   540 Returns the drive on which the current file is located.

   541 

   542 Note: This will give the wrong answer if the file is renamed!

   543 

   544 @return The FileDrive (drive letter only, without path, filename and extension).

   545 */

   546 const TDesC& CProgDLMultimediaSource::FileDrive() const 

   547     {

   548     return *iFileDrive ;

   549     }

   550 

   551 /** 

   552 Returns the full name of the current file.

   553 

   554 Note: This will give the wrong answer if the file is renamed!

   555 

   556 @return The file name (full filename including drive letter, without path, filename and extension).

   557 */

   558 const TFileName CProgDLMultimediaSource::FullName() const

   559     {

   560     return iFullFileName;

   561     }

   562             

   563 /** 

   564 Returns the uniqueID associated with this content. If no uniqueID has been provided, a null

   565 descriptor will be provided

   566 

   567 @return The UniqueID

   568 */

   569 const TDesC& CProgDLMultimediaSource::UniqueId() const

   570     {

   571     if (iCAFParameters->iUniqueId)

   572         return *(iCAFParameters->iUniqueId);

   573     else

   574         return KNullDesC;

   575     }

   576             

   577 /**

   578 Obtains a CTransferBufferCopy from iTransferBufferCopies that is

   579 at least as big as that required.

   580 

   581 There is no need to put the pointer returned by this method onto the CleanupStack

   582 as it will have already been placed into iTransferBufferCopies.

   583 

   584 @param  aMaxLength

   585 The size required.

   586 

   587 @return A pointer to a valid CTransferBufferCopy.

   588 */

   589 CTransferBufferCopy* CProgDLMultimediaSource::ObtainCopyOfTransferBufferL(TInt aMaxLength)

   590     {

   591     //find a free transfer buffer copy of the right size

   592     TInt firstFree = -1;

   593     CTransferBufferCopy* transBufCopyToUse = NULL;

   594     

   595     for(TInt cnt=0; cnt < iTransferBufferCopies.Count(); cnt++)

   596         {

   597         if(!iTransferBufferCopies[cnt]->InUse())

   598             {

   599             //record the first free entry, we may remove this

   600             //if entries in iTransferBufferCopies > KAcceptableTransferBufferCopiesSize

   601             if(firstFree == -1) 

   602                 firstFree = cnt;

   603             

   604             if(iTransferBufferCopies[cnt]->MaxLength() >= aMaxLength)

   605                 {

   606                 transBufCopyToUse = iTransferBufferCopies[cnt];

   607                 

   608                 //Set the MaxLength. This will ensure that the copy acts the same as

   609                 //the original Transfer buffer, eg. file server will throw KErrOverflow

   610                 transBufCopyToUse->ReUse(aMaxLength);

   611                 break;

   612                 }

   613             }

   614         }

   615     

   616     //If we failed to find a suitable entry, we need to create a new one

   617     if(!transBufCopyToUse)

   618         {

   619         //Firstly, should we re-cycle an existing entry?

   620         //There must be entries in the array, a free entry must have been found,

   621         //the size of the array must be beyond the water mark where we want to start

   622         //cycling free entries.

   623         if((iTransferBufferCopies.Count() > 0) &&

   624             (firstFree != -1) &&

   625             (iTransferBufferCopies.Count() > KAcceptableTransferBufferCopiesSize))

   626             {

   627             delete iTransferBufferCopies[firstFree];

   628             iTransferBufferCopies.Remove(firstFree);

   629             

   630             transBufCopyToUse = CTransferBufferCopy::NewL(aMaxLength);

   631             CleanupStack::PushL(transBufCopyToUse);

   632             User::LeaveIfError(iTransferBufferCopies.Insert(transBufCopyToUse,firstFree));

   633             

   634             CleanupStack::Pop();

   635             }

   636         else

   637             {

   638     #ifdef _DEBUG

   639             if(iTransferBufferCopies.Count() > KMaximumTransferBufferCopiesSize)

   640                 {

   641                 User::Panic(_L("iTransferBufferCopies grew too large in CProgDLMultimediaSource"),KErrTooBig);

   642                 }

   643     #endif

   644             

   645             transBufCopyToUse = CTransferBufferCopy::NewL(aMaxLength);

   646             CleanupStack::PushL(transBufCopyToUse);

   647             User::LeaveIfError(iTransferBufferCopies.Append(transBufCopyToUse));

   648             

   649             CleanupStack::Pop();

   650             }

   651         }

   652     

   653     return transBufCopyToUse;

   654     }

   655             

   656             

   657             

   658 /** 

   659 Loads aBuffer from iFile.

   660 

   661 The file must already be open for reading. File read is asynchronous. CReadRequest is created to 

   662 respond to completion.

   663 

   664 @param  aBuffer

   665 The buffer to be filled from the file.

   666 @param  aConsumer

   667 The data sink consumer of the buffer.

   668 */

   669 void CProgDLMultimediaSource::FillBufferL( CMMFBuffer* aBuffer, MDataSink* aConsumer, TMediaId /*aMediaId*/ )

   670     {

   671     // Requires that iFile is open for read.

   672     // Reads data from iFile into aBuffer

   673     TInt status(KErrNone);

   674     DEBPRN2(_L("CProgDLMultimediaSource::FillBuffer[%x]]"), aBuffer );

   675     if ((!aConsumer) || (!aBuffer))

   676         User::Leave(KErrArgument);

   677     

   678     if (!iFile)

   679         User::Leave(KErrNotReady);

   680     

   681     AppendBufferToSinkQueue(aBuffer,NULL,aConsumer,EFalse);

   682     DEBPRN4(_L("CProgDLMultimediaSource::FillBuffer DLComplete[%d] ReOpenCAF[%d] RequestPending[%d]"), isDownloadComplete,iReOpenCAF,iReadRequestPending );

   683     if(isDownloadComplete && !iReOpenCAF) 

   684         {

   685         if(!iReadRequestPending)

   686             {

   687             ReOpenCAF();

   688             status = ServiceFillBuffer();

   689             if(status == KErrUnderflow)

   690                 {

   691                 StateChanged(EBUFFERING);

   692                 }

   693             }

   694         }

   695     else

   696         {

   697         status = ServiceFillBuffer();

   698         

   699         if(status == KErrUnderflow)

   700             {

   701             StateChanged(EBUFFERING);

   702             }

   703         }        

   704     }

   705             

   706 /**

   707 Stores a request in an array.

   708 

   709 CReadWriteRequests are stored in the array iRequests.

   710 This function takes ownership and places the request in the array.

   711 It also checks the array for completed requests and removes them.

   712 

   713 @param  aRequest

   714 The request to store.

   715 */

   716 void CProgDLMultimediaSource::StoreRequestL( CReadWriteRequest* aRequest )

   717     {

   718     // add aRequest to iRequests

   719     User::LeaveIfError( iRequests.Append( aRequest ) ) ;

   720     

   721     // Clear out any completed requests

   722     for ( TInt ii = 0 ; ii < iRequests.Count() ; ii++ )

   723         {

   724         if (iRequests[ii]->Completed())

   725             {

   726             CReadWriteRequest* request = iRequests[ii];

   727             delete request;

   728             

   729             iRequests.Remove(ii);

   730             ii--;

   731             }

   732         }

   733     }

   734 

   735 

   736 /**

   737 Cancels outstanding requests.

   738 

   739 CReadWriteRequests are stored in the array iRequests.

   740 This function cancels any outstanding requests and removes them

   741 from iRequests.

   742 */

   743 void CProgDLMultimediaSource::CancelRequests()

   744     {

   745     // Clear out any completed requests

   746     for ( TInt ii = 0 ; ii < iRequests.Count() ; ii++ )

   747         {

   748         CReadWriteRequest* request = iRequests[ii];

   749         delete request;

   750         iRequests.Remove(ii);

   751         ii--;

   752         }

   753     }

   754 

   755             

   756 /**

   757 Evaluates a given intent against the rights associated with the file.

   758 

   759 The rights are not updated by this function call.

   760 

   761 @param  aIntent

   762 The intent to evaluate.

   763 

   764   @return An error code indicating if the function call was successful. KErrNone on success, otherwise

   765   another of the system-wide error codes.

   766 */

   767 TInt CProgDLMultimediaSource::EvaluateIntent(ContentAccess::TIntent aIntent) const

   768     {

   769     if (!iFile)

   770         {

   771         return KErrNotReady;

   772         }

   773     

   774     return iFile->EvaluateIntent(aIntent);

   775     }

   776             

   777 /**

   778 Evaluates and executes a given intent against the rights associated with the file.

   779 

   780 The rights object is updated after calling this function.

   781 

   782 @param  aIntent

   783 The intent to evaluate.

   784 

   785 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

   786 another of the system-wide error codes.

   787 */

   788 TInt CProgDLMultimediaSource::ExecuteIntent(ContentAccess::TIntent aIntent)

   789     {

   790     if (!iFile)

   791         {

   792         return KErrNotReady;

   793         }

   794     

   795     return iFile->ExecuteIntent(aIntent);

   796     }

   797             

   798 /**

   799 Returns whether the file is protected.

   800 

   801 @return A boolean indicating if the file is protected. ETrue if the file is protected.

   802 */

   803 TInt CProgDLMultimediaSource::GetDRMProtection(TBool& aIsProtected)

   804     {

   805     TInt err(KErrNone);	

   806     if (!iFile)

   807         {

   808         return KErrNotReady;

   809         }

   810     

   811     TRAP(err,aIsProtected = iFile->IsProtected());

   812     return err;

   813     }

   814             

   815 TInt CProgDLMultimediaSource::SetAgentProperty(ContentAccess::TAgentProperty aProperty, TInt aValue)

   816     {

   817     if (!iFile)

   818         {

   819         return KErrNotReady;

   820         }

   821     

   822     return iFile->SetAgentProperty(aProperty, aValue);

   823     }

   824             

   825 /*

   826 *	Returns ETrue if the request can safely be deleted.

   827 */

   828 TBool CReadWriteRequest::Completed() 

   829     {

   830     return iCompleted ;

   831     }

   832             

   833 TInt CReadWriteRequest::SetStatus(TBool aStatus)

   834     {

   835     iCompleted = aStatus;

   836     return KErrNone;

   837     }

   838 

   839 TBool CReadWriteRequest::SourceType() 

   840     {

   841     return iSourceType ;

   842     }

   843 

   844 

   845 /*

   846 *	Returns the data member of CMMFDataBuffer or CMMFTransferBuffer (as TPtr8)

   847 *  

   848 */

   849 TDes8& CReadWriteRequest::BufferDes()

   850     {

   851     if(iTransferBufferCopy)

   852         return iTransferBufferCopy->Des();

   853     else

   854         {

   855         //reset iBufferDes in case iBuffer has changed...

   856         iBufferDes = &(STATIC_CAST(CMMFDataBuffer*, iBuffer)->Data());

   857         return *iBufferDes;

   858         }

   859     }

   860 

   861 const TDesC8& CReadWriteRequest::BufferDesC()

   862     {

   863     if(iTransferBufferCopy)

   864         return iTransferBufferCopy->Des();

   865     else

   866         return BufferDes();

   867     }

   868 

   869 CMMFBuffer* CReadWriteRequest::Buffer()

   870     {

   871     return iBuffer;

   872     }

   873 

   874 TAny* CReadWriteRequest::GetSinkOrSource()

   875     {

   876     return iSinkOrSource;

   877     }

   878 

   879 /*

   880 *	Destructor.

   881 */

   882 CReadWriteRequest::~CReadWriteRequest() 

   883     {

   884     Cancel();

   885     if(iTransferBufferCopy)

   886         iTransferBufferCopy->SetInUse(EFalse);

   887     }

   888 

   889 /*

   890 *	Allows owning class access to SetActive()

   891 */

   892 void CReadWriteRequest::SetActive() 

   893     {

   894     CActive::SetActive() ;

   895     }

   896         

   897 /*

   898 *  For the moment at least...    Canceled requests may be deleted

   899 */

   900 void CReadWriteRequest::DoCancel() 

   901     {

   902     iCompleted = ETrue ;

   903     }

   904             

   905 /*

   906 *	Called when errors in RunL force Leave.  For the moment just mark the request deletable

   907 */

   908 TInt CReadWriteRequest::RunError( TInt aError ) 

   909     {

   910     //RunL can leave.

   911     iCompleted = ETrue ;

   912     iError = aError; //keep this error internally for now

   913     return KErrNone ;

   914     }

   915         

   916 /*

   917 *	On completion of read request call back to the MDataSink

   918 */

   919 void CReadRequest::RunL() 

   920     {

   921     //Copy the data from the normal buffer into the Transfer buffer

   922     if(iTransferBufferCopy)

   923         {

   924         //must specify the size here as the dest may be smaller than the source.

   925         TDes8& destDesc = STATIC_CAST(CMMFDataBuffer*, iBuffer)->Data();

   926         destDesc.Copy(iTransferBufferCopy->Des().Left(destDesc.MaxLength()));

   927     

   928         iTransferBufferCopy->SetInUse(EFalse);

   929         }

   930 

   931         STATIC_CAST(CProgDLMultimediaSource*,iParent)->ReadRequestStatus(STATIC_CAST(CReadWriteRequest*,this),iStatus);

   932     }

   933 

   934         // From CMultimediaDataSource begins

   935 TInt CProgDLMultimediaSource::SetObserver( MMultimediaDataSourceObserver& aObserver )

   936     {

   937     TInt status(KErrNone);

   938     iObserver = &aObserver;

   939     return status;

   940     }

   941         

   942 TInt CProgDLMultimediaSource::GetObserver( MMultimediaDataSourceObserver*& aObserver )

   943     {

   944     TInt status(KErrNone);

   945     aObserver = iObserver;

   946     return status;

   947     }

   948         

   949 void CProgDLMultimediaSource::Event( TUid aEvent )

   950     {

   951     if( aEvent == KMultimediaDataSourceEventBitRateChanged )

   952         {

   953         

   954         if(iObserver)

   955             {

   956                 iObserver->GetBitRate( iObserverBitRate ); 

   957                 if(iState == EBUFFERING)

   958                     CalculateBufferedDataSize();

   959             }

   960         }    

   961     

   962     }

   963         

   964 TInt CProgDLMultimediaSource::SetDataTypeCode(TFourCC aSourceFourCC )

   965     {

   966     TInt status(KErrNone);

   967     iSourceFourCC = aSourceFourCC;

   968     return status;

   969     }

   970         

   971 TInt CProgDLMultimediaSource::GetDataTypeCode(TFourCC& aSourceFourCC )

   972     {

   973     TInt status(KErrNone);

   974     aSourceFourCC = iSourceFourCC;

   975     return status;

   976     }

   977 

   978 TInt CProgDLMultimediaSource::GetSize( TUint& aSize )

   979     {

   980     TInt err = KErrNone;

   981     if (iDLFileSize >=0)

   982     	{

   983     	aSize = iDLFileSize;

   984     	}

   985     else

   986     	{

   987     	aSize = 0;

   988     	}

   989     return err;

   990     }

   991 

   992 TInt CProgDLMultimediaSource::Open()

   993     {

   994     TInt status(KErrNotReady);

   995     DEBPRN1(_L("CProgDLMultimediaSource::Open"));

   996     switch ( iState )

   997         {

   998         case ECLOSED:

   999             StateChanged(ESTOPPED);

  1000             status = KErrNone;

  1001             break;

  1002         case ESTOPPED:

  1003         case EPRIMED:

  1004         case EEXECUTING:

  1005         case EBUFFERING:

  1006         default:

  1007             DEBPRN2(_L("CProgDLMultimediaSource::Open[Illegal cmd on state[%d]]"), iState );

  1008             break;

  1009         };

  1010     return status;

  1011     }

  1012 

  1013 TInt CProgDLMultimediaSource::Close()

  1014     {

  1015     TInt status(KErrNone);

  1016     iHandle.Close();

  1017     iFsSession.Close();

  1018 

  1019     StateChanged(ECLOSED);

  1020     // Clear app buffers

  1021     EmptySinkQueue();

  1022     iSnkBytes = 0;

  1023     // Clear observer buffers

  1024     return status;

  1025     }

  1026 

  1027 TInt CProgDLMultimediaSource::Prime()

  1028     {

  1029     TInt status(KErrNotReady);

  1030     DEBPRN1(_L("CProgDLMultimediaSource::Prime"));

  1031     switch ( iState )

  1032         {

  1033         case ESTOPPED:

  1034             

  1035             // don't reopen file if already open

  1036             if (!iFile)

  1037                 {

  1038                 if (iFileHandle)

  1039                     {

  1040                     TRAPD(err,iFile = CContentFile::NewL(iHandle, UniqueId(), iCAFParameters->iEnableUI));

  1041                     if(err)

  1042                         return err;

  1043                     }

  1044                 else

  1045                     {

  1046                     // Open for read-only access

  1047                     TRAPD(err,iFile = CContentFile::NewL(iFsSession, iFullFileName, UniqueId(), EFileShareAny, iCAFParameters->iEnableUI));

  1048                     if(err)

  1049                         return err;                    

  1050                     }

  1051                 }

  1052             

  1053             if(iFile)

  1054                 {

  1055                 if(iFile->IsProtected())

  1056                     iFile->Size(iFileSize);

  1057                 else

  1058                     iFileSize = iDLFileSize;		          

  1059                 }												

  1060             

  1061             StateChanged(EPRIMED);

  1062             status = KErrNone;

  1063             break;

  1064         case EPRIMED:

  1065             status = KErrNone;

  1066             break;

  1067         case ECLOSED:

  1068         case EEXECUTING:

  1069         case EBUFFERING:

  1070         default:

  1071             DEBPRN2(_L("CProgDLMultimediaSource::Prime[Illegal cmd on state[%d]]"), iState );

  1072             break;

  1073         }

  1074     return status;

  1075     }

  1076 

  1077 TInt CProgDLMultimediaSource::Play()

  1078     {

  1079     TInt status(KErrNotReady);

  1080     DEBPRN1(_L("CProgDLMultimediaSource::Play"));

  1081     switch ( iState )

  1082         {

  1083         case EPRIMED:

  1084             CalculateBufferedDataSize();

  1085             StateChanged(EEXECUTING);

  1086             

  1087             while ( !iSinkQueue->IsEmpty() )

  1088                 {

  1089                 status = ServiceFillBuffer();

  1090                 }

  1091             

  1092             if(status == KErrUnderflow)

  1093                 {

  1094                 StateChanged(EBUFFERING);

  1095                 }

  1096             

  1097             status = KErrNone;	

  1098             break;

  1099         case EEXECUTING:

  1100         case EBUFFERING:

  1101             status = KErrNone;

  1102             // No op

  1103             break;

  1104         case ECLOSED:

  1105         case ESTOPPED:

  1106         default:

  1107             DEBPRN2(_L("CProgDLMultimediaSource::Play[Illegal cmd on state[%d]]"), iState );

  1108             break;

  1109         };

  1110     return status;

  1111     }

  1112         

  1113 TInt CProgDLMultimediaSource::Stop()

  1114     {

  1115     TInt status(KErrNotReady);

  1116     DEBPRN1(_L("CProgDLMultimediaSource::Stop"));

  1117     switch ( iState )

  1118         {

  1119         case EPRIMED:

  1120         case EEXECUTING:

  1121         case EBUFFERING:

  1122             {

  1123             TInt pos = 0;

  1124             CancelRequests();

  1125             delete iFile;

  1126             iFile = NULL;

  1127             //iDLFileSize = -1;

  1128             iSnkBytes=pos;

  1129             iBufferedDataSize = 0;

  1130             EmptySinkQueue();

  1131             StateChanged(ESTOPPED);

  1132             status = KErrNone;

  1133             }

  1134             break;