1 /*

     2 * Copyright (c) 2002-2004 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:   Object to offer some common utility functions to Iptv engine testing*

    15 */

    16 

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <e32Base.h>

    22 #include <mmf/common/mmfcontrollerpluginresolver.h> // CleanupResetAndDestroyPushL

    23 

    24 #include "VCXTestLog.h"

    25 #include "CIptvTestVCApiUtil.h"

    26 #include "CIptvVodContentClient.h"

    27 #include "CIptvVodContentContentFullDetails.h"

    28 #include "CIptvVodContentContentBriefDetails.h"

    29 #include "CIptvVodContentCategoryBriefDetails.h"

    30 #include "CIptvMediaContent.h"

    31 #include "VCXTestLog.h"

    32 #include "CIptvTestVodContentAllDetails.h"

    33 

    34 // EXTERNAL DATA STRUCTURES

    35 

    36 // EXTERNAL FUNCTION PROTOTYPES

    37 

    38 // CONSTANTS

    39 

    40 // MACROS

    41 

    42 // LOCAL CONSTANTS AND MACROS

    43 

    44 // MODULE DATA STRUCTURES

    45 

    46 // LOCAL FUNCTION PROTOTYPES

    47 

    48 // FORWARD DECLARATIONS

    49 

    50 // ============================= LOCAL FUNCTIONS ===============================

    51 

    52 // ============================ MEMBER FUNCTIONS ===============================

    53 

    54 // -----------------------------------------------------------------------------

    55 // CIptvTestVCApiUtil::CIptvTestVCApiUtil

    56 // C++ default constructor can NOT contain any code, that

    57 // might leave.

    58 // -----------------------------------------------------------------------------

    59 //

    60 CIptvTestVCApiUtil::CIptvTestVCApiUtil()

    61     {

    62     }

    63 

    64 // -----------------------------------------------------------------------------

    65 // CIptvTestVCApiUtil::ConstructL

    66 // Symbian 2nd phase constructor can leave.

    67 // -----------------------------------------------------------------------------

    68 //

    69 void CIptvTestVCApiUtil::ConstructL()

    70     {

    71     iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait;

    72     }

    73 

    74 // -----------------------------------------------------------------------------

    75 // CIptvServicesFromFile::NewL

    76 // Two-phased constructor.

    77 // -----------------------------------------------------------------------------

    78 //

    79 CIptvTestVCApiUtil* CIptvTestVCApiUtil::NewL()

    80     {

    81     VCXLOGLO1(">>>CIptvTestVCApiUtil::NewL");

    82     CIptvTestVCApiUtil* self = new( ELeave ) CIptvTestVCApiUtil;

    83 

    84     CleanupStack::PushL( self );

    85     self->ConstructL();

    86     CleanupStack::Pop();

    87 	VCXLOGLO1("<<<CIptvTestVCApiUtil::NewL");

    88     return self;

    89     }

    90 

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

    92 // CIptvServicesFromFile::NewL

    93 // Destructor

    94 // -----------------------------------------------------------------------------

    95 //

    96 CIptvTestVCApiUtil::~CIptvTestVCApiUtil()

    97     {

    98     VCXLOGLO1(">>>CIptvTestVCApiUtil::~CIptvTestSMApiUtil");

    99     if(iActiveSchedulerWait)

   100 	    {

   101 	    ActiveWait(EActiveWaitStop);

   102 	    delete iActiveSchedulerWait;

   103 	    iActiveSchedulerWait = NULL;

   104 	  	}

   105     delete iIptvVodContentClient;

   106     iIptvVodContentClient = NULL;

   107     VCXLOGLO1("<<<CIptvTestVCApiUtil::~CIptvTestVCApiUtil");

   108     }

   109 

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

   111 // CIptvTestVCApiUtil::GetContentIdsL

   112 // Creates CIptvServiceInstance from parameters

   113 // returns pointer to service if succeeded, otherwise NULL

   114 // -----------------------------------------------------------------------------

   115 //

   116 TBool CIptvTestVCApiUtil::GetContentIdsL(TIptvServiceId aServiceId, TUint32 aIAPId, RArray<TIptvContentId>& aContentIdArray, TUint32 aMaxSize, TUint32 aMaxPlaytime)

   117     {

   118    	VCXLOGLO1(">>>CIptvTestVCApiUtil::GetContentIdsL");

   119     TBool rv = TRUE;

   120     TInt resp = KErrNone;

   121 

   122     TUint32 total=0;

   123 

   124     TBuf<255> string;

   125     string.Append(_L(""));

   126 

   127     TTime currentTime;

   128     TTime lastUpdateTime;

   129     TTimeIntervalMinutes minutes;

   130 

   131     iEpgUpdateError = KErrNone;

   132 

   133     currentTime.HomeTime();

   134     CheckVodContentClient( aServiceId );

   135 

   136     //Set IAP

   137     TRAPD(error,resp = iIptvVodContentClient->SetIapL(aIAPId));

   138     if(KErrNone != error || KErrNone != resp)

   139         {

   140         VCXLOGLO1("CIptvTestVCApiUtil: Couldn't set IAP!!");

   141         return FALSE;

   142         }

   143 

   144     resp = iIptvVodContentClient->GetUpdateTimeL(lastUpdateTime);

   145 

   146     if(resp != KErrNone)

   147         {

   148         VCXLOGLO2("CIptvTestVCApiUtil: GetUpdateTimeL error = %d", resp);

   149         VCXLOGLO1("<<<CIptvTestVCApiUtil::GetContentIdsL");

   150         return FALSE;

   151         }

   152 

   153     currentTime.MinutesFrom(lastUpdateTime, minutes);

   154 

   155     if(minutes.Int() > 60)

   156 	    {

   157 	    VCXLOGLO1("Epg update starts");

   158 	    resp = iIptvVodContentClient->UpdateEcgL();

   159 	    if(resp != KErrNone)

   160             {

   161             VCXLOGLO2("CIptvTestVCApiUtil: UpdateEcgL error = %d", resp);

   162             VCXLOGLO1("<<<CIptvTestVCApiUtil::GetContentIdsL");

   163             return FALSE;

   164             }

   165 

   166 	    ActiveWait(EActiveWaitStart);//wait for Epg download

   167 	    if(iEpgUpdateError != KIptvErrorEpgUpdateSuccessed)

   168             {//update failed!!

   169             VCXLOGLO2("CIptvTestVCApiUtil: EpgUpdate error = %d", iEpgUpdateError);

   170             VCXLOGLO1("<<<CIptvTestVCApiUtil::GetContentIdsL");

   171             return FALSE;

   172             }

   173 	    }

   174 

   175    	RPointerArray<CIptvVodContentContentBriefDetails> data;

   176 	CleanupResetAndDestroyPushL(data);

   177 

   178 	VCXLOGLO2("count = %d", data.Count());

   179 

   180     resp = iIptvVodContentClient->GetEcgAllListL(string, 0, 1500, total, data);

   181     if(resp == KErrNone)

   182         {

   183         VCXLOGLO2("totalAmount = %d", total);

   184 

   185         for (TInt i = 0; i < data.Count(); i++)

   186             {

   187             VCXLOGLO2("Content id = %d",data[i]->iContentId);

   188             VCXLOGLO2("Content name = %S", &data[i]->iName);

   189             if( (data[i]->iSize <= aMaxSize || aMaxSize == 0) && (data[i]->iPlaytime < aMaxPlaytime || aMaxPlaytime == 0) )

   190             	{

   191             	aContentIdArray.Append(data[i]->iContentId);

   192             	}

   193             }

   194         }

   195     else

   196         {

   197         VCXLOGLO2("CIptvTestVCApiUtil: GetEcgAllListL error = %d", resp);

   198         rv = FALSE;

   199         }

   200 

   201     VCXLOGLO2("Added %d videos", aContentIdArray.Count());

   202 

   203     CleanupStack::PopAndDestroy(&data);

   204 	data.Close();

   205 

   206     VCXLOGLO1("<<<CIptvTestVCApiUtil::GetContentIdsL");

   207     // check rv!!

   208     return rv;

   209     }

   210 

   211 // -----------------------------------------------------------------------------

   212 // CIptvTestVCApiUtil::GetEcgCategoryListL

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

   214 //

   215 void CIptvTestVCApiUtil::GetEcgCategoryListL(TUint32 aServiceId, TUint32 aParentCategoryId, RPointerArray<CIptvVodContentCategoryBriefDetails>& aCategoryList)

   216     {

   217     VCXLOGLO1(">>>CIptvTestVCApiUtil::GetEcgCategoryListL");

   218     CheckVodContentClient( aServiceId );

   219     User::LeaveIfError( iIptvVodContentClient->GetEcgCategoryListL(aParentCategoryId, aCategoryList) );

   220     for( TInt i = 0; i < aCategoryList.Count(); i++)

   221         {

   222         VCXLOGLO3("CIptvTestVCApiUtil:: Category '%S' with id '%d'", &aCategoryList[i]->iName, aCategoryList[i]->iCategoryId);        

   223         }

   224     VCXLOGLO1("<<<CIptvTestVCApiUtil::GetEcgCategoryListL");

   225     }

   226 

   227 // -----------------------------------------------------------------------------

   228 // CIptvTestVCApiUtil::GetEcgListL

   229 // -----------------------------------------------------------------------------

   230 //

   231 void CIptvTestVCApiUtil::GetEcgListL(TUint32 aServiceId, TUint32 aCategoryId, RPointerArray<CIptvVodContentContentBriefDetails>& aEcgList )

   232     {

   233     VCXLOGLO1(">>>CIptvTestVCApiUtil::GetEcgListL");

   234     TBuf<10> searchString(_L("") );

   235     TUint32 totalAmount = 0;

   236     CheckVodContentClient( aServiceId );

   237     User::LeaveIfError( iIptvVodContentClient->GetEcgListL( aCategoryId, searchString, 0, 0, totalAmount, aEcgList ) );

   238     for( TInt i = 0; i < aEcgList.Count(); i++ )

   239         {

   240         VCXLOGLO4("CIptvTestVCApiUtil:: Content '%S' at index '%d' with id '%d'.", &aEcgList[i]->iName, i, aEcgList[i]->iContentId);                    

   241         }

   242     VCXLOGLO1("<<<CIptvTestVCApiUtil::GetEcgListL");

   243     }

   244 

   245 // -----------------------------------------------------------------------------

   246 // CIptvTestVCApiUtil::GetVodContentContentDetailsL

   247 // -----------------------------------------------------------------------------

   248 //

   249 TInt CIptvTestVCApiUtil::GetVodContentContentDetailsL(TUint32 aServiceId, TUint32 aContentId, CIptvVodContentContentFullDetails& aContentDetails)

   250 	{

   251     VCXLOGLO1(">>>CIptvTestVCApiUtil::GetVodContentContentDetailsL");

   252     CheckVodContentClient( aServiceId );

   253     TInt ret = iIptvVodContentClient->GetContentDetailsL(aContentId, aContentDetails);        

   254     VCXLOGLO1("<<<CIptvTestVCApiUtil::GetVodContentContentDetailsL");

   255     return ret;

   256 	}

   257 

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

   259 // CIptvTestVCApiUtil::GetContentAccessListL

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

   261 //

   262 TInt CIptvTestVCApiUtil::GetContentAccessListL(TUint32 aServiceId, TUint32 aContentId, RPointerArray<CIptvMediaContent>& aCAList)

   263 	{

   264     VCXLOGLO1(">>>CIptvTestVCApiUtil::GetContentAccessListL");

   265     CheckVodContentClient( aServiceId );

   266     TInt ret = iIptvVodContentClient->GetContentAccessListL(aContentId, aCAList);

   267     for( TInt a = 0; a < aCAList.Count(); a++ )

   268         {

   269         VCXLOGLO3("CIptvTestVCApiUtil:: mediaContent index: %d, expression: %d", a, aCAList[a]->iExpression);

   270         }    

   271     VCXLOGLO1("<<<CIptvTestVCApiUtil::GetContentAccessListL");

   272     return ret;

   273 	}

   274 

   275 // -----------------------------------------------------------------------------

   276 // CIptvTestVCApiUtil::GetVodContentAllDetailsListL

   277 // -----------------------------------------------------------------------------

   278 //

   279 void CIptvTestVCApiUtil::GetVodContentAllDetailsListL( TUint32 aServiceId, RPointerArray<CIptvTestVodContentAllDetails>& aDetailsList )

   280 	{

   281     VCXLOGLO1(">>>CIptvTestVCApiUtil::GetVodContentAllDetailsListL");

   282 

   283     CheckVodContentClient( aServiceId );

   284     RPointerArray<CIptvVodContentCategoryBriefDetails> categoryList;

   285     CleanupResetAndDestroyPushL( categoryList );

   286 

   287     User::LeaveIfError( iIptvVodContentClient->GetEcgCategoryListL( 0, categoryList) );

   288 

   289     TInt count = categoryList.Count();

   290 

   291     // Loop categories

   292     for (TInt i = 0; i < count; i++)

   293         {

   294         VCXLOGLO3("CIptvTestVCApiUtil:: Category '%S' with id '%d'", &categoryList[i]->iName, categoryList[i]->iCategoryId);

   295 

   296         RPointerArray<CIptvVodContentContentBriefDetails> ecgList;

   297         CleanupResetAndDestroyPushL( ecgList );

   298 

   299         TBuf<10> searchString(_L("") );

   300         TUint32 totalAmount = 0;

   301         User::LeaveIfError( iIptvVodContentClient->GetEcgListL( categoryList[i]->iCategoryId, searchString, 0, 0, totalAmount, ecgList ) );

   302 

   303         // Loop ECG brief details

   304         for (TInt e = 0; e < ecgList.Count(); e++)

   305             {

   306             CIptvVodContentContentFullDetails* contentDetails = CIptvVodContentContentFullDetails::NewL();

   307             CleanupStack::PushL( contentDetails );

   308 

   309             VCXLOGLO4("CIptvTestVCApiUtil:: Get full details, content '%S' at index '%d' with id '%d'.", &ecgList[e]->iName, e, ecgList[e]->iContentId);            

   310             User::LeaveIfError( iIptvVodContentClient->GetContentDetailsL( ecgList[e]->iContentId, *contentDetails ) );

   311 

   312             // Construct all details 

   313             CIptvTestVodContentAllDetails* allDetails = CIptvTestVodContentAllDetails::NewL();

   314             aDetailsList.Append( allDetails );

   315 

   316             User::LeaveIfError( iIptvVodContentClient->GetContentAccessListL( ecgList[e]->iContentId, allDetails->iMediaContents) );

   317 

   318             TInt mediaCount = allDetails->iMediaContents.Count();

   319             for( TInt a = 0; a < mediaCount; a++ )

   320                 {

   321                 VCXLOGLO3("CIptvTestVCApiUtil:: mediaContent index: %d, expression: %d", a, allDetails->iMediaContents[a]->iExpression);

   322                 }

   323             

   324             allDetails->iCategoryId = categoryList[i]->iCategoryId;

   325             allDetails->iFullDetails = contentDetails;

   326             allDetails->iBriefDetails = ecgList[e];

   327 

   328             CleanupStack::Pop( contentDetails );

   329             }

   330 

   331         CleanupStack::Pop( &ecgList );

   332         ecgList.Reset();

   333         }

   334 

   335     CleanupStack::PopAndDestroy( &categoryList );

   336     VCXLOGLO1("<<<CIptvTestVCApiUtil::GetVodContentAllDetailsListL");

   337 	}

   338 

   339 // -----------------------------------------------------------------------------

   340 // CIptvTestVCApiUtil::CheckVodContentClient

   341 // -----------------------------------------------------------------------------

   342 //

   343 void CIptvTestVCApiUtil::CheckVodContentClient( TInt aServiceId )

   344     {

   345     if( !iIptvVodContentClient || iCurrentService != aServiceId )

   346         {

   347         delete iIptvVodContentClient;

   348         iIptvVodContentClient = NULL;

   349         iCurrentService = aServiceId;

   350         iIptvVodContentClient = CIptvVodContentClient::NewL( aServiceId, *this );

   351         }

   352     }

   353 

   354 // -----------------------------------------------------------------------------

   355 // CIptvTestVCApiUtil::ActiveWait

   356 // Starts or stops CActiveSchedulerWait.

   357 // -----------------------------------------------------------------------------

   358 //

   359 void CIptvTestVCApiUtil::ActiveWait( TIptvTestActiveWaitCmd aActiveWaitCmd )

   360     {

   361     VCXLOGLO1(">>>CIptvTestVCApiUtil::ActiveWait");

   362     VCXLOGLO2("aActiveWaitCmd=%d", aActiveWaitCmd );

   363 

   364     switch( aActiveWaitCmd )

   365         {

   366         case EActiveWaitStart:

   367             {

   368             if( !iActiveSchedulerWait->IsStarted() )

   369                 {

   370                 VCXLOGLO1("iActiveSchedulerWait->Start()");

   371                 iActiveSchedulerWait->Start();

   372                 }

   373             else

   374                 {

   375                 VCXLOGLO1("ActiveSchedulerWait already started");

   376                 }

   377             }

   378             break;

   379         case EActiveWaitStop:

   380             {

   381             if( iActiveSchedulerWait->IsStarted() )

   382                 {

   383             VCXLOGLO1("iActiveSchedulerWait->AsyncStop()");

   384                 iActiveSchedulerWait->AsyncStop();

   385                 }

   386             else

   387                 {

   388                 VCXLOGLO1("ActiveSchedulerWait already stopped");

   389                 }

   390             }

   391             break;

   392         default:

   393             break;

   394         }

   395 

   396     VCXLOGLO1("<<<CIptvTestVCApiUtil::ActiveWait");

   397     }

   398 

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

   400 // CIptvTestVCApiUtil::

   401 //

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

   403 //

   404 void CIptvTestVCApiUtil::HandleEpgManagerMsgL(TInt aMsg, TInt aInfo, TIptvServiceId aServiceId)

   405     {

   406     VCXLOGLO1(">>>CIptvTestVCApiUtil::HandleEpgManagerMsgL");

   407     VCXLOGLO2("CIptvTestVCApiUtil::HandleEpgManagerMsgL: aMsg = %d", aMsg);

   408     VCXLOGLO2("CIptvTestVCApiUtil::HandleEpgManagerMsgL: aInfo = %d", aInfo);

   409     VCXLOGLO2("CIptvTestVCApiUtil::HandleEpgManagerMsgL: aServiceId = %d", aServiceId);

   410 

   411      switch (aMsg)

   412         {

   413         case KIptvErrorEpgUpdateFailed:

   414             {

   415             VCXLOGLO1("CIptvTestVCApiUtil:Epg Update failed");

   416             iEpgUpdateError = aMsg;

   417             ActiveWait(EActiveWaitStop);

   418             /*****

   419             typedef enum

   420             {

   421             EIptvDlNoError,

   422 

   423             //errors before the download starts

   424             EIptvDlMessageAlreadyPending,

   425             EIptvDlTypeNotSupported,

   426               EIptvDlMaxDownloadsExceeded,

   427               KIptvDlCouldNotGetServiceData, //wrong service id?

   428               EIptvDlEpgManagerNotReady,

   429               EIptvDlCouldNotGetContentFullDetails,

   430               EIptvDlFailedToAddNewVideoToMyVideos,

   431               EIptvDlCouldNotConnectToS60DlMgr,

   432               EIptvDlCouldNotSetIapAttrToS60DlMgr,

   433               EIptvDlCouldNotCreateS60Download,

   434               EIptvDlCouldNotStartS60Download,

   435 

   436             //errors during & after download

   437               EIptvDlConnectionFailed, //IAP wrong or no network coverage

   438               EIptvDlAuthFailed,

   439               EIptvDlProxyAuthFailed,

   440               EIptvDlContentNotFound, // HTTP 402

   441               EIptvDlDiskFull,

   442               EIptvDlDestFileInUse,

   443               EIptvDlBadUrl,          //syntax error in url

   444               EIptvDlMmcRemoved,

   445               EIptvDlGeneral          //wrong url, content removed, network does not work, ...

   446               } TIptvDlError;

   447 

   448             *****/

   449             }

   450             break;

   451         case KIptvErrorEpgUpdateSuccessed:

   452             {

   453             VCXLOGLO1("CIptvTestVCApiUtil:Epg Update succeeded");

   454             iEpgUpdateError = aMsg;

   455             ActiveWait(EActiveWaitStop);

   456             }

   457             break;

   458         case KIptvVodUpdateStarted:

   459             {

   460             VCXLOGLO1("CIptvTestVCApiUtil:Epg Update started");

   461             iEpgUpdateError = aMsg;

   462             }

   463             break;

   464         case KIptvVodUpdateNotStarted:

   465             {

   466             VCXLOGLO1("CIptvTestVCApiUtil:Epg Update not started");

   467             iEpgUpdateError = aMsg;

   468             ActiveWait(EActiveWaitStop);

   469             }

   470             break;

   471 

   472         case KIptvErrorVodNoIap:

   473             {

   474             VCXLOGLO1("CIptvTestVCApiUtil:Epg No Iap");

   475             iEpgUpdateError = aMsg;

   476             ActiveWait(EActiveWaitStop);

   477             }

   478             break;

   479 

   480         default:

   481             {

   482              VCXLOGLO1("CIptvTestVCApiUtil::aMsg default case");

   483             iEpgUpdateError = aMsg;

   484             //ActiveWait(EActiveWaitStop);

   485             }

   486         }

   487 

   488     /**********/

   489     VCXLOGLO1("<<<CIptvTestVCApiUtil::aMsg");

   490     }

   491 

   492 //  End of File