/*

* Copyright (c) 2007 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:      server impl. of session against media server

*

*/

// INCLUDE FILES

// System

#include <mmf/common/mmfcontrollerpluginresolver.h>

// upnp stack api

#include <upnpitem.h>

#include <upnpattribute.h>

#include <upnpstring.h>

#include <upnpdlnaprotocolinfo.h>

#include <upnpavcontrolpoint.h>

// upnpframework / avcontroller helper api

#include "upnpconstantdefs.h" // for upnp-specific stuff

#include "upnpitemutility.h" // FindElementByNameL, GetResElements

// upnpframework / xmlparser api

#include "upnpxmlparser.h"

// upnpframework / internal api's

#include "upnpcdsreselementutility.h"

#include "httpuploader.h"

#include "upnpmetadatafetcher.h"

#include "upnpcommonutils.h"

// INTERNAL INCLUDES

#include "upnpuploadsession.h"

#include "upnpfiletransferitem.h"

#include "upnpavcontrollerserver.h"

#include "upnpfiletransferitem.h"

#include "upnpavdeviceextended.h"

#include "upnpavdispatcher.h"

#include "upnpaverrorhandler.h"

#include "upnpresourcehelper.h"

_LIT( KComponentLogfile, "upnpavcontrollerserver.txt");

#include "upnplog.h"

// CONSTANTS

_LIT8( KImportUri,              "importUri" );

_LIT8( KAsterisk,               "*" );

const TUint32 KBufferSize       = 0x40000; // 256K

const TInt KParallerTransfers   = 1;

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

// --------------------------------------------------------------------------

// CUPnPUploadSession::NewL

// See upnpuploadsession.h

// --------------------------------------------------------------------------

CUPnPUploadSession* CUPnPUploadSession::NewL( CUpnpAVControllerServer&

    aServer, TInt aSessionId, const TDesC8& aUuid )

    {

    CUPnPUploadSession* self = new (ELeave) CUPnPUploadSession(

        aServer, aSessionId );

    CleanupStack::PushL( self );    

    self->ConstructL( aUuid );

    CleanupStack::Pop( self );

    return self;

    }

// --------------------------------------------------------------------------

// CUPnPUploadSession::CUPnPUploadSession

// See upnpuploadsession.h

// --------------------------------------------------------------------------

CUPnPUploadSession::CUPnPUploadSession( CUpnpAVControllerServer& aServer,

    TInt aSessionId ) :

    CUPnPFileTransferSessionBase( aServer, aSessionId ),

    iResourceIndex( KErrNotFound ),

    iAsyncError( KErrNone ),

    iIPSessionId( KErrNotFound ),

    iSchedulerStopped( ETrue )

    {

    }

// --------------------------------------------------------------------------

// CUPnPUploadSession::~CUPnPUploadSession

// See upnpuploadsession.h

// --------------------------------------------------------------------------

CUPnPUploadSession::~CUPnPUploadSession()

    {

    __LOG( "CUPnPUploadSession::~CUPnPUploadSession" );

    delete iUploader;

    iResources.ResetAndDestroy();

    __LOG( "CUPnPUploadSession::~CUPnPUploadSession - end" );

    }

// --------------------------------------------------------------------------

// CUPnPUploadSession::ConstructL

// See upnpuploadsession.h

// --------------------------------------------------------------------------

void CUPnPUploadSession::ConstructL( const TDesC8& aUuid )

    {

    __LOG( "CUPnPUploadSession::ConstructL" );

    CUPnPFileTransferSessionBase::ConstructL( aUuid );

    iUploader = CHttpUploader::NewL( *this, (TUint32)iServer.IAP(),

        KBufferSize, KParallerTransfers );

    }

// --------------------------------------------------------------------------

// CUPnPDownloadSession::TransferProgress

// See upnpdownloadsession.h

// --------------------------------------------------------------------------

void CUPnPUploadSession::TransferProgress( TAny* aKey, TInt aBytes,

    TInt aTotalBytes )

    {

    __LOG( "CUPnPUploadSession::TransferProgress" );

    if( iProgressTrackingEnabled )

        {

        TUpnpFileTransferEvent item;

        TInt err = FindItemByKey( item, (TInt)aKey );

        if( err == KErrNone )

            {

            item.iStatus = KErrNone;

            item.iParam2 = aTotalBytes;

            item.iParam1 = aBytes;

            item.iEvent = TUpnpFileTransferEvent::ETransferProgress;

            Complete( item );

            }

        else

            {

            __LOG( "TransferProgress - Not enabled!" );

            }

        }

    }

// --------------------------------------------------------------------------

// CUPnPUploadSession::ReadyForTransfer

// See upnpdownloadsession.h

// --------------------------------------------------------------------------

void CUPnPUploadSession::ReadyForTransferL( TAny* aKey )

    {

    __LOG( "CUPnPUploadSession::ReadyForTransferL" );

    TUpnpFileTransferEvent event;

    if( FindItemByKey( event, (TInt)aKey, iResourceIndex ) == KErrNone )

        {

        ReadyForTransferL( event );

        event.iEvent = TUpnpFileTransferEvent::ETransferStarted;

        Complete( event );

        }

    else

        {

        __LOG( "ReadyForTransfer - Key not found" );

        // Not found

        event.iStatus = KErrGeneral;

        event.iParam2 = 0;

        event.iEvent = TUpnpFileTransferEvent::ETransferCompleted;

        Complete( event );

        }

    }

// --------------------------------------------------------------------------

// CUPnPUploadSession::TransferCompleted

// See upnpdownloadsession.h

// --------------------------------------------------------------------------

void CUPnPUploadSession::TransferCompleted( TAny* aKey, TInt aStatus )

    {

    __LOG2( "CUPnPUploadSession::TransferCompleted, key = %d, status = %d",

            (TInt)aKey, aStatus );

    TUpnpFileTransferEvent item;

    TInt index;

    TInt err = FindItemByKey( item, (TInt)aKey, index );

    if( err == KErrNone )

        {

        item.iStatus = UPnPAVErrorHandler::ConvertToSymbianErrorCode( aStatus,

        EUPnPHTTPError );

        item.iEvent = TUpnpFileTransferEvent::ETransferCompleted;

        Complete( item );

        iTransferItems.Remove( index );

        delete iResources[ index ];

        iResources.Remove( index );

        }

    else

        {

        __LOG( "TransferCompleted - Key not found" );

        // Not found

        if( aStatus == KErrCancel )

            {

            item.iStatus = aStatus;

            }

        else

            {

            item.iStatus = KErrGeneral;    

            }    

        item.iParam2 = 0;

        item.iEvent = TUpnpFileTransferEvent::ETransferCompleted;

        Complete( item );

        } 

    if( aStatus == KErrDisconnected )

        {

        __LOG( "TransferCompleted - Target device lost" );

        TInt count = iTransferItems.Count();

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

            {

            iUploader->CancelTransfer( (TAny*)iTransferItems[i].iKey );

            if( iResources[ i ]->ItemId() )

                {

                // Send destroyobject

                __LOG( "CancelAllUploadsL - sending destroyobject" );

                TRAP_IGNORE( iServer.ControlPoint().CdsDestroyObjectActionL(

                    iDevice->Uuid(), *iResources[ i ]->ItemId() ) );  

                }

            }

        iResources.ResetAndDestroy();    

        iTransferItems.Reset();

        }      

    }

// --------------------------------------------------------------------------

// CUPnPUploadSession::CdsCreateObjectResponse

// See upnpbrowsingsession.h

// --------------------------------------------------------------------------

void CUPnPUploadSession::CdsCreateObjectResponse(

    const TDesC8& /*aUuid*/,

    TInt aSessionId,

    TInt aErr,

    const TDesC8& /*aContainerID*/, 

    const TDesC8& /*aElements*/, 

    const TDesC8& aObjectID, 

    const TDesC8& aResult )

    {

    __LOG1( "CUPnPUploadSession::CdsCreateObjectResponse: %d" , aErr );

    __ASSERTD( iIPSessionId == aSessionId, __FILE__, __LINE__ );

    __ASSERTD( iTransferItems.Count() == iResources.Count(), __FILE__, 

               __LINE__ );

    iServer.Dispatcher().UnRegister( iIPSessionId );

    iIPSessionId = KErrNotFound;

    aErr = UPnPAVErrorHandler::ConvertToSymbianErrorCode( aErr,

        EUPnPContentDirectoryError );

    if( aErr == KErrNone )

        {

        TRAP( aErr, HandleObjectResponseL( aObjectID, aResult ) );

        }        

    iAsyncError = aErr;

    StopWait();

    }

// --------------------------------------------------------------------------

// CUPnPUploadSession::StartUploadL

// See upnpbrowsingsession.h

// --------------------------------------------------------------------------

void CUPnPUploadSession::StartUploadL( const RMessage2& aMessage )

    {

    __LOG( "CUPnPUploadSession::StartUploadL" );

    __ASSERTD( iTransferItems.Count() == iResources.Count(), __FILE__, 

               __LINE__ );

    CUpnpFileTransferItem* tmpTransferItem = CUpnpFileTransferItem::NewLC();

    ReadTransferItemFromMessageL( aMessage, 1 ,tmpTransferItem );

    if( CheckIfKeyExists( tmpTransferItem->Key() ) )

        {

        User::Leave( KErrInUse );

        }

    TUpnpFileTransferEvent transferItem;        

    transferItem.iKey = tmpTransferItem->Key();

    CUpnpItem* tmpUpnpItem = UPnPMetadataFetcher::CreateItemFromFileLC( 

        tmpTransferItem->Path() );

    tmpUpnpItem->SetIdL( KNullDesC8 );

    tmpUpnpItem->SetParentIdL( KContainerIdAny );

    tmpUpnpItem->SetRestricted( EFalse );

    const CUpnpElement& resEl = UPnPItemUtility::FindElementByNameL(

        *tmpUpnpItem, KElementRes );

    const CUpnpAttribute* pInfo = UPnPItemUtility::FindAttributeByName(

        resEl, KAttributeProtocolInfo );  

    if( iDevice->DlnaCompatible() )

        {

        // Dlna device, additional checks required

        __LOG( "StartUploadL - DLNA device" );

        TPtrC8 objectClass = tmpUpnpItem->ObjectClass(); 

        if( objectClass.Find( KClassAudio ) != KErrNotFound &&

            iDevice->AudioUpload() )

            {

            // Trying to upload audio and it's supported

            }

        else if( objectClass.Find( KClassImage ) != KErrNotFound &&

            iDevice->ImageUpload() )

            {

            // Trying to upload images and it's supported

            }

        else if(  objectClass.Find( KClassVideo ) != KErrNotFound &&

            iDevice->VideoUpload() )

            {

            // Trying to upload video and it's supported

            }

        else

            {

            // Unknown media type, or copy not supported

            __LOG( "StartUploadL - Unknown media type, or copy not \

supported" );

            User::Leave( KErrNotSupported );

            }    

            if( iDevice->ValidateTransfer( pInfo->Value() ) )

                {

                __LOG( "StartUploadL - Match by protocolInfo succeeded" );

                // Continue with DLNA upload

                // ProtocolInfo is in DLNA format

                }

            else

                {

                __LOG( "StartUploadL - Match by protocolInfo failed, upload \

as UPnP content" );

                // Continue with UPnP upload

                // Check the protocolInfo

                ProtocolInfoToUPnPL( pInfo );

                }        

        }

    else

        {

        __LOG( "StartUploadL - UPnP Device -> UPnP upload" );

        // Continue with UPnP upload

        // Check the protocolInfo

        ProtocolInfoToUPnPL( pInfo );        

        }

    iUploader->InsertFileIntoWaitQueueL( (TAny*)transferItem.iKey,

        tmpTransferItem->Path(), KNullDesC8 );

    SetHeadersL( pInfo->Value(), (TAny*)transferItem.iKey );

    iTransferItems.Append( transferItem );

    CUPnPResourceHelper* helper = CUPnPResourceHelper::NewL();

    CleanupStack::Pop( tmpUpnpItem );

    helper->SetItem( tmpUpnpItem ); // Transfer ownership

    iUploader->MoveToTransferQueueL( (TAny*)transferItem.iKey );

    CleanupStack::PopAndDestroy( tmpTransferItem );

    aMessage.Complete( KErrNone );

    __LOG( "CUPnPUploadSession::StartUploadL - end " );    

    }

// --------------------------------------------------------------------------

// CUPnPUploadSession::CancelUploadL

// See upnpbrowsingsession.h

// --------------------------------------------------------------------------

void CUPnPUploadSession::CancelUploadL( const RMessage2& aMessage )

    {

    __LOG( "CUPnPUploadSession::CancelUploadL" );          

    __ASSERTD( iTransferItems.Count() == iResources.Count(), __FILE__,

               __LINE__ );

    TInt key = aMessage.Int1();

    TInt index;

    if( CheckIfKeyExists( key, index ) )

        {

        iUploader->CancelTransfer( (TAny*)key );

        aMessage.Complete( KErrNone );

        iTransferItems.Remove( index );

        if( iResources[ index ]->ItemId() )

            {

            // Send destroyobject

            iServer.ControlPoint().CdsDestroyObjectActionL( iDevice->Uuid(),

                *iResources[ index ]->ItemId() );

            }

        delete iResources[index ];

        iResources.Remove( index );   

        }

    else

        {

        aMessage.Complete( KErrNotFound );

        }        

    __LOG( "CUPnPUploadSession::CancelUploadL - end" );

    }

// --------------------------------------------------------------------------

// CUPnPUploadSession::CancelAllUploadsL

// See upnpbrowsingsession.h

// --------------------------------------------------------------------------

void CUPnPUploadSession::CancelAllUploadsL( const RMessage2& aMessage )

    {

    __LOG( "CUPnPUploadSession::CancelAllUploadsL" );          

    __ASSERTD( iTransferItems.Count() == iResources.Count(), __FILE__,

               __LINE__ );

    TInt count = iTransferItems.Count();

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

        {

        iUploader->CancelTransfer( (TAny*)iTransferItems[i].iKey );

        if( iResources[ i ]->ItemId() )

            {

            // Send destroyobject

            __LOG( "CancelAllUploadsL - sending destroyobject" );

            iServer.ControlPoint().CdsDestroyObjectActionL( iDevice->Uuid(),

                *iResources[ i ]->ItemId() );  

            }

        }

    iResources.ResetAndDestroy();

    iTransferItems.Reset();

    iEventQueu.Reset();

    // Scheduler loop started, stop it and ignore createobject-resp

    __LOG( "CancelAllUploadsL - Un register" );

    iServer.Dispatcher().UnRegister( iIPSessionId );

    iIPSessionId = KErrNotFound;

    iAsyncError = KErrCancel;

    __LOG( "CancelAllUploadsL - Stop scheduler loop" );

    StopWait();

    aMessage.Complete( KErrNone );

    __LOG( "CUPnPUploadSession::CancelAllUploadsL - end" );

    }

// --------------------------------------------------------------------------

// CUPnPUploadSession::StartTrackingUploadProgressL

// See upnpbrowsingsession.h

// --------------------------------------------------------------------------

void CUPnPUploadSession::StartTrackingUploadProgressL( const RMessage2&

    aMessage )

    {

    __LOG( "CUPnPUploadSession::StartTrackingUploadProgressL" );

    TInt key = aMessage.Int1();

    if( CheckIfKeyExists( key ) )

        {

        iUploader->TrackProgress( (TAny*)key, ETrue );

        iProgressTrackingEnabled = ETrue;

        aMessage.Complete( KErrNone );

        }

    else

        {

        aMessage.Complete( KErrNotFound );

        }    

    }

// --------------------------------------------------------------------------

// CUPnPUploadSession::StopTrackingUploadProgressL

// See upnpbrowsingsession.h

// --------------------------------------------------------------------------

void CUPnPUploadSession::StopTrackingUploadProgressL( const RMessage2&

    aMessage )

    {

    __LOG( "CUPnPUploadSession::StopTrackingUploadProgressL" );

    TInt key = aMessage.Int1();

    if( CheckIfKeyExists( key ) )

        {

        iUploader->TrackProgress( (TAny*)key, EFalse );

        iProgressTrackingEnabled = EFalse;        

        aMessage.Complete( KErrNone );

        }

    else

        {

        aMessage.Complete( KErrNotFound );

        }

    }

// --------------------------------------------------------------------------

// CUPnPUploadSession::GetUploadEventL

// See upnpbrowsingsession.h

// --------------------------------------------------------------------------

void CUPnPUploadSession::GetUploadEventL( const RMessage2& aMessage )

    {

    __LOG( "CUPnPUploadSession::GetUploadEventL" );

    if( iEventQueu.Count() )

        {

        // There are events in the queu, write the first queued event back

        // to client

        __LOG1( "GetUploadEventL - events in queu, count = %d",

            iEventQueu.Count() );