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

equal deleted inserted replaced

-:5cc91383ab1e
+:7333d7932ef7
 #include <bautils.h>
 #include <e32err.h>
 #include <DocumentHandler.h>
 #include <apmstd.h> // TDataType
 #include <escapeutils.h>
+#include <downloadmanager.h>
+#include <cmmanager.h>
+#include <cmdestination.h>
+#include <uri8.h>
+#include <QtGlobal>
+#include <QStringList>
+#include <xqconversions.h>
 #include "catalogshttpdownloadmanagerimpl.h"
 #include "catalogshttpobserver.h"
 #include "catalogshttpconfigimpl.h"
 #include "catalogskeyvaluepair.h"
 // Creator
 // ---------------------------------------------------------------------------
 //
 CCatalogsHttpDownload* CCatalogsHttpDownload::NewLC(
 CCatalogsHttpDownloadManager& aOwner,
-RHttpDownload* aDownload,
+Download* aDownload,
 const CCatalogsHttpConfig& aConfig )
 {
 CCatalogsHttpDownload* self = new( ELeave ) CCatalogsHttpDownload(
 aOwner,
 aDownload );
 SetDeleteState( EDownloadPaused );
 }
 else
 {
 DLTRACE(( "Deleting download" ));
-iDownload->Delete();
+iOwner.GetDownloadManager()->removeOne(iDownload);
 if ( iState.iOperationState != ECatalogsHttpOpCompleted )
 {
 // Ensure that temp files are really deleted
 DeleteFiles();
 iCancelled = ETrue;
 if ( iDownload )
 {
 iObserver = NULL;
 TInt32 state = 0;
-iDownload->GetIntAttribute( EDlAttrState, state );
+state = (Download::State)iDownload->attribute(State).toInt();
 if ( IsOneOf(
 static_cast<THttpDownloadState>( state ),
 EHttpDlCreated,
 EHttpDlPaused,
 EHttpDlCompleted,
 // just restarted when it's resumed
 DLTRACE(("Thread semaphore count: %d", RThread().RequestCount() ));
 TInt err = KErrNone;
 if ( iDownload )
 {
-err = iDownload->Pause();
+					    try
+							{
+							iDownload->pause();
+							}
+			        catch(const std::exception& exception)
+			        	{
+							 err = qt_symbian_exception2Error(exception);
+			        	}
 }
 DLTRACE(("Pause err: %d", err ));
 if ( err == KErrNone )
 {
 DLTRACEIN((""));
 // We get the content size only once in order to minimize
 // client-server communication with the Download manager server
 if ( iDownload && iContentSize <= 0 )
 {
-iDownload->GetIntAttribute( EDlAttrLength, iContentSize );
+iContentSize = iDownload->attribute(TotalSize).toInt();
 DLTRACE(("Content size from download: %i", iContentSize ));
 }
 return iContentSize;
 }
 TBool CCatalogsHttpDownload::IsPausable() const
 {
 TBool pausable = ETrue;
 if ( iDownload )
 {
-iDownload->GetBoolAttribute( EDlAttrPausable, pausable );
+pausable=iDownload->attribute(Pausable).toBool();
 }
 return pausable;
 }
 {
 DLTRACEIN((""));
 iConfig->InternalizeL( aStream );
 HBufC8* contentType = NULL;
 InternalizeDesL( contentType, aStream );
-if ( contentType->Length() > KMaxContentTypeLength )
+// HLa if ( contentType->Length() > KMaxContentTypeLength )
+if ( contentType->Length() > 256 )
 {
 DeletePtr( contentType );
 DLERROR(("Content type was too long, leaving with KErrCorrupt"));
 User::Leave( KErrCorrupt );
 }
 return iOwner.OperationPriorityChanged( this );
 }
 return KErrNone;
 }
+void CCatalogsHttpDownload::HandledownloadEventL(DownloadEvent& aEvent)
+{
+	switch(aEvent.type())
+	{
+		case DownloadEvent::Started:
+			break;
+		case DownloadEvent::Error:
+		case DownloadEvent::Failed:
+		case DownloadEvent::NetworkLoss:
+		case DownloadEvent::ConnectionNeeded:
+		case DownloadEvent::ConnectionDisconnected:
+			{
+		    TInt32 errorId = -1;
+		    if ( aEvent.type() == DownloadEvent::NetworkLoss  ||
+		         aEvent.type() == DownloadEvent::ConnectionNeeded ||
+		         aEvent.type() == DownloadEvent::ConnectionDisconnected )
+		        {
+		        errorId = WRT::ConnectionFailed;
+		        }
+SetTransferring( EFalse );
+errorId = iDownload->attribute(LastError).toInt();
+if ( errorId > 0 )
+{
+// Symbian error codes are always negative numbers
+errorId =  -1 * errorId;
+}
+/*if ( ( errorId == ConnectionFailed ||
+errorId == TransactionFailed ))
+{
+DLTRACE(("Try to reconnect"));
+iReconnectWhenFail = EFalse;
+iDownload->start();
+break;
+}
+else if ( errorId == ContentExpired ||
+errorId == PartialContentModified )
+{
+DLTRACE(("Content has changed, reset and restart"));
+iReconnectWhenFail = EFalse;
+iDownload->cancel();
+iDownload->start();
+break;
+}*/
+iState.iOperationState = ECatalogsHttpOpFailed;
+TBool deleted = EFalse;
+if ( iObserver )
+{
+// Determine whether failure was due to a HTTP error or some
+// other error.
+//if ( errorId >= 400 )
+//    {
+//     deleted = iObserver->HandleHttpError(
+//     *this, TCatalogsHttpError(
+//      ECatalogsHttpErrorHttp,
+//      errorId ) );
+//      }
+//  else
+{
+AddRef();
+//iOwner.ConnectionManager().ReportConnectionError(
+//               TCatalogsConnectionMethod(), errorId );
+if ( iRefCount > 1 )
+{
+deleted = iObserver->HandleHttpError(
+*this, TCatalogsHttpError(
+ECatalogsHttpErrorGeneral, errorId ) );
+}
+else
+{
+deleted = ETrue;
+}
+Release();
+}
+}
+if ( !deleted )
+{
+iOwner.CompleteOperation( this );
+iState.iProgressState = ECatalogsHttpDone;
+}
+			}
+			break;
+		case DownloadEvent::Cancelled:
+			break;
+		case DownloadEvent::ContentTypeChanged:
+			break;
+		case DownloadEvent::HeadersReceived:
+			{
+					// Read the response headers from platform DL manager
+			UpdateResponseHeadersL();
+			UpdateContentType();
+		  }
+			break;
+		case DownloadEvent::Completed:
+			  {
+// move/rename temp file as the target file
+TRAPD( err, MoveFileL() );
+// DLMAIN-546, delete DL manager's download before starting
+// the next one so that downloads don't jam, again
+if ( iDownload )
+{
+	iTransferredSize = iDownload->attribute(DownloadedSize).toInt();
+DLTRACE(("Deleting download"));
+DeletePlatformDownload();
+}
+iState.iProgressState = ECatalogsHttpDone;
+iOwner.CompleteOperation( this );
+iState.iOperationState = ECatalogsHttpOpCompleted;
+if ( iObserver )
+{
+iObserver->HandleHttpEventL( *this, iState );
+}
+	     }
+			break;
+		case DownloadEvent::InProgress:
+		    {
+		    iTransferredSize  =  iDownload->attribute(DownloadedSize).toInt();
+		    if ( iObserver )
+		        {
+		        iObserver->HandleHttpEventL( *this, iState );
+		        }
+		    }
+		    break;
+	  default:
+{
+}
+	};
+}
 // ---------------------------------------------------------------------------
 // Handles events from the transaction
 // ---------------------------------------------------------------------------
 //
 void CCatalogsHttpDownload::HandleHttpEventL(
 // ---------------------------------------------------------------------------
 // Handles events from the download manager
 // ---------------------------------------------------------------------------
 //
+/* HLa
 void CCatalogsHttpDownload::HandleEventL( THttpDownloadEvent aEvent )
 {
 DLTRACEIN((""));
 DLINFO( ("DL id: %d, Dl state: %i, Pr: %i, this-ptr: %X, iState: %d, iProgress: %d, dl-ptr: %X",
 OperationId().Id(),
 return;
 }
 	TInt32 statusCode = -1;
-	iDownload->GetIntAttribute( EDlAttrStatusCode, statusCode );
+	 statusCode  = (Download::State)iDownload->attribute(WRT::State).toInt();
-	DLINFO( ("Response status: %i", statusCode ) );
+	 DLINFO( ("Response status: %i", statusCode ) );
 #ifdef CATALOGS_BUILD_CONFIG_DEBUG
 TInt32 errorId = 0;
+		errorId=iDownload->attribute(LastError).toInt();
-	iDownload->GetIntAttribute( EDlAttrErrorId, errorId );
 	DLINFO( ("Error id: %i", errorId ) );
 #endif
 TInt32 globalErrorId = 0;
-	iDownload->GetIntAttribute(
+globalErrorId= iDownload->attribute(LastError).toInt();
-	    EDlAttrGlobalErrorId, globalErrorId );
 	DLINFO( ("Global error id: %i", globalErrorId ) );
 // was >=, DL manager should give us proper errors but it doesn't always
 if ( ( statusCode == KHttpErrorStatus ||
 if ( iReconnectWhenFail &&
 iState.iProgressState == ECatalogsHttpDisconnected )
 {
 DLTRACE(("Try to reconnect"));
 iReconnectWhenFail = EFalse;
-iDownload->Start();
+iDownload->start();
 break;
 }
 if ( iState.iOperationState != ECatalogsHttpOpQueued )
 {
 TRAPD( err, MoveFileL() );
 // DLMAIN-546, delete DL manager's download before starting
 // the next one so that downloads don't jam, again
 if ( iDownload )
 {
-iDownload->GetIntAttribute(
+	iTransferredSize = iDownload->attribute(DownloadedSize).toInt();
-EDlAttrDownloadedSize, iTransferredSize );
 DLTRACE(("Deleting download"));
 DeletePlatformDownload();
 }
 case EHttpDlFailed:
 {
 DLTRACE(( "Download failed" ));
 TInt32 errorId = -1;
 SetTransferring( EFalse );
-	iDownload->GetIntAttribute( EDlAttrErrorId, errorId );
+errorId = iDownload->attribute(LastError).toInt();
 	DLINFO( ("Error id: %i", errorId ) );
 	DLINFO( ("Global error id: %i", globalErrorId ) );
 if ( iReconnectWhenFail &&
 ( errorId == EConnectionFailed ||
 errorId == ETransactionFailed ))
 {
 DLTRACE(("Try to reconnect"));
 iReconnectWhenFail = EFalse;
-iDownload->Start();
+iDownload->start();
 break;
 }
 else if ( errorId == EContentExpired ||
 errorId == EPartialContentModified )
 {
 DLTRACE(("Content has changed, reset and restart"));
 iReconnectWhenFail = EFalse;
-iDownload->Reset();
+iDownload->cancel();
-iDownload->Start();
+iDownload->start();
 break;
 }
 ReleasePtr( iConnection );
 iState.iOperationState = ECatalogsHttpOpFailed;
 */
 /**
 * Download process can be paused again. This event only occurs after
 * EHttpDlNonPausable.
 */
+/* HLa
 case EHttpDlPausable:
 {
 DLTRACE(( "Pausable" ));
 iState.iOperationState = ECatalogsHttpOpPausable;
 HandleEventProgressL( aEvent );
 {
 break;
 }
 }
 }
+*/
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
+/*
 void CCatalogsHttpDownload::HandleEventProgressL( const
 THttpDownloadEvent& aEvent )
 {
 DLTRACEIN(( "" ));
 	switch ( aEvent.iProgressState )
 		    SetTransferring( EFalse );
 		    // Don't restart paused downloads or notify about disconnection
 		    if ( !iPaused )
 		        {
 TInt32 globalErrorId = 0;
-	iDownload->GetIntAttribute(
+	    globalErrorId = iDownload->attribute(LastError).toInt();
-	    EDlAttrGlobalErrorId, globalErrorId );
 	DLINFO( ("Global error id: %i", globalErrorId ) );
 if ( globalErrorId == KErrCancel )
 {
 DLTRACE(("Cancelled"));
 		    // Reset reconnect count
 		    iReconnectCount = KReconnectAttempts;
 		    TInt32 size = 0;
-	        iDownload->GetIntAttribute( EDlAttrDownloadedSize, size );
+		     size = iDownload->attribute(DownloadedSize).toInt();
 	        DLTRACE(("Transferred size from download: %i", size));
 	        if ( size != iTransferredSize )
 	            {
 	            DLTRACE(("Updating transferred size"));
 		    DLTRACE(("Default"));
 		    DLTRACE(( "state: %d, progress: %d",aEvent.iDownloadState, aEvent.iProgressState));
 			break;
 		}
 }
+*/
 // ---------------------------------------------------------------------------
 // Sets file server session
 // ---------------------------------------------------------------------------
 // Constructor
 // ---------------------------------------------------------------------------
 //
 CCatalogsHttpDownload::CCatalogsHttpDownload(
 CCatalogsHttpDownloadManager& aOwner,
-RHttpDownload* aDownload ) :
+Download* aDownload ) :
 iOwner( aOwner ),
 iDownload( aDownload ),
 iState( ECatalogsHttpOpCreated, ECatalogsHttpNone ),
 iRefCount( 1 ),
 iNormalDelete( EFalse ),
 // Get the id for the download and update iUri
 if ( iDownload )
 {
 // id part will be updated from disk
 iId = TCatalogsTransportOperationId( iOwner.SessionId(), KErrNotFound );
+				iQTDownload = new CCatalogsHttpQTDownload(this,iDownload);
 UpdateSecondaryIdL();
 User::LeaveIfError( SetDeleteState( EDownloadCanBeDeleted ) );
 // Update iUri to match the current URI
 UpdateUriL();
 DLTRACEIN(( "" ));
 if ( !iContentType.Length() )
 {
 // Download always exists when this is called so no need to check
 DLTRACE(("Updating the content type"));
-iDownload->GetStringAttribute( EDlAttrContentType,
+QString contentType;
-iContentType );
+contentType= iDownload->attribute(WRT::ContentType).toString();
+// HLa TBuf<KMaxContentTypeLength>  ContentType(contentType.utf16());
+TBuf<256>  ContentType(contentType.utf16());
+	iContentType.Copy(ContentType);
 }
 DLTRACEOUT(("Content-type: %S", &iContentType ));
 }
 {
 DLTRACEIN( ("") );
 // Get the current url of the download
 RBuf8 buf;
 CleanupClosePushL( buf );
+const TInt KMaxUrlLength = 2048;
 buf.CreateL( KMaxUrlLength );
+QString string;
-User::LeaveIfError( iDownload->GetStringAttribute( EDlAttrCurrentUrl,
+	try
-buf ) );
+	{
+string = iDownload->attribute(SourceUrl).toString();
+	}
+catch(const std::exception& exception)
+	{
+			 qt_symbian_exception2LeaveL(exception);
+	}
 // DL manager has the encoded URI
 AssignDesL( iEncodedUri, buf );
 CleanupStack::PopAndDestroy( &buf );
 {
 AddRequestHeaderL( iAddedRequestHeaders, *headers[i] );
 }
 else
 {
-User::LeaveIfError( iDownload->SetStringAttribute(
+/*            User::LeaveIfError( iDownload->SetStringAttribute(
-predefined, headers[i]->Value() ) );
+predefined, headers[i]->Value() ) );*/
 }
 }
 // Add the headers that don't have a predefined enumeration in
 // the platform DL manager
 if ( iAddedRequestHeaders )
 {
 DLTRACE(( "added request headers: %S", iAddedRequestHeaders ));
-User::LeaveIfError( iDownload->SetStringAttribute(
+/*   User::LeaveIfError( iDownload->SetStringAttribute(
-EDlAttrRequestHeaderAddon, *iAddedRequestHeaders ) );
+EDlAttrRequestHeaderAddon, *iAddedRequestHeaders ) );*/
 delete iAddedRequestHeaders;
 iAddedRequestHeaders = NULL;
 }
 DLTRACEOUT((""));
 }
 // ---------------------------------------------------------------------------
 //
 TUint CCatalogsHttpDownload::MatchWithPredefinedRequestHeader(
 const TDesC8& aHeader ) const
 {
+/* HLa
 if ( aHeader.CompareF( KHttpRequestAcceptHeader ) == 0 )
 {
 return EDlAttrRequestAccept;
 }
 else if ( aHeader.CompareF( KHttpRequestAcceptCharSetHeader ) == 0 )
 }
 else if ( aHeader.CompareF( KHttpRequestVaryHeader ) == 0 )
 {
 return EDlAttrRequestVary;
 }
+*/
 return 0;
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 TUint CCatalogsHttpDownload::MatchWithPredefinedGeneralHeader(
 const TDesC8& aHeader ) const
 {
+/* HLa
 if ( aHeader.CompareF( KHttpGeneralCacheControlHeader ) == 0 )
 {
 return EDlAttrGeneralCacheControl;
 }
 else if ( aHeader.CompareF( KHttpGeneralDateHeader ) == 0 )
 return EDlAttrGeneralVia;
 }
 else if ( aHeader.CompareF( KHttpGeneralWarningHeader ) == 0 )
 {
 return EDlAttrGeneralWarning;
 }
+*/
 return 0;
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 TUint CCatalogsHttpDownload::MatchWithPredefinedEntityHeader(
 const TDesC8& aHeader ) const
 {
+/*
 if ( aHeader.CompareF( KHttpEntityAllowHeader ) == 0 )
 {
 return EDlAttrEntityAllow;
 }
 else if ( aHeader.CompareF( KHttpEntityContentEncodingHeader ) == 0 )
 }
 else if ( aHeader.CompareF( KHttpEntityLastModifiedHeader ) == 0 )
 {
 return EDlAttrEntityLastModified;
 }
+*/
 return 0;
 }
 // ---------------------------------------------------------------------------
 DLTRACE( ("Reallocating target buffer") );
 aTarget = aTarget->ReAllocL( headerLength );
 }
 TPtr8 ptr( aTarget->Des() );
+_LIT8( KHttpFieldSeparator, "\n"); // HLa
+const TInt KColon( ':' ); // HLa
 if( newSize )
 {
 DLTRACE( ("Appending to existing headers") );
 // Append after the existing headers
 DLTRACEIN((""));
 DASSERT( iConnection );
 TRAPD( err,
 {
-iOwner.SetConnectionL( *iConnection );
+if ( Config().ConnectionMethod().iType == ECatalogsConnectionMethodTypeDestination )
+{
+RCmManager cmManager;
+CleanupClosePushL( cmManager );
+cmManager.OpenL();
+RCmDestination dest = cmManager.DestinationL( Config().ConnectionMethod().iId );
+CleanupClosePushL( dest );
+HBufC* temp = dest.NameLC();
+QString destname;
+destname = XQConversions::s60DescToQString( *temp );
+CleanupStack::PopAndDestroy( temp );
+CleanupStack::PopAndDestroy( &dest );
+CleanupStack::PopAndDestroy( &cmManager );
+if ( iOwner.GetDownloadManager() )
+{
+iOwner.GetDownloadManager()->attribute(AccessPoints).toStringList();
+iOwner.GetDownloadManager()->setAttribute(AccessPoint, destname);
+}
+}
 // Update the configuration
 if ( iState.iProgressState == ECatalogsHttpNone )
 {
 DLTRACE(("Updating dl config"));
 InitializeDownloadL();
 }
 });
 if ( err == KErrNone )
 {
-err = iDownload->Start();
+						 try
+							{
+							iDownload->start();
+							}
+			        catch(const std::exception& exception)
+			        	{
+							 qt_symbian_exception2LeaveL(exception);
+			        	}
 }
 return err;
 }
 DLTRACEIN(( "aStatus: %x, id: %x", aStatus, OperationId().Id() ));
 TInt err = KErrNone;
 if ( iDownload )
 {
-err = iDownload->SetIntAttribute( EDlAttrUserData, aStatus );
+iStatus = aStatus;
 }
 return err;
 }
+CCatalogsHttpDownload::TDownloadDeleteState CCatalogsHttpDownload::GetStatusState()
+	{
+		return iStatus;
+	}
 // ---------------------------------------------------------------------------
 // Gets delete status and download id from the platform download
 // ---------------------------------------------------------------------------
 //
 TInt CCatalogsHttpDownload::GetDeleteState(
 TInt32 data = 0;
 TInt err = KErrNotReady;
 if ( iDownload )
 {
-err = iDownload->GetIntAttribute( EDlAttrUserData, data );
+err = iStatus;
 DLTRACE(("Data: %d", data));
 aStatus = static_cast<TDownloadDeleteState>( data );
 }
 DLTRACEOUT(("status: %x", aStatus ));
 return err;
 // Update the request headers to the download manager but do it
 // only once
 UpdateRequestHeadersL();
 }
-// Check if the download has been set progressive
+// Check if the
-TBool progressive = EFalse;
+//download has been set progressive
-User::LeaveIfError( iDownload->GetBoolAttribute(
+/* MTA
-EDlAttrProgressive, progressive ) );
+* TBool progressive = EFalse;
+		try
+		{
+		         progressive =iDownload->attribute(Progressive).toBool();
+		}
+catch(const std::exception& exception)
+	{
+				 qt_symbian_exception2LeaveL(exception);
+	}
 // We want to have progressive downloads because then DL manager uses
 // a smaller download buffer which makes progress events much more
 // frequent. However, something goes wrong if the progressive flag is
 // set the flag if it has already been set because it
 // messes the download
 !iFileIsSet )
 {
 DLTRACE(("Setting download as progressive"));
-User::LeaveIfError( iDownload->SetBoolAttribute(
+						try
-EDlAttrProgressive, ETrue ) );
+						{
-}
+						   iDownload->setAttribute(Progressive,ETrue);
+						}
+						catch(const std::exception& exception)
+						{
+							qt_symbian_exception2LeaveL(exception);
+						}
+						}
 // Doesn't pause the download after content type has been received
-User::LeaveIfError( iDownload->SetBoolAttribute(
+					try
-EDlAttrNoContentTypeCheck, ETrue ) );
+					{
+						iDownload->setAttribute(Progressive,ETrue);
+					}
+					catch(const std::exception& exception)
+					{
+						qt_symbian_exception2LeaveL(exception);
+					}
+**/
 if ( !iFileIsSet )
 {
 DLTRACE(("Setting filehandle to download"));
-User::LeaveIfError( iDownload->SetFileHandleAttribute( file ) );
+// User::LeaveIfError( iDownload->SetFileHandleAttribute( file ) );
+file.Close();
+TInt ret = BaflUtils::DeleteFile( iFs, *iTempFilename );
+iDownload->setAttribute(DestinationPath,XQConversions::s60DescToQString(iConfig->Directory()));
+iDownload->setAttribute(FileName, XQConversions::s60DescToQString(*iTempFilename));
 iFileIsSet = ETrue;
 }
 CleanupStack::PopAndDestroy( &file );
 }
 }
+Download* CCatalogsHttpDownload::GetDownload()
+{
+	return iDownload;
+}
 // ---------------------------------------------------------------------------
 // Delete platform download and reset secondary id
 // ---------------------------------------------------------------------------
 //
 void CCatalogsHttpDownload::DeletePlatformDownload()
 {
 if ( iDownload )
 {
-iDownload->Delete();
+iOwner.GetDownloadManager()->removeOne(iDownload);
 iDownload = NULL;
 iId.SetSecondaryId( KErrNotFound );
 }
 }
 // ---------------------------------------------------------------------------
 //
 void CCatalogsHttpDownload::UpdateSecondaryIdL()
 {
 TInt32 secondaryId = KErrNotFound;
-User::LeaveIfError(
+secondaryId = iDownload->id();
-iDownload->GetIntAttribute( EDlAttrId, secondaryId ) );
 iId.SetSecondaryId( secondaryId );
 }
 // ---------------------------------------------------------------------------
 {
 aName.Delete( dotPos, aName.Length()- dotPos );
 aName.Append( aExt );
 }
 }
+CCatalogsHttpQTDownload::CCatalogsHttpQTDownload(CCatalogsHttpDownload* aHttpDownload,Download* aDownload)
+	{
+		iCatalogsHttpDownload = aHttpDownload;
+		iDownload = aDownload;
+		connect(iDownload, SIGNAL(downloadEvent(DownloadEvent*)), this,SLOT(downloadEventHandler(DownloadEvent*)));
+connect(iDownload, SIGNAL(downloadError(Error)), this,SLOT(downloadErrorHandler(Error)));
+	}
+void CCatalogsHttpQTDownload::downloadEventHandler(DownloadEvent* aEvent)
+	{
+		iCatalogsHttpDownload->HandledownloadEventL(*aEvent);
+	}
+void CCatalogsHttpQTDownload::downloadErrorHandler(Error)
+	{
+		//iCatalogsHttpDownload->HandledownloadEventL(*aEvent);
+	}

branch	RCL_3
changeset 25	7333d7932ef7
parent 11	3ba40be8e484
child 26	8b7f4e561641