/*

* 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".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:      server impl. of session against media server

*

*/

// INCLUDE FILES

// System

#include <utf.h> 

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include <centralrepository.h>

// upnp stack api

#include <upnpstring.h>

#include <upnpdevice.h>

#include <upnpservice.h>

// dlnasrv / mediaserver api

#include <upnpcontainer.h>

#include <upnpitem.h>

#include <upnpelement.h>

#include <upnpmediaserversettings.h>

#include <upnpmediaserverclient.h>

#include <upnpmediaservernotifier.h>

#include <upnpfiletransferevent.h>

// dlnasrv / avcontroller api

#include "upnpavrenderingsessionobserver.h"

// dlnasrv / avcontroller helper api

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

#include "upnpfileutility.h"

#include "upnpitemutility.h"

// dlnasrv / xmlparser api

#include "upnpxmlparser.h"

// dlnasrv / internal api's

#include "upnpcdsreselementutility.h"

#include "upnpmetadatafetcher.h"

// dlnasrv / avcontroller internal

#include "upnpavdispatcher.h"

#include "upnpavbrowserequest.h"

#include "upnpavrequest.h"

#include "upnpaverrorhandler.h"

#include "upnpavdeviceextended.h"

#include "upnpdevicerepository.h"

#include "upnpavbrowserespparams.h"

#include "upnpavcontrollerserver.h"

#include "upnpavcpstrings.h"

#include "upnpbrowsingsession.h"

#include "upnpavcontrolpoint.h"

using namespace UpnpAVCPStrings;

// CONSTANTS

_LIT8( KDirectChildren,         "BrowseDirectChildren" );

_LIT8( KMetaData,               "BrowseMetadata" );

_LIT8( KBrowseMetadata,         "BrowseMetadata" );

_LIT8( KDefaultStartingIndex,   "0" );

_LIT8( KDefaultRequestedCount,  "1" );

const TInt KDefaultInstanceId   = 0;

const TInt KExpectedCount       = 1;

const TInt KMaxIntLength        = 10;

_LIT( KComponentLogfile, "upnpavcontrollerserver.txt");

#include "upnplog.h"

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

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

// CUPnPBrowsingSession::NewL

// See upnpbrowsingsession.h

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

CUPnPBrowsingSession* CUPnPBrowsingSession::NewL

    (

    CUpnpAVControllerServer& aServer,

    TInt aSessionId,

    const TDesC8& aUuid

    )

    {

    CUPnPBrowsingSession* self = new (ELeave) CUPnPBrowsingSession(

        aServer, aSessionId );

    CleanupStack::PushL( self );    

    self->ConstructL( aUuid );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUPnPBrowsingSession::CUPnPBrowsingSession

// See upnpbrowsingsession.h

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

CUPnPBrowsingSession::CUPnPBrowsingSession

    (

    CUpnpAVControllerServer& aServer,

    TInt aSessionId

    ):

    iServer( aServer ),

    iSessionId( aSessionId ),

    iInstanceId( KDefaultInstanceId ),

    iIPSessionId( KErrNotFound ),

    iInternalState( ENone )

    {

    }

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

// CUPnPBrowsingSession::~CUPnPBrowsingSession

// See upnpbrowsingsession.h

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

CUPnPBrowsingSession::~CUPnPBrowsingSession()

    {

    iIPSessionId = KErrNotFound;

    delete iDevice;

    delete iRespBuf;

    delete iRespBuf2;

    delete iItemId;

    delete iLocalMediaServerUuid; 

    delete iActionMessage;

    delete iDeviceMessage;

    }

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

// CUPnPBrowsingSession::ConstructL

// See upnpbrowsingsession.h

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

void CUPnPBrowsingSession::ConstructL( const TDesC8& aUuid )

    {

    __LOG( "CUPnPBrowsingSession::ConstructL" );

    // Get the local Media Server Uuid, if available

    const RPointerArray<CUpnpAVDeviceExtended>& devList =

        iServer.DeviceRepository().DeviceList();

    TInt count = devList.Count();

    TInt i;

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

        {

        if( devList[ i ]->Local() )

            {

            __ASSERT( !iLocalMediaServerUuid, __FILE__, __LINE__ );

            iLocalMediaServerUuid = devList[i]->Uuid().AllocL();

            }

        if( devList[ i ]->Uuid() == aUuid )

            {

            __ASSERT( !iDevice, __FILE__, __LINE__ );

            iDevice = CUpnpAVDeviceExtended::NewL( *devList[ i ] );

            }             

        }

    if( !iDevice )

        {

        if( aUuid == KNullDesC8 ) // Fix to enable AV Controller helper usage

            {

            iDevice = CUpnpAVDeviceExtended::NewL();

            }

        else

            {

            User::Leave( KErrNotFound );    

            }    

        }

    else

        {

        //

        // Gets related control point device (CUpnpDevice) only if aUuid 

        // is provided. It is needed when CUpnpAVControlPoint is really 

        // used.

        //

        // In some cases CUPnPBrowsingSession is be instantiated with dummy

        // device uuid (KNullDesC8). In these cases we shouldn't leave nor

        // get the control point device.

        iCpDevice = iServer.ControlPoint().Device( aUuid );

        if ( !iCpDevice ) 

            {

            User::Leave( KErrNotFound );

            }

        }

    }

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

// CUPnPBrowsingSession::ActionResponseL

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

void CUPnPBrowsingSession::ActionResponseL(CUpnpAction* aAction)

    {

    __ASSERT( aAction->SessionId()==iIPSessionId, __FILE__, __LINE__ );

    if (aAction->Name().Compare(KGetSearchCapabilities) == 0)

        {

        CdsSearchCapabilitiesResponse(

            aAction->Error(),

            aAction->ArgumentValue( KSearchCaps ) );

        }

    else if (aAction->Name().Compare(KBrowse) == 0)

        {

        const TDesC8& numberReturned = aAction->ArgumentValue( 

                KNumberReturned );

        TLex8 returnedLex( numberReturned );

        TInt numberReturnedInt;

        User::LeaveIfError( returnedLex.Val( numberReturnedInt ) );

        const TDesC8& totalmatches = aAction->ArgumentValue( KTotalMatches );

        TLex8 matchesLex( totalmatches );

        TInt totalMatchesInt;

        User::LeaveIfError( matchesLex.Val( totalMatchesInt ) );

        CdsBrowseResponseL(

            aAction->Error(),

            aAction->ArgumentValue( KBrowseFlag ),

            aAction->ArgumentValue( KResult ),

            numberReturnedInt,

            totalMatchesInt,

            aAction->ArgumentValue( KUpdateID ) );

        }

    else if (aAction->Name().Compare(KSearch) == 0)

        {		

        const TDesC8& numberReturned = aAction->ArgumentValue( 

                KNumberReturned );

        TLex8 returnedLex( numberReturned );

        TInt numberReturnedInt;

        User::LeaveIfError( returnedLex.Val( numberReturnedInt ) );

        const TDesC8& totalmatches = aAction->ArgumentValue( KTotalMatches );

        TLex8 matchesLex( totalmatches );

        TInt totalMatchesInt;

        User::LeaveIfError( matchesLex.Val( totalMatchesInt ) );

        CdsSearchResponse(

            aAction->Error(),

            aAction->ArgumentValue( KResult ),

            numberReturnedInt,

            totalMatchesInt,

            aAction->ArgumentValue( KUpdateID )

            );

        }

    else if (aAction->Name().Compare(KDestroyObject) == 0)

        {		

        CdsDestroyObjectResponse(

            aAction->Error() );

        }

    else if (aAction->Name().Compare(KCreateObject) == 0)

        {

        CdsCreateObjectResponse(

            aAction->Error(),

            aAction->ArgumentValue(KObjectID), 

            aAction->ArgumentValue(KResult)

            );

        }

    else

        {

        __LOG( "response not expected, ignore" );

        }

    }

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

// CUPnPBrowsingSession::StateUpdatedL

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

void CUPnPBrowsingSession::StateUpdatedL(CUpnpService* /*aService*/)

    {

    // No implementation required        

    }

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

// CUPnPBrowsingSession::HttpResponseL

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

void CUPnPBrowsingSession::HttpResponseL(CUpnpHttpMessage* /*aMessage*/)

    {

    // No implementation required        

    }

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

// CUPnPBrowsingSession::DeviceDiscoveredL

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

void CUPnPBrowsingSession::DeviceDiscoveredL(CUpnpDevice* /*aDevice*/)

    {

    // No implementation required        

    }

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

// CUPnPBrowsingSession::DeviceDisappearedL

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

void CUPnPBrowsingSession::DeviceDisappearedL(CUpnpDevice* /*aDevice*/)

    {

    // No implementation required        

    }

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

// CUPnPBrowsingSession::CdsSearchCapabilitiesResponse

// See upnpbrowsingsession.h

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

void CUPnPBrowsingSession::CdsSearchCapabilitiesResponse(

    TInt aErr,

    const TDesC8& aSearchCaps)

    {

    __LOG1( "CUPnPBrowsingSession::CdsSearchCapabilitiesResponse: %d",

        aErr );

    iServer.Dispatcher().UnRegister( iIPSessionId );

    iIPSessionId = KErrNotFound;

    if( iActionMessage )

        {

        aErr = UPnPAVErrorHandler::ConvertToSymbianErrorCode( aErr,

            EUPnPContentDirectoryError );    

        if( aErr == KErrNone )

            {

            if(  aSearchCaps != KNullDesC8 )

                {

                delete iRespBuf; iRespBuf = NULL;

                iRespBuf = aSearchCaps.Alloc();

                if( iRespBuf )

                    {

                    TPckgBuf<TInt> resp1( aSearchCaps.Length() );

                    iActionMessage->Write( 1, resp1 );

                    }

                else

                    {

                    TPckgBuf<TInt> resp1( 0 );

                    iActionMessage->Write( 1, resp1 );

                    }

                iActionMessage->Complete(

                    EAVControllerGetSearchCapabilitiesSizeCompleted );      

                delete iActionMessage; iActionMessage = NULL;

                }

            else

                {

                TPckgBuf<TInt> resp1( 0 );

                iActionMessage->Write( 1, resp1 );

                iActionMessage->Complete(

                    EAVControllerGetSearchCapabilitiesSizeCompleted );

                delete iActionMessage; iActionMessage = NULL;

                }    

            }

        else

            {

            iActionMessage->Complete( aErr );

            delete iActionMessage; iActionMessage = NULL;

            }        

        }

    else

        {

        __LOG( "CdsSearchCapabilitiesResponse - no msg" );

        }

    }

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

// CUPnPBrowsingSession::CdsBrowseResponseL

// See upnpbrowsingsession.h

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

void CUPnPBrowsingSession::CdsBrowseResponseL(

    TInt aErr,

    const TDesC8&  aBrowseFlag,

    const TDesC8&  aResult,

    TInt aReturned,

    TInt aMatches,

    const TDesC8&  aUpdateID )

    {

    __LOG1( "CUPnPBrowsingSession::CdsBrowseResponseL: %d", aErr );

    iServer.Dispatcher().UnRegister( iIPSessionId );

    iIPSessionId = KErrNotFound;

    if( iActionMessage )

        {

        if (  aBrowseFlag.CompareF( KBrowseMetadata ) == 0 && aReturned == 0 

                && aErr != KErrCouldNotConnect && aErr != KErrHostUnreach )

            {

            aErr = ENoSuchObject;  //the file not exist;

            }

        if ( aErr != KErrCouldNotConnect && aErr != KErrHostUnreach )

            {

            aErr = UPnPAVErrorHandler::ConvertToSymbianErrorCode( aErr,

            EUPnPContentDirectoryError );

            __LOG1( "CUPnPBrowsingSession::CdsBrowseResponseL:001 %d", 

                    aErr );

            }    

        if( aErr == KErrNone )

            {

            if( aResult != KNullDesC8 )

                {

                if( iInternalState == EDestroyObject )

                    {

                    TRAP( aErr, CheckAndSendDestroyObjectActionL( aResult) );

                    if( aErr )    

                        {

                        iInternalState = ENone;

                        iActionMessage->Complete( aErr );

                        delete iActionMessage; iActionMessage = NULL;

                        }

                    }    

                else // Browse

                    {

                    delete iRespBuf; iRespBuf = NULL;

                    delete iRespBuf2; iRespBuf2 = NULL;

                    iRespBuf = aResult.Alloc();

                    iRespBuf2 = aUpdateID.Alloc();

                    if( iRespBuf && iRespBuf2 )

                        {

                        TUpnpAVBrowseRespParams params;

                        TPckg<TUpnpAVBrowseRespParams> resp2( params );

                        params.iMatches = aReturned ;

                        params.iTotalCount = aMatches;

                        params.iResponseSize = aResult.Length();

                        params.iUpdateIdSize = aUpdateID.Length();

                        iActionMessage->Write( 2, resp2 );

                        iActionMessage->Complete( 

                            EAVControllerGetBrowseResponseSizeCompleted );

                        }

                    else

                        {

                        delete iRespBuf; iRespBuf = NULL;

                        delete iRespBuf2; iRespBuf2 = NULL;

                        iActionMessage->Complete( KErrNoMemory );

                        }

                    iInternalState = ENone;

                    delete iActionMessage; iActionMessage = NULL;      

                    }    

                }

            else

                {

                if( iInternalState == EBrowse )

                    {

                    TUpnpAVBrowseRespParams params;

                    TPckg<TUpnpAVBrowseRespParams> resp2( params );

                    params.iMatches = 0;

                    params.iTotalCount = 0;

                    params.iResponseSize = 0;

                    params.iUpdateIdSize = 0;

                    iActionMessage->Write( 2, resp2 );

                    iInternalState = ENone;

                    iActionMessage->Complete(

                        EAVControllerGetBrowseResponseSizeCompleted );

                    delete iActionMessage; iActionMessage = NULL;

                    }

                else

                    {

                    iInternalState = ENone;

                    iActionMessage->Complete( aErr );

                    delete iActionMessage; iActionMessage = NULL;

                    }        

                }    

            }

        else

            {

            iInternalState = ENone;

            iActionMessage->Complete( aErr );

            delete iActionMessage; iActionMessage = NULL;

            if ( KErrCouldNotConnect == aErr || KErrHostUnreach == aErr )

                {

                iServer.DeviceDisappearedL( iDevice->Uuid() );

                }

            }            

        }

    else

        {

        __LOG( "CdsBrowseResponseL - no msg" );

        }    

    }

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

// CUPnPBrowsingSession::CdsSearchResponse

// See upnpbrowsingsession.h