MCL/sf/mw/appinstall: comparison ncdengine/engine/transport/src/catalogshttpdownloadmanagerimpl.cpp

equal deleted inserted replaced

-:7333d7932ef7
+:8b7f4e561641
 /*
-* Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 #include "catalogsnetworkmanager.h"
 #include "catalogshttpsessionimpl.h"
 #include "catalogsconnection.h"
 #include "catalogsdebug.h"
-#include <QString>
-#include <QVector>
-#include <QList>
-#include <downloadevent.h>
-#include <xqconversions.h>
 // ======== MEMBER FUNCTIONS ========
 // ---------------------------------------------------------------------------
 // Creator
 // ---------------------------------------------------------------------------
 aTransactionManager,
 aConnectionManager );
 DLTRACE(("constructor ok"));
 CleanupStack::PushL( self );
 self->ConstructL( aCleanup );
 CleanupStack::Pop( self );
 return self;
 }
 CCatalogsHttpDownloadManager::~CCatalogsHttpDownloadManager()
 {
 DLTRACEIN( ( "" ) );
 Cancel();
-// HLa iEventQueue.Close();
+iEventQueue.Close();
 // Release downloads
 TInt count = iDownloads.Count() - 1;
 while( count > -1 )
 {
 if ( iNetworkManager )
 {
 iNetworkManager->RemoveObserver( *this );
 }
+if ( iDmgr.Handle() )
-if ( iDmgr )
 {
 DLTRACE(("We were connected to DL manager"));
 DeleteHangingDownloads();
 }
 // Close download manager session
-iDmgr->removeAll();
+iDmgr.Close();
 delete iDefaultConfig;
 iManager.Release();
 iFs.Close();
 void CCatalogsHttpDownloadManager::DeleteHangingDownloads()
 {
 DLTRACEIN((""));
 // This pauses all downloads in addition to disconnecting
-	iDmgr->pauseAll();
+iDmgr.Disconnect();
-TInt count = iDownloads.Count();
+const CDownloadArray& downloads( iDmgr.CurrentDownloads() );
-for ( TInt i = 0; i < count; ++i )
-{
+TInt count = downloads.Count();
-TInt32 deleteStatus = 0;
+while( count-- )
-deleteStatus = dynamic_cast<CCatalogsHttpDownload*>(iDownloads[i])->GetStatusState();
+{
+RHttpDownload& dl = *( downloads[ count ] );
-if ( deleteStatus == CCatalogsHttpDownload::EDownloadCanBeDeleted )
+TInt32 deleteStatus = 0;
+dl.GetIntAttribute( EDlAttrUserData, deleteStatus );
+DLTRACE(("DeleteStatus: %d", deleteStatus ));
+if ( deleteStatus == CCatalogsHttpDownload::EDownloadCanBeDeleted )
 {
 DLTRACE(("Deleting download"));
-iDmgr->removeOne(dynamic_cast<CCatalogsHttpDownload*>(iDownloads[i])->GetDownload());
+dl.Delete();
 }
-}
+}
 }
 // ---------------------------------------------------------------------------
 // Download creator
 // ---------------------------------------------------------------------------
 MCatalogsHttpOperation* CCatalogsHttpDownloadManager::CreateDownloadL(
 const TDesC8& aUrl, TBool /* aStart */, MCatalogsHttpObserver* aObserver )
 {
 DLTRACEIN((""));
 // Create a new download
-QString Url = XQConversions::s60Desc8ToQString(aUrl);
-iDownload = iDmgr->createDownload( Url );
 CCatalogsHttpDownload* dl = CCatalogsHttpDownload::NewLC(
 *this,
 //download,
-iDownload,
+NULL,
 *iDefaultConfig );
 dl->SetUriL( aUrl );
 dl->SetFileServerSession( iFs );
-// If the given observer != NULL, set it as the observer for the download
+// If the given observer != NULL, set it as the observer for the download
 if ( aObserver )
 {
 dl->Config().SetObserver( aObserver );
 }
 const TCatalogsTransportOperationId& aId ) const
 {
 TInt count = iDownloads.Count();
 for ( TInt i = 0; i < count; ++i )
 {
 if ( iDownloads[i]->OperationId() == aId )
 {
 return iDownloads[i];
 }
 }
 const TCatalogsConnectionMethod& aMethod )
 {
 DLTRACEIN((""));
 if ( aMethod != iCurrentAp )
 {
-		try
-		{
 DLTRACE( ( "Set AP, type: %d, id: %u, apn: %d",
 aMethod.iType, aMethod.iId, aMethod.iApnId ));
-		 iDmgr->pauseAll();
+User::LeaveIfError( iDmgr.Disconnect() );
+User::LeaveIfError( iDmgr.SetIntAttribute( EDlMgrIap, aMethod.iApnId ) );
 iCurrentAp = aMethod;
 DLTRACE(("AP set"));
-		}
-		 catch(const std::exception& exception)
-		 {
-		 qt_symbian_exception2LeaveL(exception);
-		 }
 }
 }
 // ---------------------------------------------------------------------------
 //
 TInt32 CCatalogsHttpDownloadManager::SessionId() const
 {
 return iSessionId;
 }
 // ---------------------------------------------------------------------------
 // Handles download manager events
 // ---------------------------------------------------------------------------
 //
-void CCatalogsHttpDownloadManager::downloadMgrEventRecieved(WRT::DownloadManagerEvent* dlmEvent)
+void CCatalogsHttpDownloadManager::HandleDMgrEventL( RHttpDownload& aDownload,
-{
+	THttpDownloadEvent aEvent )
+{
-	switch(dlmEvent ->type())
+DLTRACEIN(( "Dl state: %i, pr: %i, DL: %x", aEvent.iDownloadState,
-		{
+aEvent.iProgressState, &aDownload ));
-default:
+TDownloadEvent event( aDownload, aEvent );
-	break;
-		};
+if ( IsOneOf( aEvent.iDownloadState, EHttpDlDeleted, EHttpDlDeleting ) )
+{
+DLTRACEOUT(("Download was deleted"))
-}
+RemoveUnhandledEvents( event );
+}
+// Handle everything but Download name change events
+else if ( aEvent.iProgressState != EHttpProgDlNameChanged )
+{
+DLTRACE(("Adding event to queue"));
+if ( aEvent.iProgressState == EHttpProgResponseBodyReceived )
+{
+// Filter unhandled progress events from the queue
+RemoveUnhandledProgressEvents( event );
+}
+iEventQueue.AppendL( event );
+ContinueEventHandling();
+}
+}
 // ---------------------------------------------------------------------------
 // Accesspoint observer
 // ---------------------------------------------------------------------------
 const TCatalogsAccessPointEvent& aEvent )
 {
 DLTRACEIN((""));
 if ( aEvent == ECatalogsAccessPointClosed )
 {
-		try
-		{
 DLTRACE(("Disconnecting download manager"));
+User::LeaveIfError( iDmgr.Disconnect() );
-		iDmgr->pauseAll();
-	}
-		catch(const std::exception& exception)
-{
-qt_symbian_exception2LeaveL(exception);
-}
 }
 }
 // ---------------------------------------------------------------------------
 DLTRACEIN((""));
 User::LeaveIfError( iFs.Connect() );
 // shared so that RFiles can be given to Download manager
 User::LeaveIfError( iFs.ShareProtected() );
-	QString DmgrUid(QString::number(KNCDEngineAppID));
-iDmgr =  new DownloadManager(DmgrUid);
-iDmgr->initialize();
-iQTmgr = new CCatalogsHttpQTDownloadManager(this,iDmgr);
 TUid sessionId( TUid::Uid( iSessionId ) );
 if ( aCleanup )
 {
 DLTRACE(("Cleaning download manager before connecting"));
 TInt err = KErrNone;
 TInt retries = KCatalogsDlMgrConnectRetryAttempts;
 do
 {
+TRAP( err, iDmgr.ConnectL( sessionId, *this, ETrue ) );
 if ( err != KErrNone )
 {
 DLERROR(("DL manager connection failed with err: %d, retry attempts left",
 err, retries ));
 // This halts the whole thread which is not nice but shouldn't
 iDefaultConfig = CCatalogsHttpConfig::NewL();
 iNetworkManager = &CCatalogsHttpSessionManager::NetworkManagerL();
 iNetworkManager->AddObserverL( *this );
+iDmgr.SetIntAttribute( EDlMgrExitAction, EExitPause );
 // Restore downloads from previous sessions
-//    RestoreDownloadsL();
+RestoreDownloadsL();
 DLTRACEOUT((""));
+}
-}
-DownloadManager* CCatalogsHttpDownloadManager::GetDownloadManager()
-{
-	return iDmgr;
-}
 // ---------------------------------------------------------------------------
 // Restore downloads from previous session
 // ---------------------------------------------------------------------------
 //
 void CCatalogsHttpDownloadManager::RestoreDownloadsL()
 {
 DLTRACEIN((""));
+const CDownloadArray& downloads = iDmgr.CurrentDownloads();
-const TInt KMaxUrlLength = 2048; // HLa
 TBuf8<KMaxUrlLength> url;
+TBuf<KMaxPath> filename;
-QList<WRT::Download*> downloads = iDmgr->currentDownloads();
 // Go through downloads, create wrappers for DL manager downloads and
 // add them to HttpDownloadManager
-for ( TInt i = 0; i < downloads.size(); ++i )
+for ( TInt i = 0; i < downloads.Count(); ++i )
 {
 DLTRACE(( "Restoring dl %i", i ));
-WRT::Download *dlPtr = downloads[i];
+RHttpDownload* dlPtr = downloads[i];
 // Create the download and push it to cleanup stack
 CCatalogsHttpDownload* dl = CCatalogsHttpDownload::NewLC( *this,
 dlPtr, *iDefaultConfig );
 // set file server session
 dl->SetFileServerSession( iFs );
-QString name   =  dlPtr->attribute(FileName).toString();
+dlPtr->GetStringAttribute( EDlAttrDestFilename, filename );
-TBuf<KMaxPath> filename(name.utf16());
 // Separate the filename from the path
 TParsePtrC parser( filename );
 if ( parser.PathPresent() )
 // ---------------------------------------------------------------------------
 // Finds the index for the given download in iDownloads
 // ---------------------------------------------------------------------------
 //
-/* HLa
 TInt CCatalogsHttpDownloadManager::FindInDownloads(
 const RCatalogsHttpOperationArray& aArray,
 RHttpDownload* aDownload ) const
 {
 DASSERT( aDownload );
 TInt32 id = 0;
-//aDownload->GetIntAttribute( EDlAttrId, id );
+aDownload->GetIntAttribute( EDlAttrId, id );
 TInt count = aArray.Count();
 for ( TInt i = 0; i < count; ++i )
 {
 if ( aArray[ i ]->OperationId().SecondaryId() == id )
 return i;
 }
 }
 return KErrNotFound;
 }
-*/
 // ---------------------------------------------------------------------------
 // Finds the index for the given download in the given array
 // ---------------------------------------------------------------------------
 //
 TInt CCatalogsHttpDownloadManager::StartOperation(
 MCatalogsHttpOperation* aOperation )
 {
 DLTRACEIN(( "" ));
 DASSERT( aOperation );
-TInt err = iManager.StartOperation( aOperation, EFalse );
+TInt err = iManager.StartOperation( aOperation );
 if ( err == KErrNone || err == KCatalogsHttpOperationQueued )
 {
 TInt err2 = MoveRestoredDlToCurrentDls( *aOperation );
 // Check for unwanted errors
 if ( err2 != KErrNone && err2 != KErrNotFound )
 void CCatalogsHttpDownloadManager::RunL()
 {
 DLTRACEIN(( "Event queue count: %d", iEventQueue.Count() ));
 // Handle the event queue
-/* HLa
 while ( iEventQueue.Count() )
 {
 TDownloadEvent dlEvent( iEventQueue[0] );
 iEventQueue.Remove( 0 );
 DLERROR(( "Observer was NULL" ));
 User::Leave( eventErr );
 }
 }
 }
-*/
 }
 void CCatalogsHttpDownloadManager::DoCancel()
 {
 void CCatalogsHttpDownloadManager::ContinueEventHandling()
 {
 DLTRACEIN((""));
-/* HLa
 if( iEventQueue.Count() && !IsActive() )
 {
 DLTRACE(("More events to handle"));
 iStatus = KRequestPending;
 SetActive();
 TRequestStatus* status = &iStatus;
 User::RequestComplete( status, KErrNone );
 }
-*/
+}
-}
-/* HLa
 void CCatalogsHttpDownloadManager::RemoveUnhandledEvents(
 const TDownloadEvent& aEvent )
 {
 DLTRACEIN((""));
 TInt index = iEventQueue.Count();
 DLTRACE(("Removing unhandled event"));
 iEventQueue.Remove( index );
 }
 }
 }
-*/
-/* HLa
 void CCatalogsHttpDownloadManager::RemoveUnhandledProgressEvents(
 const TDownloadEvent& aEvent )
 {
 DLTRACEIN((""));
 TInt index = iEventQueue.Count();
 iEventQueue.Remove( index );
 break;
 }
 }
 }
-*/
 TInt CCatalogsHttpDownloadManager::NewDownloadId()
 {
 return ++iCurrentDlId;
 }
-Download& CCatalogsHttpDownloadManager::CreatePlatformDownloadL(
+RHttpDownload& CCatalogsHttpDownloadManager::CreatePlatformDownloadL(
 const TDesC8& aUrl )
 {
+return iDmgr.CreateDownloadL( aUrl );
-	QString myString=	QString::fromRawData( reinterpret_cast<const QChar*>(aUrl.Ptr()),aUrl.Length());
+}
-return *(iDmgr->createDownload( myString ));
-}
-CCatalogsHttpQTDownloadManager::CCatalogsHttpQTDownloadManager(CCatalogsHttpDownloadManager* aDownloadManager,DownloadManager* aDmgr)
-	{
-		iDownloadManager = aDownloadManager;
-		iDmgr = aDmgr;
-		connect(iDmgr, SIGNAL(downloadManagerEvent(DownloadManagerEvent*)), this,SLOT(downloadMgrEventRecieved(DownloadManagerEvent*)));
-	}
-void CCatalogsHttpQTDownloadManager::downloadMgrEventRecieved(DownloadManagerEvent* aEvent)
-	{
-		iDownloadManager->downloadMgrEventRecieved(aEvent);
-	}

branch	RCL_3
changeset 26	8b7f4e561641
parent 25	7333d7932ef7