/*
* 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:  Source file for CUpnpCommandImplementation class.
*
*/


// INCLUDE FILES
// system
#include <centralrepository.h>

// upnpframework / avcontroller helper api
#include "upnpfileutility.h"                    // IsFileProtectedL()

// upnpframework / command api
#include "upnpcommand.h"                        // CUpnpCommand
#include "upnpcommandcallback.h"                // MUpnpCommandCallback

// command internal
#include "upnpcommandimplementation.h"
#include "upnpfilepipe.h"
#include "upnpcommandparameters.h"
#include "upnpnotehandler.h"
#include "upnpshowtask.h"
#include "upnpcopytask.h"
#include "upnpmovetask.h"
#include "upnpbrowsetask.h"
#include "upnprunsetuptask.h"

_LIT( KComponentLogfile, "upnpcommand.log");
#include "upnplog.h"

// CONSTANTS
const TUid KCRUidUPnPApplication = {0x20009cae};
const TUint32 KUPnPAppAccessPointSetting = 0x00000001;


// --------------------------------------------------------------------------
// CUpnpCommandImplementation::NewL
// Creates an instance of the implementation.
// --------------------------------------------------------------------------
//
CUpnpCommandImplementation* CUpnpCommandImplementation::NewL()
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::NewL" );
    
    CUpnpCommandImplementation* self = NULL;
    self = new (ELeave) CUpnpCommandImplementation();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::CUpnpCommandImplementation
// First phase construction.
// --------------------------------------------------------------------------
//
CUpnpCommandImplementation::CUpnpCommandImplementation()
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::Constructor" );

    // Set command ID to unknown by default. Client is forced to set this
    // (inline code in the NewL method of CUpnpCommand interface class).
    iCommandId = UpnpCommand::ECommandUndefined;

    // By default there is no task
    iTask = NULL;

    // By default the state is IDLE (resources not allocated nor executing)
    iState = UpnpCommand::EStateIdle;

    // DRM note will be shown only once
    iDrmNoteShown = EFalse;
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::ConstructL
// Second phase construction.
// --------------------------------------------------------------------------
//
void CUpnpCommandImplementation::ConstructL()
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::ConstructL" );

    iFilePipe = CUpnpFilePipe::NewL();
    iParameters = CUpnpCommandParameters::NewL();
    iNoteHandler = CUpnpNoteHandler::NewL();
    }

// --------------------------------------------------------------------------
// Destructor.
// --------------------------------------------------------------------------
//
CUpnpCommandImplementation::~CUpnpCommandImplementation()
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::Destructor" );

    delete iTask;
    iTask = NULL;
    delete iFilePipe;
    iFilePipe = NULL;
    delete iParameters;
    iParameters = NULL;
    delete iNoteHandler;
    iNoteHandler = NULL;
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::SetCommandIdL
// Sets the command ID.
// --------------------------------------------------------------------------
//
void CUpnpCommandImplementation::SetCommandIdL(
    UpnpCommand::TUpnpCommandId aCommandId )
    {
    __LOG1( "[UpnpCommand]\t CUpnpCommandImplementation::SetCommandIdL %d",
        TInt( aCommandId ) );

    // command ID can only be set ONCE !
    __ASSERTD( iCommandId == UpnpCommand::ECommandUndefined,
        __FILE__, __LINE__ );
    if( iCommandId != UpnpCommand::ECommandUndefined )
        {
        User::Leave( KErrServerBusy );
        }

    iCommandId = aCommandId;

    // If the command is to Show images & video, re-create the file pipe.
    // In this case we are using a file pipe of a limited size (1)
    if( iCommandId == UpnpCommand::ECommandShow )
        {
        delete iFilePipe;
        iFilePipe = NULL; // In case the following method leaves
        iFilePipe = CUpnpFilePipe::NewL( 1 );
        }
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::SetObserver
// Sets the callback interface
// --------------------------------------------------------------------------
//
void CUpnpCommandImplementation::SetObserver(
    MUpnpCommandCallback* aCallback )
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::SetObserver" );

    // Set the observer
    iParameters->SetObserver( aCallback );
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::IsAvailableL
// Checks if a command is available for execution
// --------------------------------------------------------------------------
//
TBool CUpnpCommandImplementation::IsAvailableL()
    {
    return IsAvailableL( iCommandId );
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::IsAvailableL
// Checks if a command is available for execution
// --------------------------------------------------------------------------
//
TBool CUpnpCommandImplementation::IsAvailableL(
    UpnpCommand::TUpnpCommandId aCommandId )
    {
    TBool available( EFalse );
    switch( aCommandId )
        {
        case UpnpCommand::ECommandShow: // flow through
        case UpnpCommand::ECommandCopy: // flow through
        case UpnpCommand::ECommandMove: // flow through
        case UpnpCommand::ECommandBrowse:
            {
            // available if upnp is configured
            available = IsUpnpConfiguredL();
            }
            break;
        case UpnpCommand::ECommandSetup:
            {
            // setup is always available
            available = ETrue;
            }
            break;
        default:
            {
            __PANIC( __FILE__, __LINE__ );
            }
            break;
        }

    return available;
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::AllocateResourcesL
// Allocates the Upnp Framework resources.
// --------------------------------------------------------------------------
//
void CUpnpCommandImplementation::AllocateResourcesL()
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::AllocateResourcesL" );

    // Leave if a task is already going (resources allocated)
    if( iTask )
        {
        User::Leave( KErrAlreadyExists );
        }

    // Instantiate a task according to the command ID
    if( iCommandId == UpnpCommand::ECommandShow )
        {
        iTask = CUpnpShowTask::NewL();
        }
    else if( iCommandId == UpnpCommand::ECommandCopy )
        {
        iTask = CUpnpCopyTask::NewL();
        }
    else if( iCommandId == UpnpCommand::ECommandMove )
        {
        iTask = CUpnpMoveTask::NewL();
        }
    else if( iCommandId == UpnpCommand::ECommandBrowse )
        {
        iTask = CUpnpBrowseTask::NewL();
        }
    else if( iCommandId == UpnpCommand::ECommandSetup )
        {
        iTask = CUpnpRunSetupTask::NewL();
        }
    else
        {
        __PANICD( __FILE__, __LINE__ );
        User::Leave( KErrNotSupported );
        }

    // Set the pointers for the task (using base class CUpnpTask methods)
    iTask->SetTaskHandlerL( this );
    iTask->SetCommandParametersL( iParameters );
    iTask->SetFilePipeL( iFilePipe );
    iTask->SetNoteHandlerL( iNoteHandler );

    // Allocate the resources
    TRAPD( allocateError, iTask->AllocateResourcesL() );
    
    // If allocating resources failed, delete the task and forward the
    // leave code.
    if( allocateError != KErrNone )
        {
        __LOG1( "[UpnpCommand]\t AllocateResourcesL \
failed %d", allocateError );
        // show note only if operation was not cancelled by user
        if( allocateError != KErrCancel )
            {
            TRAP_IGNORE( iNoteHandler->ShowConnectionLostNoteL() );
            }
            
        delete iTask;
        iTask = NULL;
        iState = UpnpCommand::EStateIdle;
        User::Leave( allocateError );
        }

    // Update the state
    iState = UpnpCommand::EStateAllocated;
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::ReleaseResources
// Releases the Upnp Framework resources.
// --------------------------------------------------------------------------
//
void CUpnpCommandImplementation::ReleaseResources()
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::ReleaseResources" );

    // Destroy the task
    if( iTask )
        {
        delete iTask;
        iTask = NULL;
        }

    // Update the state
    iState = UpnpCommand::EStateIdle;
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::ExecuteL
// Executes the command.
// --------------------------------------------------------------------------
//
void CUpnpCommandImplementation::ExecuteL()
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::ExecuteL" );

    // Allocates Upnp Fw resources if not yet allocated
    if( !iTask )
        {
        __LOG( "[UpnpCommand]\t ExecuteL task deleted, leave" );
        User::Leave( KErrNotReady );
        }

    // Update the state
    iState = UpnpCommand::EStateExecuting;

    // Execute the task
    TInt status = KErrNone;
    TRAP( status, iTask->ExecuteL() );

    // Update the state
    iState = UpnpCommand::EStateAllocated;

    // If operation failed, leave
    if( status != KErrNone )
        {
        User::Leave( status );
        }
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::SetParameterL
// Set a parameter.
// --------------------------------------------------------------------------
//
void CUpnpCommandImplementation::SetParameterL(
    UpnpCommand::TUpnpParameterType aParamType,
    const TDesC& aParamValue )
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::SetParameterL" );
    __ASSERTD( iParameters!=0, __FILE__, __LINE__ );

    iParameters->SetL( aParamType, aParamValue );
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::Parameter
// --------------------------------------------------------------------------
//
const TDesC& CUpnpCommandImplementation::Parameter(
    UpnpCommand::TUpnpParameterType aParamType )
    {
    __ASSERTD( iParameters!=0, __FILE__, __LINE__ );
    return iParameters->Get( aParamType );
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::ResetParameters
// Resets parameteres.
// --------------------------------------------------------------------------
//
void CUpnpCommandImplementation::ResetParameters()
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::ResetParameters" );

    // Reset parameters
    iParameters->Reset();
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::PushFileL
// Pushes one file into the file pipe.
// --------------------------------------------------------------------------
//
void CUpnpCommandImplementation::PushFileL( const TDesC& aFilename )
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::PushFileL" );
        
    // Push it in the file pipe
    iFilePipe->PushL( aFilename );
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::CountFiles
// --------------------------------------------------------------------------
//
TInt CUpnpCommandImplementation::FileCount()
    {
    return iFilePipe->Count();
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::File
// Pops oldest file from the file pipe.
// --------------------------------------------------------------------------
//
const TDesC& CUpnpCommandImplementation::File( TInt aIndex )
    {
    return iFilePipe->FileAt( aIndex );
    }


// --------------------------------------------------------------------------
// CUpnpCommandImplementation::ResetFiles
// Resets files.
// --------------------------------------------------------------------------
//
void CUpnpCommandImplementation::ResetFiles()
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::ResetFiles" );

    // Reset files
    iFilePipe->Reset();
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::State
// Returns the state of the command.
// --------------------------------------------------------------------------
//
UpnpCommand::TUpnpCommandState CUpnpCommandImplementation::State()
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::State" );

    return iState;
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::DestroyTask
// Destroys the ongoing task.
// --------------------------------------------------------------------------
//
void CUpnpCommandImplementation::DestroyTask()
    {
    __LOG( "[UpnpCommand]\t CUpnpCommandImplementation::DestroyTask" );

    // Release resources (delete the ongoing UpnpTask).
    ReleaseResources();
    }

// --------------------------------------------------------------------------
// CUpnpCommandImplementation::IsUpnpConfigured
// --------------------------------------------------------------------------
//
TBool CUpnpCommandImplementation::IsUpnpConfiguredL()
    {
    TBool returnValue = EFalse;
    // Access the Upnp Fw central repository key
    CRepository* repository = NULL;
    TRAPD( error, repository = CRepository::NewL( KCRUidUPnPApplication ) );

    if ( error == KErrNone )
        {
        // Read the IAP setting
        TInt iapDefined = KErrNotFound;
        TInt getError = repository->Get( KUPnPAppAccessPointSetting,
                                         iapDefined );
    
        delete repository;
    
        // Define the return value (min. valid IAP Id value is 1,
        // 0=None selected)
        if( getError == KErrNone &&
            iapDefined > 0 )
            {
            returnValue = ETrue;
            }
        }
    
    return returnValue;
    }

// End of File