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 the License "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:    Implements My Videos Client API.*

    15 */

    16 

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 

    22 #include <e32svr.h>

    23 #include <s32mem.h> 

    24 

    25 #include "IptvClientServerCommon.h"

    26 #include "IptvDebug.h"

    27 #include "CIptvMyVideosClient.h"

    28 #include "MIptvMyVideosClientObserver.h"

    29 #include "IptvServer.pan"

    30 #include "CIptvMyVideosFolder.h"

    31 #include "CIptvMyVideosGlobalFileId.h"

    32 #include "CIptvMyVideosVideoBriefDetails.h"

    33 #include "CIptvMyVideosVideoFullDetails.h"

    34 #include "CIptvMyVideosContentUpdateObserver.h"

    35 #include "CIptvMyVideosTotalVideoLengthObserver.h"

    36 #include "CIptvMyVideosCopyOrMoveObserver.h"

    37 

    38 // CONSTANTS

    39 const TInt KIptvMaxFileSizeInKiloBytes = 4194303; // (TUint32) ((KMaxTUint32 - 1) / 1024)

    40 const TInt KTUint32SizeInBytes         = 4;

    41 const TInt KTUint16SizeInBytes         = 2;

    42 

    43 _LIT(KIptvInvalidFileNameChars, "\"<>/|'?*");

    44 

    45 // ============================ MEMBER FUNCTIONS ===============================

    46 

    47 // -----------------------------------------------------------------------------

    48 // CIptvMyVideosClient::CIptvMyVideosClient

    49 // -----------------------------------------------------------------------------

    50 //

    51 CIptvMyVideosClient::CIptvMyVideosClient( 

    52     MIptvMyVideosClientObserver& aClientObserver ) 

    53   : CActive( EPriorityStandard ),

    54     iClientObserver( aClientObserver ),

    55     iMsgPtr( NULL, 0 )

    56     {

    57     CActiveScheduler::Add( this );

    58     }

    59 

    60 // -----------------------------------------------------------------------------

    61 // CIptvMyVideosClient::ConstructL

    62 // -----------------------------------------------------------------------------

    63 //

    64 void CIptvMyVideosClient::ConstructL( TBool aSkipMaintenance )

    65     {

    66     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::ConstructL -- Enter");

    67 

    68     User::LeaveIfError(iSession.Connect());

    69 

    70     // Create observers for "content updated", "get total video length" and "copy/move complete"

    71     // messages from server. These messages stay pending until server has completed operation.

    72     //

    73     iContentUpdateObserver    = CIptvMyVideosContentUpdateObserver::NewL(iClientObserver, iSession);

    74     iTotalVideoLengthObserver = CIptvMyVideosTotalVideoLengthObserver::NewL(iClientObserver, iSession);

    75     iCopyOrMoveObserver       = CIptvMyVideosCopyOrMoveObserver::NewL(iClientObserver, iSession);

    76 

    77     // If client does not need maintenance scan, send the information about

    78     // need for maintenance to server. If this message is not sent, server

    79     // assumes that maintenance is needed and performs it after a short while.

    80     //

    81     if ( aSkipMaintenance )

    82         {

    83         TRequestStatus status;

    84         delete iMsg;

    85         iMsg = NULL;

    86         iMsg = HBufC8::NewL(KTUint32SizeInBytes);

    87         iMsgPtr.Set(iMsg->Des());

    88         RDesWriteStream stream;

    89         stream.Open(iMsgPtr);

    90         CleanupClosePushL(stream);

    91         stream.WriteUint32L(static_cast<TUint32>(aSkipMaintenance));

    92         CleanupStack::PopAndDestroy(&stream);

    93         iSession.SendRequest(EIptvEngineMyVideosPassMaintenanceInfoReq, iMsgPtr, status);

    94         User::WaitForRequest(status);

    95         }

    96 

    97     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::ConstructL -- Exit");

    98     }

    99 

   100 // -----------------------------------------------------------------------------

   101 // CIptvMyVideosClient::NewL

   102 // -----------------------------------------------------------------------------

   103 //

   104 EXPORT_C CIptvMyVideosClient* CIptvMyVideosClient::NewL(

   105         MIptvMyVideosClientObserver& aClientObserver,

   106         TBool aMaintenance /*= EFalse*/ )

   107     {

   108 	CIptvMyVideosClient* self = CIptvMyVideosClient::NewLC(

   109 	        aClientObserver,

   110 	        aMaintenance );

   111 	CleanupStack::Pop(self);

   112 	return self;

   113     }

   114 

   115 // -----------------------------------------------------------------------------

   116 // CIptvMyVideosClient::NewLC

   117 // -----------------------------------------------------------------------------

   118 //

   119 EXPORT_C CIptvMyVideosClient* CIptvMyVideosClient::NewLC(

   120         MIptvMyVideosClientObserver& aClientObserver,

   121         TBool aMaintenance /*= EFalse*/ )

   122     {

   123 	CIptvMyVideosClient* self = new (ELeave) CIptvMyVideosClient(aClientObserver);

   124 	CleanupStack::PushL(self);

   125 	self->ConstructL(aMaintenance);

   126 	return self;

   127     }

   128 

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

   130 // CIptvMyVideosClient::~CIptvMyVideosClient

   131 // -----------------------------------------------------------------------------

   132 //

   133 CIptvMyVideosClient::~CIptvMyVideosClient()

   134     {

   135     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::~CIptvMyVideosClient -- Enter");

   136 

   137     // Cancel own requests, there shouldn't be any though.

   138     Cancel(); 

   139 

   140     // Cancel the content update and total video length requests.

   141     // The cancellation is done with the help of server side.

   142     if (!IsActive())

   143         {

   144         if (!iSession.IsNull())

   145             {

   146             TRequestStatus status;

   147             iSession.SendRequest(EIptvEngineMyVideosCancelReq, status);

   148             User::WaitForRequest(status);

   149             }

   150         }

   151 

   152     delete iContentUpdateObserver;

   153     delete iTotalVideoLengthObserver;

   154     delete iCopyOrMoveObserver;

   155 

   156     delete iMsg;

   157 

   158     iSession.Close();

   159     

   160     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::~CIptvMyVideosClient -- Exit");    

   161     }

   162 

   163 // -----------------------------------------------------------------------------

   164 // CIptvMyVideosClient::GetFolderListL

   165 // -----------------------------------------------------------------------------

   166 //

   167 EXPORT_C TInt CIptvMyVideosClient::GetFolderListL( 

   168         CIptvMyVideosGlobalFolderId& aParentFolderId,

   169         TUint32 aFrom,

   170         TUint32 aAmount,

   171         TUint32& aTotalAmount,

   172         RPointerArray<CIptvMyVideosFolder>& aFolderList )

   173     {

   174     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::GetFolderListL");

   175 

   176     TInt error = KErrServerBusy;

   177 

   178     if ( ! IsActive() )

   179         {

   180         if ( KErrNone ==

   181              ( error = SendRequestL( EIptvEngineMyVideosGetFolderListSizeReq,

   182                                      aParentFolderId,

   183                                      aFrom,

   184                                      aAmount ) ) )

   185             {

   186             if ( KErrNone ==

   187                  ( error = HandleMyVideosSizeReqL( EIptvEngineMyVideosGetFolderListDataReq ) ) )

   188                 {

   189                 error = HandleMyVideosGetFolderListDataReqL( aTotalAmount, aFolderList );

   190                 }

   191             }

   192         }

   193 

   194     return error;

   195     }

   196 

   197 // -----------------------------------------------------------------------------

   198 // CIptvMyVideosClient::GetParentFolderL

   199 // -----------------------------------------------------------------------------

   200 //

   201 EXPORT_C TInt CIptvMyVideosClient::GetParentFolderL(

   202         CIptvMyVideosGlobalFolderId& aFolderId,

   203         CIptvMyVideosGlobalFolderId& aParentFolder )

   204     {

   205     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::GetParentFolderL");

   206 

   207     TInt error = KErrServerBusy;

   208 

   209     if ( aFolderId.iDrive == 0 && aFolderId.iFolderId == 0 )

   210         {

   211         return KErrArgument;

   212         }

   213 

   214     if ( ! IsActive() )

   215         {

   216         if ( KErrNone ==

   217              ( error = SendRequestL( EIptvEngineMyVideosGetParentFolderSizeReq, aFolderId ) ) )

   218             {

   219             if ( KErrNone ==

   220                  ( error = HandleMyVideosSizeReqL( EIptvEngineMyVideosGetParentFolderDataReq ) ) )

   221                 {

   222                 error = HandleMyVideosGetParentFolderDataReqL( aParentFolder );

   223                 }

   224             }

   225         }

   226 

   227     return error;

   228     }

   229 

   230 // -----------------------------------------------------------------------------

   231 // CIptvMyVideosClient::GetFolderNameL

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

   233 //

   234 EXPORT_C TInt CIptvMyVideosClient::GetFolderNameL(

   235         CIptvMyVideosGlobalFolderId& aFolderId,

   236         TDes& aName )

   237     {

   238     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::GetParentFolderL");

   239 

   240     TInt error = KErrServerBusy;

   241 

   242     if ( ! IsActive() )

   243         {

   244         if ( KErrNone ==

   245              ( error = SendRequestL( EIptvEngineMyVideosGetFolderNameSizeReq, aFolderId ) ) )

   246             {

   247             if ( KErrNone ==

   248                  ( error = HandleMyVideosSizeReqL( EIptvEngineMyVideosGetFolderNameDataReq ) ) )

   249                 {

   250                 error = HandleMyVideosGetFolderNameDataReqL( aName );

   251                 }

   252             }

   253         }

   254 

   255     return error;

   256     }

   257 

   258 // -----------------------------------------------------------------------------

   259 // CIptvMyVideosClient::DeleteFolderReqL

   260 // -----------------------------------------------------------------------------

   261 //

   262 EXPORT_C TInt CIptvMyVideosClient::DeleteFolderReqL(CIptvMyVideosGlobalFolderId& aFolderId)

   263     {

   264     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::DeleteFolderReqL");

   265     

   266     TInt error = KErrServerBusy;

   267     

   268     if (aFolderId.iDrive == 0 && aFolderId.iFolderId == 0)

   269         {

   270         return KErrArgument;

   271         }  

   272 

   273     if (!IsActive())

   274         {

   275         if (iMsg)

   276             {

   277             delete iMsg;

   278             iMsg = NULL;

   279             }

   280 

   281         TUint32 dataSize = aFolderId.CountExternalizeSize();

   282 

   283         iMsg = HBufC8::NewL(dataSize);

   284         iMsgPtr.Set(iMsg->Des());

   285 

   286         RDesWriteStream stream;

   287         stream.Open(iMsgPtr);

   288         CleanupClosePushL( stream );

   289         aFolderId.ExternalizeL(stream);

   290         CleanupStack::PopAndDestroy( &stream );

   291 

   292         iSession.SendRequest(EIptvEngineMyVideosDeleteFolderRequestReq, iMsgPtr, iStatus);

   293         iActiveRequest = EIptvEngineMyVideosDeleteFolderRequestReq;

   294         SetActive();

   295 

   296         error = KErrNone;

   297         }

   298 

   299     return error;

   300     }

   301 

   302 // -----------------------------------------------------------------------------

   303 // CIptvMyVideosClient::DeleteFolderL

   304 // -----------------------------------------------------------------------------

   305 //

   306 EXPORT_C TInt CIptvMyVideosClient::DeleteFolderL( CIptvMyVideosGlobalFolderId& aFolderId )

   307     {

   308     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::DeleteFolderL");

   309     

   310     TInt error = KErrServerBusy;

   311     

   312     if ( aFolderId.iDrive == 0 && aFolderId.iFolderId == 0 )

   313         {

   314         return KErrArgument;

   315         }  

   316 

   317     if ( ! IsActive() )

   318         {

   319         if ( KErrNone ==

   320              ( error = SendRequestL( EIptvEngineMyVideosDeleteFolderReq, aFolderId ) ) )

   321             {

   322             error = HandleMyVideosReqL(); // No return data.

   323             }

   324         }

   325 

   326     return error;

   327     }

   328 

   329 // -----------------------------------------------------------------------------

   330 // CIptvMyVideosClient::GetVideoListL

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

   332 //

   333 EXPORT_C TInt CIptvMyVideosClient::GetVideoListL(

   334         CIptvMyVideosGlobalFolderId& aParentFolderId,

   335         TUint32 aFrom,

   336         TUint32 aAmount,

   337         TUint32& aTotalAmount,

   338         RPointerArray<CIptvMyVideosVideoBriefDetails>& aVideoList )

   339     {

   340     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::GetVideoListL");

   341     

   342     TInt error = KErrServerBusy;

   343     

   344     if ( ! IsActive() )

   345         {

   346         if ( KErrNone == 

   347              ( error = SendRequestL( EIptvEngineMyVideosGetVideoListSizeReq,

   348                                      aParentFolderId,

   349                                      aFrom,

   350                                      aAmount ) ) )

   351             {

   352             if ( KErrNone ==

   353                  ( error = HandleMyVideosSizeReqL( EIptvEngineMyVideosGetVideoListDataReq ) ) )

   354                 {

   355                 error = HandleMyVideosGetVideoListDataReqL( aTotalAmount, aVideoList );

   356                 }

   357             }

   358         }

   359 

   360     return error;

   361     }

   362 

   363 // -----------------------------------------------------------------------------

   364 // CIptvMyVideosClient::GetVideoDetailsL

   365 // -----------------------------------------------------------------------------

   366 //

   367 EXPORT_C TInt CIptvMyVideosClient::GetVideoDetailsL(

   368         CIptvMyVideosGlobalFileId& aFileId,

   369         CIptvMyVideosVideoFullDetails& aFullDetails )

   370     {

   371     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::GetVideoDetailsL");

   372     

   373     TInt error = KErrServerBusy;

   374     

   375     if ( ! IsActive() )

   376         {        

   377         if ( KErrNone ==

   378              ( error = SendRequestL( EIptvEngineMyVideosGetVideoDetailsSizeReq, aFileId ) ) )

   379             {

   380             if ( KErrNone ==

   381                  ( error = HandleMyVideosSizeReqL( EIptvEngineMyVideosGetVideoDetailsDataReq ) ) )

   382                 {

   383                 error = HandleMyVideosGetVideoDetailsDataReqL( aFullDetails );

   384                 }

   385             }

   386         }

   387 

   388     return error;

   389     }

   390 

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

   392 // CIptvMyVideosClient::GetVideoDetailsForPathL

   393 // -----------------------------------------------------------------------------

   394 //

   395 EXPORT_C TInt CIptvMyVideosClient::GetVideoDetailsForPathL(

   396         const TDesC& aLocalPath,

   397         CIptvMyVideosVideoFullDetails& aFullDetails )

   398     {

   399     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::GetVideoDetailsForPathL");

   400 

   401     TInt error = KErrServerBusy;

   402 

   403     if ( aLocalPath.Length() == 0 || aLocalPath.Length() > KIptvMaxPath )

   404         {

   405         return KErrArgument;

   406         }

   407 

   408     if ( ! IsActive() )

   409         {

   410         RDesWriteStream writeStream;

   411         CleanupClosePushL( writeStream );

   412         TRequestStatus status;

   413         TUint32 length = aLocalPath.Length();

   414 

   415         // Request for the video details.

   416         delete iMsg;

   417         iMsg = NULL;

   418         iMsg = HBufC8::NewL( KTUint16SizeInBytes + ( length * 2 ) );

   419         iMsgPtr.Set( iMsg->Des() );

   420         writeStream.Open( iMsgPtr );

   421         CIptvUtil::WriteDesToStreamL( aLocalPath, writeStream );

   422         CleanupStack::PopAndDestroy( &writeStream );

   423 

   424         iSession.SendRequest( EIptvEngineMyVideosGetVideoDetailsForPathSizeReq, iMsgPtr, status );

   425         User::WaitForRequest( status );

   426         error = status.Int();

   427 

   428         // If operation went ok, get the reply data.

   429         if ( error == KErrNone )    

   430             {

   431             if ( KErrNone ==

   432                  ( error = HandleMyVideosSizeReqL( 

   433                                EIptvEngineMyVideosGetVideoDetailsForPathDataReq ) ) )

   434                 {

   435                 error = HandleMyVideosGetVideoDetailsDataReqL( aFullDetails );

   436                 }

   437             }

   438         }

   439 

   440     return error;

   441     }

   442 

   443 // -----------------------------------------------------------------------------

   444 // CIptvMyVideosClient::GetTotalVideoLengthRequestL

   445 // -----------------------------------------------------------------------------

   446 //

   447 EXPORT_C TInt CIptvMyVideosClient::GetTotalVideoLengthRequestL()

   448     {

   449     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::GetTotalVideoLengthRequestL");

   450 

   451     if (iTotalVideoLengthObserver && (! iTotalVideoLengthObserver->IsActive()))

   452         {

   453         iTotalVideoLengthObserver->SetActiveL();

   454         return KErrNone;

   455         }

   456     else

   457         {

   458         return KErrServerBusy;

   459         }

   460     }

   461 

   462 // -----------------------------------------------------------------------------

   463 // CIptvMyVideosClient::SetVideoDetailsL

   464 // -----------------------------------------------------------------------------

   465 //

   466 EXPORT_C TInt CIptvMyVideosClient::SetVideoDetailsL( 

   467         CIptvMyVideosVideoFullDetails& aVideoFullDetails )

   468     {

   469     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::SetVideoDetailsL()");

   470     

   471     TInt error = KErrServerBusy;

   472     

   473     if ( ! IsActive() )

   474         {

   475         if ( KErrNone ==

   476              ( error = SendRequestL( EIptvEngineMyVideosSetVideoDetailsReq,

   477                                      aVideoFullDetails ) ) )

   478             {

   479             error = HandleMyVideosReqL(); // No return data.

   480             }

   481         }

   482 

   483     return error;

   484     }

   485 

   486 // -----------------------------------------------------------------------------

   487 // CIptvMyVideosClient::DeleteVideoReqL()

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

   489 //

   490 EXPORT_C TInt CIptvMyVideosClient::DeleteVideoReqL(CIptvMyVideosGlobalFileId& aFileId)

   491     {

   492     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::DeleteVideoReqL");

   493 

   494     TInt error = KErrServerBusy;

   495 

   496     if (!IsActive())

   497         {

   498         if (iMsg)

   499             {

   500             delete iMsg;

   501             iMsg = NULL;

   502             }

   503 

   504         TUint32 dataSize = aFileId.CountExternalizeSize();

   505 

   506         iMsg = HBufC8::NewL(dataSize);

   507         iMsgPtr.Set(iMsg->Des());

   508 

   509         RDesWriteStream stream;

   510         stream.Open(iMsgPtr);

   511         CleanupClosePushL( stream );

   512         aFileId.ExternalizeL(stream);

   513         CleanupStack::PopAndDestroy( &stream );

   514 

   515         iSession.SendRequest(EIptvEngineMyVideosDeleteVideoRequestReq, iMsgPtr, iStatus);

   516         iActiveRequest = EIptvEngineMyVideosDeleteVideoRequestReq;

   517         SetActive();

   518 

   519         error = KErrNone;

   520         }

   521 

   522     return error;    

   523     }

   524 

   525 // -----------------------------------------------------------------------------

   526 // CIptvMyVideosClient::DeleteVideoL

   527 // -----------------------------------------------------------------------------

   528 //

   529 EXPORT_C TInt CIptvMyVideosClient::DeleteVideoL( CIptvMyVideosGlobalFileId& aFileId )

   530     {

   531     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::DeleteVideoL");

   532 

   533     TInt error = KErrServerBusy;

   534 

   535     if ( ! IsActive() )

   536         {

   537         if ( KErrNone ==

   538              ( error = SendRequestL( EIptvEngineMyVideosDeleteVideoReq, aFileId ) ) )

   539             {

   540             error = HandleMyVideosReqL(); // No return data.

   541             }

   542         }

   543 

   544     return error;

   545     }

   546 

   547 // -----------------------------------------------------------------------------

   548 // CIptvMyVideosClient::CopyReqL()

   549 // -----------------------------------------------------------------------------

   550 //

   551 EXPORT_C TInt CIptvMyVideosClient::CopyReqL(CIptvMyVideosGlobalFileId& aSourceFileId, CIptvMyVideosGlobalFolderId& aTargetFolderId)

   552     {

   553     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::CopyReqL(file)");

   554 

   555     if (iCopyOrMoveObserver && (! iCopyOrMoveObserver->IsActive()))

   556         {

   557         iCopyOrMoveObserver->SetActiveL(EIptvEngineMyVideosCopyFileRequestReq, aSourceFileId, aTargetFolderId);

   558         return KErrNone;

   559         }

   560     else

   561         {

   562         return KErrServerBusy;

   563         }

   564     }

   565 

   566 // -----------------------------------------------------------------------------

   567 // CIptvMyVideosClient::CopyL

   568 // -----------------------------------------------------------------------------

   569 //

   570 EXPORT_C TInt CIptvMyVideosClient::CopyL(

   571         CIptvMyVideosGlobalFileId& aSourceFileId,

   572         CIptvMyVideosGlobalFolderId& aTargetFolderId )

   573     {

   574     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::CopyL(file)");

   575 

   576     TInt error = KErrServerBusy;

   577     

   578     if ( ! IsActive() )

   579         {

   580         if ( KErrNone == 

   581              ( error = SendRequestL( EIptvEngineMyVideosCopyFileReq,

   582                                      aSourceFileId,

   583                                      aTargetFolderId ) ) )

   584             {

   585             error = HandleMyVideosReqL(); // No return data.

   586             }

   587         }

   588 

   589     return error;

   590     }

   591 

   592 // -----------------------------------------------------------------------------

   593 // CIptvMyVideosClient::CopyReqL()

   594 // -----------------------------------------------------------------------------

   595 //

   596 EXPORT_C TInt CIptvMyVideosClient::CopyReqL(CIptvMyVideosGlobalFolderId& aSourceFolderId, CIptvMyVideosGlobalFolderId& aTargetFolderId)

   597     {

   598     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::CopyReqL(folder)");

   599 

   600     if (iCopyOrMoveObserver && (! iCopyOrMoveObserver->IsActive()))

   601         {

   602         iCopyOrMoveObserver->SetActiveL(EIptvEngineMyVideosCopyFolderRequestReq, aSourceFolderId, aTargetFolderId);

   603         return KErrNone;

   604         }

   605     else

   606         {

   607         return KErrServerBusy;

   608         }

   609     }

   610 

   611 // -----------------------------------------------------------------------------

   612 // CIptvMyVideosClient::CopyL

   613 // -----------------------------------------------------------------------------

   614 //

   615 EXPORT_C TInt CIptvMyVideosClient::CopyL(

   616         CIptvMyVideosGlobalFolderId& aSourceFolderId,

   617         CIptvMyVideosGlobalFolderId& aTargetFolderId,

   618         TUint32& aFailed )

   619     {

   620     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::CopyL(folder)");

   621 

   622     TInt error = KErrServerBusy;

   623 

   624     if ( aSourceFolderId.iDrive == 0 && aSourceFolderId.iFolderId == 0 )

   625         {

   626         return KErrArgument;

   627         }    

   628 

   629     if ( ! IsActive() )

   630         {

   631         if ( KErrNone ==

   632              ( error = SendRequestL( EIptvEngineMyVideosCopyFolderSizeReq,

   633                                      aSourceFolderId,

   634                                      aTargetFolderId ) ) )

   635             {

   636             if ( KErrNone ==

   637                  ( error = HandleMyVideosSizeReqL( EIptvEngineMyVideosCopyFolderDataReq ) ) )

   638                 {

   639                 error = HandleMyVideosCopyFolderDataReqL( aFailed );

   640                 }

   641             }

   642         }        

   643 

   644     return error;

   645     }

   646 

   647 // -----------------------------------------------------------------------------

   648 // CIptvMyVideosClient::MoveReqL()

   649 // -----------------------------------------------------------------------------

   650 //

   651 EXPORT_C TInt CIptvMyVideosClient::MoveReqL(CIptvMyVideosGlobalFileId& aSourceFileId, CIptvMyVideosGlobalFolderId& aTargetFolderId)

   652     {

   653     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::MoveReqL(file)");

   654 

   655     if (iCopyOrMoveObserver && (! iCopyOrMoveObserver->IsActive()))

   656         {

   657         iCopyOrMoveObserver->SetActiveL(EIptvEngineMyVideosMoveFileRequestReq, aSourceFileId, aTargetFolderId);

   658         return KErrNone;

   659         }

   660     else

   661         {

   662         return KErrServerBusy;

   663         }

   664     }

   665 

   666 // -----------------------------------------------------------------------------

   667 // CIptvMyVideosClient::MoveL

   668 // -----------------------------------------------------------------------------

   669 //

   670 EXPORT_C TInt CIptvMyVideosClient::MoveL(

   671         CIptvMyVideosGlobalFileId& aSourceFileId,

   672         CIptvMyVideosGlobalFolderId& aTargetFolderId )

   673     {

   674     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::MoveL(file)");

   675 

   676     TInt error = KErrServerBusy;

   677 

   678     if ( ! IsActive() )

   679         {

   680         if ( KErrNone ==

   681              ( error = SendRequestL( EIptvEngineMyVideosMoveFileReq,

   682                                      aSourceFileId,

   683                                      aTargetFolderId ) ) )

   684             {

   685             error = HandleMyVideosReqL(); // No return data.

   686             }

   687         }

   688 

   689     return error;

   690     }

   691 

   692 // -----------------------------------------------------------------------------

   693 // CIptvMyVideosClient::MoveReqL()

   694 // -----------------------------------------------------------------------------

   695 //

   696 EXPORT_C TInt CIptvMyVideosClient::MoveReqL(CIptvMyVideosGlobalFolderId& aSourceFolderId, CIptvMyVideosGlobalFolderId& aTargetFolderId)

   697     {

   698     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::MoveReqL(folder)");

   699 

   700     if (iCopyOrMoveObserver && (! iCopyOrMoveObserver->IsActive()))

   701         {

   702         iCopyOrMoveObserver->SetActiveL(EIptvEngineMyVideosMoveFolderRequestReq, aSourceFolderId, aTargetFolderId);

   703         return KErrNone;

   704         }

   705     else

   706         {

   707         return KErrServerBusy;

   708         }

   709     }

   710 

   711 // -----------------------------------------------------------------------------

   712 // CIptvMyVideosClient::MoveL

   713 // -----------------------------------------------------------------------------

   714 //

   715 EXPORT_C TInt CIptvMyVideosClient::MoveL(

   716         CIptvMyVideosGlobalFolderId& aSourceFolderId,

   717         CIptvMyVideosGlobalFolderId& aTargetFolderId,

   718         TUint32& aFailed )

   719     {

   720     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::MoveL(folder)");

   721     

   722     TInt error = KErrServerBusy;

   723     

   724     if ( aSourceFolderId.iDrive == 0 && aSourceFolderId.iFolderId == 0 )

   725         {

   726         return KErrArgument;

   727         }    

   728 

   729     if ( ! IsActive() )

   730         {

   731         if ( KErrNone ==

   732              ( error = SendRequestL( EIptvEngineMyVideosMoveFolderSizeReq,

   733                                      aSourceFolderId,

   734                                      aTargetFolderId ) ) )

   735             {

   736             if ( KErrNone ==

   737                  ( error = HandleMyVideosSizeReqL( EIptvEngineMyVideosMoveFolderDataReq ) ) )

   738                 {

   739                 error = HandleMyVideosMoveFolderDataReqL( aFailed );

   740                 }

   741             }        

   742         }

   743 

   744     return error;

   745     }

   746 

   747 // -----------------------------------------------------------------------------

   748 // CIptvMyVideosClient::CancelCopyOrMoveL()

   749 // -----------------------------------------------------------------------------

   750 //

   751 EXPORT_C TInt CIptvMyVideosClient::CancelCopyOrMoveL()

   752     {

   753     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::CancelCopyOrMoveL()");

   754 

   755     TInt error = KErrServerBusy;

   756 

   757     if (!IsActive())

   758         {

   759         TRequestStatus status;

   760         iSession.SendRequest(EIptvEngineMyVideosCancelCopyOrMoveReq, status);

   761         User::WaitForRequest(status);

   762 

   763         error = status.Int();

   764         }

   765 

   766     return error;

   767     }

   768 

   769 // -----------------------------------------------------------------------------

   770 // CIptvMyVideosClient::RenameDatabaseFolderL

   771 // -----------------------------------------------------------------------------

   772 //

   773 EXPORT_C TInt CIptvMyVideosClient::RenameDatabaseFolderL(

   774         CIptvMyVideosGlobalFolderId& aFolderId,

   775         TDesC& aName )

   776     {

   777     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::RenameDatabaseFolderL");

   778 

   779     TInt error = KErrServerBusy;

   780 

   781     if ( ( aFolderId.iDrive == 0 && aFolderId.iFolderId == 0 ) || 

   782          ( aName.Length() == 0 ) ||

   783          ( aName.Length() > KIptvMyVideosFolderNameMaxLength ) )

   784         {

   785         return KErrArgument;

   786         }

   787 

   788     if ( ! IsActive() )

   789         {

   790         if ( KErrNone ==

   791              ( error = SendRequestL( EIptvEngineMyVideosRenameDatabaseFolderReq,

   792                                      aFolderId,

   793                                      aName ) ) )

   794             {

   795             error = HandleMyVideosReqL(); // No return data.

   796             }

   797         }

   798 

   799     return error;

   800     }

   801 

   802 // -----------------------------------------------------------------------------

   803 // CIptvMyVideosClient::NewDatabaseFolderL

   804 // -----------------------------------------------------------------------------

   805 //

   806 EXPORT_C TInt CIptvMyVideosClient::NewDatabaseFolderL(

   807         CIptvMyVideosGlobalFolderId& aParentFolderId,

   808         TDesC& aName,

   809         CIptvMyVideosGlobalFolderId& aNewFolderId )

   810     {

   811     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::NewDatabaseFolderL");

   812 

   813     TInt error = KErrServerBusy;

   814 

   815     if ( ( aName.Length() == 0 ) || ( aName.Length() > KIptvMyVideosFolderNameMaxLength ) )

   816         {

   817         return KErrArgument;

   818         }

   819 

   820     if ( ! IsActive() )

   821         {

   822         if ( KErrNone ==

   823              ( error = SendRequestL( EIptvEngineMyVideosNewDatabaseFolderSizeReq,

   824                                      aParentFolderId,

   825                                      aName ) ) )

   826             {

   827             if ( KErrNone == 

   828                  ( error = HandleMyVideosSizeReqL( 

   829                                EIptvEngineMyVideosNewDatabaseFolderDataReq ) ) )

   830                 {

   831                 error = HandleMyVideosNewDatabaseFolderDataReqL( aNewFolderId );

   832                 }

   833             }

   834         }

   835 

   836     return error;

   837     }

   838 

   839 // -----------------------------------------------------------------------------

   840 // CIptvMyVideosClient::CreateVideoL

   841 // -----------------------------------------------------------------------------

   842 //

   843 EXPORT_C TInt CIptvMyVideosClient::CreateVideoL(

   844         CIptvMyVideosVideoFullDetails& aFullDetails,

   845         TVideoType aVideoType,

   846         TUint32 aSizeEstimateInKiloBytes )

   847     {

   848     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::CreateVideoL");

   849 

   850     TInt error = KErrServerBusy;

   851 

   852     if ( aSizeEstimateInKiloBytes > KIptvMaxFileSizeInKiloBytes ||

   853          HasInvalidFileNameChars( aFullDetails.VideoPath() ) )

   854         {

   855         return KErrArgument;

   856         }

   857 

   858     if ( ! IsActive() )

   859         {

   860         if ( KErrNone ==

   861              ( error = SendRequestL( EIptvEngineMyVideosCreateVideoSizeReq,

   862                                      aFullDetails,

   863                                      (TUint32) aVideoType,

   864                                      aSizeEstimateInKiloBytes ) ) )

   865             {

   866             if ( KErrNone ==

   867                  ( error = HandleMyVideosSizeReqL( EIptvEngineMyVideosCreateVideoDataReq ) ) )

   868                 {

   869                 error = HandleMyVideosGetVideoDetailsDataReqL( aFullDetails ); 

   870                 }

   871             }

   872         }

   873 

   874     return error;

   875     }

   876 

   877 // -----------------------------------------------------------------------------

   878 // CIptvMyVideosClient::EnsureFreeSpaceL

   879 // -----------------------------------------------------------------------------

   880 //

   881 EXPORT_C TInt CIptvMyVideosClient::EnsureFreeSpaceL(

   882         CIptvMyVideosGlobalFileId& aFileId,

   883         TUint32 aRequiredSpaceInKiloBytes )

   884     {

   885     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::EnsureFreeSpaceL (single drive)");

   886 

   887     TInt error = KErrServerBusy;

   888 

   889     if ( ( aFileId.iDrive == 0 && aFileId.iFileId == 0 ) ||

   890          ( aRequiredSpaceInKiloBytes > KIptvMaxFileSizeInKiloBytes ) )

   891         {

   892         return KErrArgument;

   893         }

   894 

   895     if ( ! IsActive() )

   896         {

   897         if ( KErrNone ==

   898              ( error = SendRequestL( EIptvEngineMyVideosEnsureFreeSpaceReq,

   899                                      aFileId,

   900                                      aRequiredSpaceInKiloBytes ) ) )

   901             {

   902             error = HandleMyVideosReqL(); // No return data.

   903             }

   904         }

   905 

   906     return error;

   907     }

   908 

   909 // -----------------------------------------------------------------------------

   910 // CIptvMyVideosClient::EnsureFreeSpaceL

   911 // -----------------------------------------------------------------------------

   912 //

   913 EXPORT_C TInt CIptvMyVideosClient::EnsureFreeSpaceL(

   914         CIptvMyVideosGlobalFileId& aCurrentFileId,

   915         TUint32 aRequiredSpaceInKiloBytes,

   916         CIptvMyVideosGlobalFileId& aNewFileId )

   917     {

   918     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::EnsureFreeSpaceL (multi drive)");

   919 

   920     TInt error = KErrServerBusy;

   921 

   922     if ( ( aCurrentFileId.iDrive == 0 && aCurrentFileId.iFileId == 0 ) ||

   923          ( aRequiredSpaceInKiloBytes > KIptvMaxFileSizeInKiloBytes ) )

   924         {

   925         return KErrArgument;

   926         }

   927 

   928     if ( ! IsActive() )

   929         {

   930         if ( KErrNone ==

   931              ( error = SendRequestL( EIptvEngineMyVideosEnsureFreeSpaceSizeReq,

   932                                      aCurrentFileId,

   933                                      aRequiredSpaceInKiloBytes ) ) )

   934             {

   935             if ( KErrNone ==

   936                  ( error = HandleMyVideosSizeReqL( EIptvEngineMyVideosEnsureFreeSpaceDataReq ) ) )

   937                 {

   938                 error = HandleMyVideosEnsureFreeSpaceDataReqL( aNewFileId );

   939                 }

   940             }

   941         }

   942 

   943     return error;

   944     }

   945 

   946 // -----------------------------------------------------------------------------

   947 // Count total video length and total file size (sum of all videos).

   948 // -----------------------------------------------------------------------------

   949 //

   950 EXPORT_C TInt CIptvMyVideosClient::GetTotalVideoLengthL(

   951     TIptvPlayTime& /*aTotalPlayTime*/,

   952     TIptvFileSize& /*aTotalFileSize*/ )

   953     {

   954     // Not implemented here.

   955     return KErrNotSupported;

   956     }

   957 

   958 // -----------------------------------------------------------------------------

   959 // Deletes all videos which are under downloading.

   960 // -----------------------------------------------------------------------------

   961 //

   962 EXPORT_C TInt CIptvMyVideosClient::DeleteAllDownloadsL()

   963     {

   964     // Not implemented here.

   965     return KErrNotSupported;

   966     }

   967     

   968 // -----------------------------------------------------------------------------

   969 // CIptvMyVideosClient::RunL

   970 // -----------------------------------------------------------------------------

   971 //

   972 void CIptvMyVideosClient::RunL()

   973     {

   974     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::RunL");

   975 

   976     // Note: Always delete the message first. If user makes another 

   977     // request from DeleteResponse below, we don't want to delete that.

   978     if (iMsg)

   979         {

   980         delete iMsg;

   981         iMsg = NULL;

   982         }

   983 

   984     if ( iActiveRequest == EIptvEngineMyVideosDeleteFolderRequestReq ||

   985          iActiveRequest == EIptvEngineMyVideosDeleteVideoRequestReq )

   986         {

   987         iClientObserver.DeleteResponse(iStatus.Int());

   988         }

   989     }

   990 

   991 // -----------------------------------------------------------------------------

   992 // CIptvMyVideosClient::DoCancel

   993 // -----------------------------------------------------------------------------

   994 //

   995 void CIptvMyVideosClient::DoCancel()

   996     {

   997     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::DoCancel");

   998 

   999     iActiveRequest = KErrNone;

  1000     }

  1001 

  1002 // -----------------------------------------------------------------------------

  1003 // CIptvMyVideosClient::RunError

  1004 // -----------------------------------------------------------------------------

  1005 //

  1006 TInt CIptvMyVideosClient::RunError(TInt /*aError*/)

  1007     {

  1008     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::RunError");

  1009 

  1010     iActiveRequest = KErrNone;

  1011     

  1012     return KErrNone;    

  1013     }

  1014 

  1015 // -----------------------------------------------------------------------------

  1016 // CIptvMyVideosClient::SendRequestL

  1017 // -----------------------------------------------------------------------------

  1018 //

  1019 TInt CIptvMyVideosClient::SendRequestL(TInt aMessage, CIptvMyVideosGlobalFileId& aFileIdParam)

  1020     {

  1021     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::SendRequestL");

  1022 

  1023     TRequestStatus status;

  1024     TUint32        dataSize = 0;

  1025 

  1026     if (iMsg)

  1027         {

  1028         delete iMsg;

  1029         iMsg = NULL;

  1030         }

  1031 

  1032     dataSize = aFileIdParam.CountExternalizeSize();

  1033 

  1034     iMsg = HBufC8::NewL(dataSize);

  1035     iMsgPtr.Set(iMsg->Des());

  1036 

  1037     RDesWriteStream stream;

  1038     stream.Open(iMsgPtr);

  1039     CleanupClosePushL( stream );

  1040     aFileIdParam.ExternalizeL(stream);

  1041     CleanupStack::PopAndDestroy( &stream );

  1042 

  1043     iSession.SendRequest(aMessage, iMsgPtr, status);

  1044     User::WaitForRequest(status);  

  1045     

  1046     return status.Int();  

  1047     }

  1048 

  1049 // -----------------------------------------------------------------------------

  1050 // CIptvMyVideosClient::SendRequestL

  1051 // -----------------------------------------------------------------------------

  1052 //

  1053 TInt CIptvMyVideosClient::SendRequestL(TInt aMessage, CIptvMyVideosGlobalFileId& aSourceFileId, CIptvMyVideosGlobalFolderId& aTargetFolderId)

  1054     {

  1055     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::SendRequestL");

  1056     

  1057     TRequestStatus status;

  1058     TUint32        dataSize = 0;

  1059 

  1060     if (iMsg)

  1061         {

  1062         delete iMsg;

  1063         iMsg = NULL;

  1064         }

  1065 

  1066     dataSize  = aSourceFileId.CountExternalizeSize();

  1067     dataSize += aTargetFolderId.CountExternalizeSize();

  1068 

  1069     iMsg = HBufC8::NewL(dataSize);

  1070     iMsgPtr.Set(iMsg->Des());

  1071 

  1072     RDesWriteStream stream;

  1073     stream.Open(iMsgPtr);

  1074     CleanupClosePushL( stream );

  1075     aSourceFileId.ExternalizeL(stream);

  1076     aTargetFolderId.ExternalizeL(stream);

  1077     CleanupStack::PopAndDestroy( &stream );

  1078 

  1079     iSession.SendRequest(aMessage, iMsgPtr, status);

  1080     User::WaitForRequest(status); 

  1081     

  1082     return status.Int();      

  1083     }

  1084 

  1085 // -----------------------------------------------------------------------------

  1086 // CIptvMyVideosClient::SendRequestL

  1087 // -----------------------------------------------------------------------------

  1088 //

  1089 TInt CIptvMyVideosClient::SendRequestL(TInt aMessage, CIptvMyVideosGlobalFolderId& aFolderIdParam)

  1090     {

  1091     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::SendRequestL");

  1092 

  1093     TRequestStatus status;

  1094     TUint32        dataSize = 0;

  1095 

  1096     if (iMsg)

  1097         {

  1098         delete iMsg;

  1099         iMsg = NULL;

  1100         }

  1101 

  1102     dataSize = aFolderIdParam.CountExternalizeSize();

  1103 

  1104     iMsg = HBufC8::NewL(dataSize);

  1105     iMsgPtr.Set(iMsg->Des());

  1106 

  1107     RDesWriteStream stream;

  1108     stream.Open(iMsgPtr);

  1109     CleanupClosePushL( stream );

  1110     aFolderIdParam.ExternalizeL(stream);

  1111     CleanupStack::PopAndDestroy( &stream );

  1112 

  1113     iSession.SendRequest(aMessage, iMsgPtr, status);

  1114     User::WaitForRequest(status);  

  1115     

  1116     return status.Int(); 

  1117     }

  1118 

  1119 // -----------------------------------------------------------------------------

  1120 // CIptvMyVideosClient::SendRequestL

  1121 // -----------------------------------------------------------------------------

  1122 //

  1123 TInt CIptvMyVideosClient::SendRequestL(TInt aMessage, CIptvMyVideosGlobalFolderId& aFolderId, const TDesC& aName)

  1124     {

  1125     IPTVLOGSTRING_LOW_LEVEL("My Videos Mgr ## CIptvMyVideosClient::SendRequestL");   

  1126     

  1127     TRequestStatus status;

  1128     TUint32        dataSize = 0;

  1129     TUint32        length = aName.Length();

  1130 

  1131     if (iMsg)

  1132         {

  1133         delete iMsg;

  1134         iMsg = NULL;