1 /*

     2 * Copyright (c) 2008 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:  API extensions for RHttpDownloadMgr

    15 *

    16 */

    17 

    18 // Version : %version: 4 %

    19 

    20 #include "stifutilities.h"

    21 #include "dlmgr_stub.h"

    22 #include "mpxvideo_debug.h"

    23 

    24 CDlMgrTestClass*

    25 CDlMgrTestClass::NewL()

    26 {

    27     MPX_ENTER_EXIT(_L("CDlMgrTestClass::NewL()"));

    28 

    29     StifUtilities* utility = reinterpret_cast<StifUtilities*>( Dll::Tls() );

    30 

    31     if ( ! utility->iDlMgrTester )

    32     {

    33         utility->iDlMgrTester = new CDlMgrTestClass();

    34     }

    35 

    36     return utility->iDlMgrTester;

    37 }

    38 

    39 CDlMgrTestClass::CDlMgrTestClass()

    40 {

    41 }

    42 

    43 CDlMgrTestClass::~CDlMgrTestClass()

    44 {

    45 }

    46 

    47 void

    48 CDlMgrTestClass::AddStifObserver( MStifTestObserver* aStifObserver )

    49 {

    50     MPX_ENTER_EXIT(_L("CDlMgrTestClass::AddStifObserver()"));

    51 

    52     iStifObserver = aStifObserver;

    53 }

    54 

    55 void

    56 CDlMgrTestClass::AttachToDownloadL( const TInt32 aDlId )

    57 {

    58     MPX_ENTER_EXIT(_L("CDlMgrTestClass::AttachToDownloadL()"));

    59 

    60     if ( iStifObserver )

    61     {

    62         TCallbackEvent* event = new TCallbackEvent;

    63         event->iEvent = EConnectedToDownload;

    64         event->iData  = aDlId;

    65         event->iError = KErrNone;

    66         iStifObserver->HandleUtilityEvent( event );

    67     }

    68 }

    69 

    70 void

    71 CDlMgrTestClass::AddDownloadMgr( RHttpDownloadMgr* aDlMgr )

    72 {

    73     iDlMgr = aDlMgr;

    74 }

    75 

    76 void

    77 CDlMgrTestClass::PauseDownload()

    78 {

    79     iDlMgr->PauseAll();

    80 }

    81 

    82 void

    83 CDlMgrTestClass::ResumeDownload()

    84 {

    85     iDlMgr->StartAll();

    86 }

    87 

    88 void

    89 CDlMgrTestClass::CancelDownload()

    90 {

    91     iDlMgr->DeleteAll();

    92 }

    93 

    94 EXPORT_C TInt

    95 RHttpDownload::SetBoolAttribute( const TUint aAttribute, TBool aValue )

    96 {

    97     MPX_DEBUG(_L("RHttpDownload::SetBoolAttribute(%d, %d)"), aAttribute, aValue);

    98 

    99     if ( aAttribute == EDlAttrProgressive )

   100     {

   101         iProgressive = aValue;

   102     }

   103 

   104     return KErrNone;

   105 }

   106 

   107 EXPORT_C TInt

   108 RHttpDownload::GetBoolAttribute( const TUint aAttribute, TBool& aValue )

   109 {

   110     if ( aAttribute == EDlAttrProgressive )

   111     {

   112         aValue = iProgressive;

   113     }

   114 

   115     MPX_DEBUG(_L("RHttpDownload::GetBoolAttribute(%d, %d)"), aAttribute, aValue);

   116 

   117     return KErrNone;

   118 }

   119 

   120 EXPORT_C TInt

   121 RHttpDownload::GetStringAttribute( const TUint /*aAttribute*/, TDes16& /*aValue*/ )

   122 {

   123     return KErrNone;

   124 }

   125 

   126 EXPORT_C TInt

   127 RHttpDownload::SetStringAttribute( const TUint aAttribute, const TDesC16& aValue)

   128 {

   129     MPX_DEBUG(_L("RHttpDownload::SetStringAttribute(%d, %S)"), aAttribute, &aValue);

   130 

   131     if ( aAttribute == EDlAttrLocalFileName )

   132     {

   133         iLocalFile = aValue.Alloc();

   134     }

   135     else if ( aAttribute == EDlAttrDestFilename )

   136     {

   137         iDestFile = aValue.Alloc();

   138     }

   139 

   140     return KErrNone;

   141 }

   142 

   143 EXPORT_C TInt

   144 RHttpDownload::GetStringAttribute( const TUint /*aAttribute*/, TDes8& /*aValue*/ )

   145 {

   146     return KErrNone;

   147 }

   148 

   149 EXPORT_C TInt

   150 RHttpDownload::SetStringAttribute( const TUint /*aAttribute*/, const TDesC8& /*aValue*/ )

   151 {

   152     return KErrNone;

   153 }

   154 

   155 EXPORT_C TInt

   156 RHttpDownload::GetIntAttribute( const TUint aAttribute, TInt32& aValue )

   157 {

   158     switch ( aAttribute )

   159     {

   160         case EDlAttrLength:

   161         {

   162             aValue = iLength;

   163             break;

   164         }

   165         case EDlAttrDownloadedSize:

   166         {

   167             aValue = iSize;

   168             break;

   169         }

   170         case EDlAttrState:

   171         {

   172             aValue = iState;

   173             break;

   174         }

   175         case EDlAttrErrorId:

   176         {

   177             aValue = iErrorId;

   178             break;

   179         }

   180         case EDlAttrGlobalErrorId:

   181         {

   182             aValue = iGlobalError;

   183         }

   184     }

   185 

   186     MPX_DEBUG(_L("RHttpDownload::GetIntAttribute(%d, %d)"), aAttribute, aValue);

   187 

   188     return KErrNone;

   189 }

   190 

   191 EXPORT_C TInt

   192 RHttpDownload::SetIntAttribute( const TUint /*aAttribute*/, TInt32 /*aValue*/ )

   193 {

   194     return KErrNone;

   195 }

   196 

   197 EXPORT_C TInt

   198 RHttpDownload::GetFileHandleAttribute( RFile& /*aFile*/ )

   199 {

   200     return KErrNone;

   201 }

   202 

   203 EXPORT_C TInt

   204 RHttpDownload::SetFileHandleAttribute( RFile& /*aFile*/ )

   205 {

   206     return KErrNone;

   207 }

   208 

   209 EXPORT_C TInt

   210 RHttpDownload::Start()

   211 {

   212     MPX_DEBUG(_L("RHttpDownload::Start()"));

   213 

   214     iState = EHttpDlInprogress;

   215 

   216     RFile file;

   217     _LIT(KFileName, "\\vhpp_dlmgr.txt");

   218 

   219     RFs fs;

   220     fs.Connect();

   221 

   222     file.Open( fs, KFileName, EFileRead | EFileShareAny );

   223 

   224     TInt dlSize;

   225     HBufC8* fBuf = HBufC8::NewL( 16 );

   226     TPtr8 fileBuf = fBuf->Des();

   227 

   228     file.Read( fileBuf, 16 );

   229 

   230     TLex8 number( fileBuf );

   231     number.Val( dlSize );

   232 

   233     iSize = dlSize;

   234 

   235     file.Close();

   236     fs.Close();

   237 

   238     iServer->iUpdateSize->Start(

   239         TCallBack( RHttpDownloadMgr::UpdateDownloadProgress, iServer ) );

   240 

   241     return KErrNone;

   242 }

   243 

   244 EXPORT_C TInt

   245 RHttpDownload::Pause()

   246 {

   247     MPX_DEBUG(_L("RHttpDownload::Pause()"));

   248 

   249     iState = EHttpDlPaused;

   250 

   251     iServer->iUpdateSize->Start(

   252         TCallBack( RHttpDownloadMgr::UpdateDownloadProgress, iServer ) );

   253 

   254     return KErrNone;

   255 }

   256 

   257 EXPORT_C TInt

   258 RHttpDownload::Delete()

   259 {

   260     MPX_DEBUG(_L("RHttpDownload::Delete()"));

   261 

   262     iState = EHttpDlFailed;

   263 

   264     iServer->iUpdateSize->Start(

   265         TCallBack( RHttpDownloadMgr::UpdateDownloadProgress, iServer ) );

   266 

   267     return KErrNone;

   268 }

   269 

   270 EXPORT_C TInt

   271 RHttpDownload::Move()

   272 {

   273     MPX_DEBUG(_L("RHttpDownload::Move()"));

   274     return KErrNone;

   275 }

   276 

   277 EXPORT_C TInt

   278 RHttpDownload::Reset()

   279 {

   280     MPX_DEBUG(_L("RHttpDownload::Reset()"));

   281     return KErrNone;

   282 }

   283 

   284 RHttpDownload::RHttpDownload( RHttpDownloadMgr* aServer )

   285 {

   286     iServer = aServer;

   287 }

   288 

   289 RHttpDownload::~RHttpDownload()

   290 {

   291     if ( iLocalFile )

   292     {

   293         delete iLocalFile;

   294     }

   295 

   296     if ( iDestFile )

   297     {

   298         delete iDestFile;

   299     }

   300 }

   301 

   302 EXPORT_C

   303 RHttpDownloadMgr::RHttpDownloadMgr()

   304 {

   305     MPX_DEBUG(_L("RHttpDownloadMgr::RHttpDownloadMgr()"));

   306 

   307     iDownloadArray = new (ELeave) CArrayPtrFlat< RHttpDownload >( 1 );

   308 

   309     iObservers = new (ELeave) CDownloadMgrObserver( 1 );

   310 

   311     iUpdateSize = CIdle::NewL( CActive::EPriorityLow );

   312 

   313     iDlMgrCallback = CDlMgrTestClass::NewL();

   314 

   315     iDlMgrCallback->AddDownloadMgr( this );

   316 }

   317 

   318 RHttpDownloadMgr::~RHttpDownloadMgr()

   319 {

   320     delete iDownloadArray;

   321     delete iObservers;

   322 

   323     if ( iUpdateSize->IsActive() )

   324     {

   325         iUpdateSize->Cancel();

   326     }

   327 

   328     delete iUpdateSize;

   329 

   330     delete iDlMgrCallback;

   331 }

   332 

   333 EXPORT_C void

   334 RHttpDownloadMgr::ConnectL( TUid /*aAppUid*/, MHttpDownloadMgrObserver& aObserver, TBool /*aMaster*/ )

   335 {

   336     MPX_DEBUG(_L("RHttpDownloadMgr::ConnectL()"));

   337 

   338     iObservers->AppendL( &aObserver );

   339 }

   340 

   341 EXPORT_C TVersion

   342 RHttpDownloadMgr::Version() const

   343 {

   344     TVersion temp;

   345 

   346     return temp;

   347 }

   348 

   349 EXPORT_C void

   350 RHttpDownloadMgr::Close()

   351 {

   352 }

   353 

   354 EXPORT_C const CDownloadArray&

   355 RHttpDownloadMgr::CurrentDownloads() const

   356 {

   357     return (*iDownloadArray);

   358 }

   359 

   360 EXPORT_C RHttpDownload&

   361 RHttpDownloadMgr::CreateDownloadL( const TDesC8& /*aUrl*/, TBool& /*aResult*/ )

   362 {

   363     RHttpDownload* dl = new RHttpDownload( this );

   364 

   365     iDownloadArray->AppendL( dl );

   366 

   367     return *(*iDownloadArray)[0];

   368 }

   369 

   370 EXPORT_C RHttpDownload&

   371 RHttpDownloadMgr::CreateDownloadL( const TDesC8& /*aUrl*/ )

   372 {

   373     RHttpDownload* dl = new RHttpDownload( this );

   374 

   375     iDownloadArray->AppendL( dl );

   376 

   377     return *(*iDownloadArray)[0];

   378 }

   379 

   380 EXPORT_C RHttpDownload&

   381 RHttpDownloadMgr::CreateClientSideDownloadL( TInt /*aHttpTransaction*/, TBool& /*aResult*/ )

   382 {

   383     return *(*iDownloadArray)[0];

   384 }

   385 

   386 EXPORT_C RHttpDownload&

   387 RHttpDownloadMgr::CreateCodDownloadL( const TDesC8& /*aUrl*/, const TDesC8& /*aBuf*/, const TDesC8& /*aMimeType*/, CEikonEnv* /*aEikEnv*/, TBool& /*aResult*/ )

   388 {

   389     return *(*iDownloadArray)[0];

   390 }

   391 

   392 EXPORT_C RHttpDownload*

   393 RHttpDownloadMgr::FindDownload( const TDesC8& /*aUrl*/, const TDesC8& /*aMsgBody*/ )

   394 {

   395     return (*iDownloadArray)[0];

   396 }

   397 

   398 EXPORT_C TInt

   399 RHttpDownloadMgr::PauseAll()

   400 {

   401     MPX_DEBUG(_L("RHttpDownloadMgr::PauseAll()"));

   402 

   403     (*iDownloadArray)[0]->Pause();

   404 

   405     return KErrNone;

   406 }

   407 

   408 EXPORT_C TInt

   409 RHttpDownloadMgr::StartAll()

   410 {

   411     MPX_DEBUG(_L("RHttpDownloadMgr::PauseAll()"));

   412 

   413     (*iDownloadArray)[0]->Start();

   414 

   415     return KErrNone;

   416 }

   417 

   418 EXPORT_C TInt

   419 RHttpDownloadMgr::ResetAll()

   420 {

   421     return KErrNone;

   422 }

   423 

   424 EXPORT_C TInt

   425 RHttpDownloadMgr::DeleteAll()

   426 {

   427     (*iDownloadArray)[0]->Delete();

   428 

   429     return KErrNone;

   430 }

   431 

   432 EXPORT_C TInt

   433 RHttpDownloadMgr::Disconnect()

   434 {

   435     return KErrNone;

   436 }

   437 

   438 EXPORT_C TInt

   439 RHttpDownloadMgr::GetIntAttribute( const TUint /*aAttribute*/, TInt32& /*aValue*/ )

   440 {

   441     return KErrNone;

   442 }

   443 

   444 EXPORT_C TInt

   445 RHttpDownloadMgr::GetBoolAttribute( const TUint /*aAttribute*/, TBool& /*aValue*/ )

   446 {

   447     return KErrNone;

   448 }

   449 

   450 EXPORT_C TInt

   451 RHttpDownloadMgr::GetStringAttribute( const TUint /*aAttribute*/, TDes16& /*aValue*/  )

   452 {

   453     return KErrNone;

   454 }

   455 

   456 EXPORT_C TInt

   457 RHttpDownloadMgr::GetStringAttribute( const TUint /*aAttribute*/, TDes8& /*aValue*/ )

   458 {

   459     return KErrNone;

   460 }

   461 

   462 EXPORT_C TInt

   463 RHttpDownloadMgr::SetIntAttribute( const TUint /*aAttribute*/, TInt32 /*aValue*/ )

   464 {

   465     return KErrNone;

   466 }

   467 

   468 EXPORT_C TInt

   469 RHttpDownloadMgr::SetBoolAttribute( const TUint /*aAttribute*/, TBool /*aValue*/ )

   470 {

   471     return KErrNone;

   472 }

   473 

   474 EXPORT_C TInt

   475 RHttpDownloadMgr::SetStringAttribute( const TUint /*aAttribute*/, const TDesC16& /*aValue*/ )

   476 {

   477     return KErrNone;

   478 }

   479 

   480 EXPORT_C TInt

   481 RHttpDownloadMgr::SetStringAttribute( const TUint /*aAttribute*/, const TDesC8& /*aValue*/ )

   482 {

   483     return KErrNone;

   484 }

   485 

   486 EXPORT_C TInt

   487 RHttpDownloadMgr::SetDefaultIntAttribute( const TUint /*aAttribute*/, TInt32 /*aValue*/ )

   488 {

   489     return KErrNone;

   490 }

   491 

   492 EXPORT_C TInt

   493 RHttpDownloadMgr::SetDefaultBoolAttribute( const TUint /*aAttribute*/, TBool /*aValue*/ )

   494 {

   495     return KErrNone;

   496 }

   497 

   498 EXPORT_C TInt

   499 RHttpDownloadMgr::SetDefaultStringAttribute( const TUint /*aAttribute*/, const TDesC16& /*aValue*/ )

   500 {

   501     return KErrNone;

   502 }

   503 

   504 EXPORT_C TInt

   505 RHttpDownloadMgr::SetDefaultStringAttribute( const TUint /*aAttribute*/, const TDesC8& /*aValue*/ )

   506 {

   507     return KErrNone;

   508 }

   509 

   510 EXPORT_C void

   511 RHttpDownloadMgr::AddObserverL( MHttpDownloadMgrObserver& /*aObserver*/ )

   512 {

   513 }

   514 

   515 EXPORT_C void

   516 RHttpDownloadMgr::RemoveObserver( MHttpDownloadMgrObserver& /*aObserver*/ )

   517 {

   518 }

   519 

   520 EXPORT_C void

   521 RHttpDownloadMgr::SetNextUriObserver( MHttpDownloadMgrNextUriObserver* /*aObserver*/ )

   522 {

   523 }

   524 

   525 void

   526 RHttpDownloadMgr::DoUpdateDownloadProgress()

   527 {

   528     MPX_ENTER_EXIT(_L("RHttpDownloadMgr::DoUpdateDownloadProgress()"));

   529 

   530     RHttpDownload* dl = (*iDownloadArray)[0];

   531 

   532     THttpDownloadEvent event;

   533 

   534     event.iDownloadState = (THttpDownloadState)dl->iState;

   535     event.iProgressState = EHttpProgResponseBodyReceived;

   536 

   537     MPX_DEBUG(_L("RHttpDownloadMgr::DoUpdateDownloadProgress() dl->iSize=%d"), dl->iSize );

   538 

   539     if ( dl->iState == EHttpDlInprogress )

   540     {

   541         if ( dl->iSize >= dl->iLength )

   542         {

   543             dl->iState = EHttpDlCompleted;

   544 

   545             event.iDownloadState = (THttpDownloadState)dl->iState;

   546             event.iProgressState = EHttpProgNone;

   547         }

   548     }

   549 

   550     (*iObservers)[0]->HandleDMgrEventL( *dl, event );

   551 }

   552 

   553 TInt

   554 RHttpDownloadMgr::UpdateDownloadProgress( TAny* aPtr )

   555 {

   556     MPX_ENTER_EXIT(_L("RHttpDownloadMgr::UpdateDownloadProgress()"));

   557 

   558     static_cast<RHttpDownloadMgr*>(aPtr)->DoUpdateDownloadProgress();

   559 

   560     return KErrNone;

   561 }

   562 

   563 EXPORT_C

   564 RHttpDownloadMgrApiExt::RHttpDownloadMgrApiExt()

   565 {

   566     MPX_DEBUG(_L("RHttpDownloadMgrApiExt::RHttpDownloadMgrApiExt()"));

   567 }

   568 

   569 EXPORT_C RHttpDownload&

   570 RHttpDownloadMgrApiExt::AttachToDownloadL( const TInt32 aDlId )

   571 {

   572     MPX_DEBUG(_L("RHttpDownloadMgrApiExt::AttachToDownloadL(%d)"), aDlId);

   573 

   574     RHttpDownload* dl = new RHttpDownload( this );

   575 

   576     dl->iErrorId = KErrNone;

   577     dl->iGlobalError = KErrNone;

   578 

   579     iDlMgrCallback->AttachToDownloadL( aDlId );

   580 

   581     dl->iState   = EHttpDlInprogress;

   582     dl->iSize    = 25;

   583     dl->iLength  = 100;

   584 

   585     iDownloadArray->AppendL( dl );

   586 

   587     return *(*iDownloadArray)[0];

   588 }