/** @file
* Copyright (c) 2005-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".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
// INCLUDE FILES
#include "upnptransfercontroller.h"
#include "upnpcontentdirectory.h"
#include "upnpcontentdirectorydb.h"
#include "upnpfiletransfertimerobserver.h"
#include "upnpfiletransferevent.h"
#include "upnpcontentdirectoryeventobserver.h"
#include "upnpfiletransfer.h"
#include "upnphttpmessage.h"
#include "upnpautodestroyobjectlist.h"
#include "upnpcdutils.h"
#include "upnptransferinterface.h"
#include "upnpstring.h"
// -----------------------------------------------------------------------------
// CUpnpTransferController::CUpnpTransferController
// -----------------------------------------------------------------------------
//
CUpnpTransferController::CUpnpTransferController( CUpnpContentDirectory* aCd ):
iContentDirectory(aCd)
{
}
// -----------------------------------------------------------------------------
// CUpnpTransferController::ConstructL
// -----------------------------------------------------------------------------
//
void CUpnpTransferController::ConstructL()
{
}
// -----------------------------------------------------------------------------
// CUpnpTransferController::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CUpnpTransferController* CUpnpTransferController::NewL( CUpnpContentDirectory* aCd )
{
CUpnpTransferController* self =
new (ELeave) CUpnpTransferController( aCd );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CUpnpTransferController destructor
// -----------------------------------------------------------------------------
//
CUpnpTransferController::~CUpnpTransferController()
{
iFileTransfers.ResetAndDestroy();
// clear timers
iStatusTimers.ResetAndDestroy();
}
// -----------------------------------------------------------------------------
// CUpnpTransferController::HttpResponseReceivedL
// -----------------------------------------------------------------------------
//
void CUpnpTransferController::HttpResponseReceivedL( TInt aSessionId,
TInt aStatusCode )
{
TInt transferId = Transfer( aSessionId);
if ( transferId == KErrNotFound )
{
return;
}
if( aStatusCode < 0)
{
if( iFileTransfers[ transferId ]->TransferState() != ECompleted )
{
//stopped transfer
if(aStatusCode == KErrCancel)
{
iFileTransfers[ transferId ]->SetTransferState( EStopped);
}
//error in transfer
else
{
iFileTransfers[ transferId ]->SetTransferState( EError);
}
iContentDirectory->GetAutoDestroyObjectList()->TransferFailL( iFileTransfers[ transferId ]->ImportNumber() );
iContentDirectory->RemoveFileTransferFromTransferIDsStateVariableL( aSessionId );
// remove the transfer after 30s
CUpnpFileTransferTimerObserver* timer =
CUpnpFileTransferTimerObserver::NewLC(
this, aSessionId );
iStatusTimers.AppendL(timer);
CleanupStack::Pop(timer);
// send event to MS
if( aStatusCode == KErrCancel)
{
CUpnpFileTransfer::TTransferType type =
iFileTransfers[ transferId ]->TransferType();
iContentDirectory->NotifyTransferStoppedL( aSessionId, type);
}
else
{
//transfer with error
iContentDirectory->NotifyTransferFailL( aSessionId, aStatusCode );
}
}
}
else if( aStatusCode == EHttpOk )
{
CUpnpFileTransferEvent* transferEvent = iFileTransfers[ transferId ]->Event();
if( iContentDirectory->IsDrmFileL( transferEvent->FilePath() ))
{
iFileTransfers[ transferId ]->SetTransferState(EError);
iContentDirectory->GetAutoDestroyObjectList()->TransferFailL( iFileTransfers[ transferId ]->ImportNumber() );
// send event to MS - AM -???
iContentDirectory->NotifyTransferFailL( aSessionId, aStatusCode );
}
else
{
iFileTransfers[ transferId ]->SetTransferState(ECompleted);
// checking if transfer was GET. In that case we have to
// create res tag for that file to CDS
if ( iFileTransfers[ transferId ]->TransferType() != CUpnpFileTransfer::EExport )
{
// 16-bit -> 8-bit conversion
HBufC8* filenameBuffer = UpnpString::FromUnicodeL( transferEvent->FilePath() );
CleanupStack::PushL( filenameBuffer );
TPtr8 buffPtr = filenameBuffer->Des();
TInt ret = iContentDirectory->CreateResTagL( aSessionId,
buffPtr ,
iFileTransfers[ transferId ]->ImportNumber() );
User::LeaveIfError( ret );
CleanupStack::PopAndDestroy(filenameBuffer);
iContentDirectory->TransferCompleteL( iFileTransfers[ transferId ]->ImportNumber() ,
iFileTransfers[ transferId ]->ObjectId() );
}
//send event to MS
iContentDirectory->NotifyOutgoingTransferL( aSessionId );
}
// remove the transfer after 30s
CUpnpFileTransferTimerObserver* timer =
CUpnpFileTransferTimerObserver::NewLC(
this, aSessionId );
iStatusTimers.AppendL(timer);
CleanupStack::Pop(timer);
iContentDirectory->RemoveFileTransferFromTransferIDsStateVariableL( aSessionId );
}
else
{
//needed?
//
}
}
// -----------------------------------------------------------------------------
// CUpnpTransferController::StopTransferResourceL
// -----------------------------------------------------------------------------
//
TUpnpErrorCode CUpnpTransferController::StopTransferResourceL( TInt aId )
{
TInt transferIndex = Transfer( aId );
if( KErrNotFound == transferIndex )
{
User::Leave( ENoFileTransfer );
}
if(iFileTransfers[ transferIndex ]->TransferState() == ::ETransferInProgress)
{
CUpnpFileTransfer::TTransferType type =
iFileTransfers[ transferIndex ]->TransferType();
if(type == CUpnpFileTransfer::EImport)
{
iContentDirectory->TransferHandler()->CancelDownload(aId);
}
else
{
iContentDirectory->TransferHandler()->CancelUpload(aId);
}
}
return EHttpOk;
}
// -----------------------------------------------------------------------------
// CUpnpTransferController::Transfer
// -----------------------------------------------------------------------------
//
TInt CUpnpTransferController::Transfer( TInt aTransferId )
{
for( TInt transferIndex(0);
transferIndex < iFileTransfers.Count();
transferIndex++ )
{
if( iFileTransfers[transferIndex]->TransferId() == aTransferId )
{
return transferIndex;
}
}
return KErrNotFound;
}
// -----------------------------------------------------------------------------
// CUpnpTransferController::IsMaxImportExportTransfers
// -----------------------------------------------------------------------------
//
TBool CUpnpTransferController::IsMaxImportExportTransfers()
{
/*
* This function limits total number of import/export transfers, according to
* current number of transfers, which are in progress state and pending import/export transfers
* Note: Any better algorithm can be used as well
*/
TInt numberOfInProgressTransfers = 0;
for( TInt i = 0; i < iFileTransfers.Count(); i++ )
{
if( iFileTransfers[i]->TransferState() == ::ETransferInProgress )
{
++numberOfInProgressTransfers;
}
}
// Note: "+ 1" because e.g future 4th transfer discovers only 3 previous transfers,
// and if KMaxImportExportTransfers = 3, 4th transfer should be forbidden now.
return ( ( numberOfInProgressTransfers + 1 ) > KMaxImportExportTransfers );
}
// -----------------------------------------------------------------------------
// CUpnpTransferController::TransferInternal
// -----------------------------------------------------------------------------
//
CUpnpFileTransferEvent* CUpnpTransferController::RemoveTransferLC( TInt aTransferId )
{
for( TInt i = 0; i < iFileTransfers.Count(); i++ )
{
if( iFileTransfers[i]->TransferId() == aTransferId )
{
CUpnpFileTransferEvent* event = iFileTransfers[i]->RemoveEvent();
if(event)
{
CleanupStack::PushL( event );
return event;
}
else
{
return NULL;
}
}
}
return NULL;
}
// -----------------------------------------------------------------------------
// CUpnpTransferController::TransferInternal
// -----------------------------------------------------------------------------
//
CUpnpFileTransferEvent* CUpnpTransferController::TransferL( TInt aTransferId )
{
for( TInt i = 0; i < iFileTransfers.Count(); i++ )
{
if( iFileTransfers[i]->TransferId() == aTransferId )
{
CUpnpFileTransferEvent* event = iFileTransfers[i]->Event();
return event;
}
}
return NULL;
}
// -----------------------------------------------------------------------------
// CUpnpContentDirectory::TransferEvent
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpTransferController::TransferEvent(
CUpnpFileTransferTimerObserver* aTimer)
{
// remove transfer
for( TInt i = 0; i < iFileTransfers.Count(); i++ )
{
if( iFileTransfers[i]->TransferId() == aTimer->TransferId() )
{
delete iFileTransfers[i];
iFileTransfers.Remove(i);
break;
}
}
// remove timer
for( TInt i = 0; i < iStatusTimers.Count(); i++ )
{
if( iStatusTimers[i] == aTimer )
{
delete iStatusTimers[i];
iStatusTimers.Remove(i);
break;
}
}
}
// -----------------------------------------------------------------------------
// CUpnpContentDirectory::AddIncomingTransferInternalL
// -----------------------------------------------------------------------------
//
void CUpnpTransferController::AddIncomingTransferInternalL( CUpnpHttpMessage* aHttpMsg )
{
TInt objId = iContentDirectory->ContentDirectoryDb()->GetObjIdByAttrLikeL(KImportUri8, aHttpMsg->SenderPathFromHeader());
CUpnpFileTransferEvent* event = CUpnpFileTransferEvent::NewLC();
event->SetProgressState( CUpnpFileTransferEvent::ECompleted );
event->SetDirection( CUpnpFileTransferEvent::EIncoming );
event->SetContentDirectoryObjectId( objId );
event->SetTransferId( aHttpMsg->SessionId() );
CleanupStack::Pop( event );
TInt transferid = Transfer(aHttpMsg->SessionId());
if( transferid == KErrNotFound)
User::Leave(KErrNotFound);
iFileTransfers[transferid]->SetEvent(event);
}
// -----------------------------------------------------------------------------
// CUpnpContentDirectory::TransferFailL
// -----------------------------------------------------------------------------
//
void CUpnpTransferController::TransferFailL(CUpnpHttpMessage* aHttpMsg)
{
TPtrC8 path( aHttpMsg->DestinationPath() );
if( path.Length() )
{
iContentDirectory->GetAutoDestroyObjectList()->TransferFailL( UpnpCdUtils::ResIdFromUriL( path ) );
}
TInt transferId = Transfer( aHttpMsg->SessionId() );
if ( transferId != KErrNotFound )
{
if ( !path.Length() )
{
iContentDirectory->GetAutoDestroyObjectList()->TransferFailL( iFileTransfers[ transferId ]->ImportNumber() );
}
iContentDirectory->RemoveFileTransferFromTransferIDsStateVariableL( aHttpMsg->SessionId() );
if(iFileTransfers[ transferId ]->TransferState () ==::ETransferInProgress )
{
iFileTransfers[ transferId ]->SetTransferState( EError );
}
CUpnpFileTransferTimerObserver* timer =
CUpnpFileTransferTimerObserver::NewLC(
this, aHttpMsg->SessionId() );
iStatusTimers.AppendL( timer );
CleanupStack::Pop( timer );
}
// send event to MS
NotifyTransferFailL( aHttpMsg );
}
// -----------------------------------------------------------------------------
// CUpnpContentDirectory::NotifyTransferFailL
// -----------------------------------------------------------------------------
//
void CUpnpTransferController::NotifyTransferFailL( CUpnpHttpMessage* aHttpMsg )
{
CUpnpFileTransferEvent* event = RemoveTransferLC( aHttpMsg->SessionId() );
if( event )
{
event->SetProgressState( CUpnpFileTransferEvent::EFailed );
event->SetErrorCode( aHttpMsg->Error() );
CleanupStack::Pop( event);
iContentDirectory->EventObserver()->FileTransferEvent( event );
}
}
// End of File