// Copyright (c) 2006-2009 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 <mtp/mmtpconnection.h>
#include <mtp/mmtpdataproviderframework.h>
#include <mtp/mtpdataproviderapitypes.h>
#include <mtp/tmtptyperequest.h>

#include "cmtpproxydp.h"
#include "cmtprequestprocessor.h"
#include "mtpproxydppanic.h"
#include "mtpproxydpprocessor.h" 

static const TInt KMTPProxyDpSessionGranularity = 3;	

__FLOG_STMT(_LIT8(KComponent,"CMTPProxyDataProvider");)

/**
Standard NewL method
@param aParams	The pointer to MMTPDataProviderFramework
*/	
TAny* CMTPProxyDataProvider::NewL(TAny* aParams)
	{
	CMTPProxyDataProvider* self = new (ELeave) CMTPProxyDataProvider(aParams);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
	}
	
	
void CMTPProxyDataProvider::ConstructL()
	{  
	__FLOG_OPEN(KMTPSubsystem, KComponent);  
	__FLOG(_L8("ConstructL - Entry"));
	iDpSingletons.OpenL(Framework());
	iSingletons.OpenL(Framework());
	__FLOG(_L8("ConstructL - Exit"));
	}

/**
Destructor
*/	
CMTPProxyDataProvider::~CMTPProxyDataProvider()
	{
	TInt count = iActiveProcessors.Count();
	while(count--)
		{
		iActiveProcessors[count]->Release();
		}
	iActiveProcessors.Close();	
	iDpSingletons.Close();
	iSingletons.Close();
    __FLOG_CLOSE; 
	}
    
void CMTPProxyDataProvider::Cancel()
    {
    
    }

/**
Process the event from initiator
@param aEvent	The event to be processed
@param aConnection	The connection from which the event comes
*/	
void CMTPProxyDataProvider::ProcessEventL(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection)
	{
	TInt index = LocateRequestProcessorL(aEvent, aConnection);
	if(index != KErrNotFound)
		{
		iActiveProcessors[index]->HandleEventL(aEvent);
		}
	}
     
void CMTPProxyDataProvider::ProcessNotificationL(TMTPNotification aNotification, const TAny* aParams)
    {
    switch (aNotification)
        {
    case EMTPSessionClosed:
        SessionClosedL(*reinterpret_cast<const TMTPNotificationParamsSessionChange*>(aParams));
        break;
        
    case EMTPSessionOpened:
        SessionOpenedL(*reinterpret_cast<const TMTPNotificationParamsSessionChange*>(aParams));
        break;
        
    default:
        // Ignore all other notifications.
        break;
        }
    }

/**
Process the request from initiator.  The method first searches if there is any matching active processor;
if not, it creates a new processor.  It deletes the processor once it finishes.
@param aPhase	The request transaction phase
@param aRequest	The request to be processed
@param aConnection	The connection from which the request comes
*/	
void CMTPProxyDataProvider::ProcessRequestPhaseL(TMTPTransactionPhase aPhase, const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
	{	
	TInt index = LocateRequestProcessorL(aRequest, aConnection);
	__ASSERT_DEBUG(index != KErrNotFound, Panic(EMTPNoMatchingProcessor));
	MMTPRequestProcessor* processor = iActiveProcessors[index];
	iActiveProcessor = index;
	iActiveProcessorRemoved = EFalse;
	TBool result = processor->HandleRequestL(aRequest, aPhase);
	if (iActiveProcessorRemoved)
		    {
		    processor->Release(); // destroy the processor
		    }
	else if (result)
		    {    
		    processor->Release();    	
		    iActiveProcessors.Remove(index);
		    }
	iActiveProcessor = -1;

	}
	
void CMTPProxyDataProvider::StartObjectEnumerationL(TUint32 aStorageId, TBool /*aPersistentFullEnumeration*/)
    {
    // The proxy data provider does not manage any data objects.
    Framework().ObjectEnumerationCompleteL(aStorageId);
    }
    
void CMTPProxyDataProvider::StartStorageEnumerationL()
    {
    Framework().StorageEnumerationCompleteL();
    }

/**
Append all the operations that are supported by the proxy data provider to
the operations array.
@param aCategory category of operations of interest
@param aArray array to hold the operations
*/
void CMTPProxyDataProvider::Supported(TMTPSupportCategory aCategory, RArray<TUint>& /*aArray*/) const
    {

    __FLOG(_L8("Supported - Entry"));
    switch (aCategory) 
        {        
    case EEvents:
        break;
        
    case EObjectCaptureFormats:
    case EObjectPlaybackFormats:

        break;
        
    case EObjectProperties:
        break; 
        
    case EOperations:
        break;  
        
    case EStorageSystemTypes:
        break; 
        
    default:
    
        // Unrecognised category, leave aArray unmodified.
        break;
        }
    __FLOG(_L8("Supported - Exit"));

    }
    

void CMTPProxyDataProvider::SupportedL(TMTPSupportCategory /*aCategory*/, CDesCArray& /*aStrings*/) const
	{
	__FLOG(_L8("SupportedL - Entry"));
	__FLOG(_L8("SupportedL - Exit"));
	}
  
    
/**
Get the pointer to the extended interface
@param aInterfaceUid	The uid of the extended interface
@return the pointer to the extended interface
*/
TAny* CMTPProxyDataProvider::GetExtendedInterface(TUid /*aInterfaceUid*/)
    {
    return NULL;
    }

/**
Standard c++ constructor
*/
CMTPProxyDataProvider::CMTPProxyDataProvider(TAny* aParams)
	:CMTPDataProviderPlugin(aParams),
	iActiveProcessors(KMTPProxyDpSessionGranularity),
	iActiveProcessor(-1)
	{
	}

/**
Find or create a request processor that can process the request
@param aRequest	The request to be processed
@param aConnection The connection from which the request comes
@return the index of the found/created request processor
*/
TInt CMTPProxyDataProvider::LocateRequestProcessorL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
    {
    TInt index = KErrNotFound;
    TInt count = iActiveProcessors.Count();
    for(TInt i = 0; i < count; i++)
        {
        if(iActiveProcessors[i]->Match(aRequest, aConnection))
            {
            index = i;
            break;
            }
        }
    if(index == KErrNotFound)
        {
        MMTPRequestProcessor* processor = MTPProxyDpProcessor::CreateL(Framework(), aRequest, aConnection);
        __ASSERT_DEBUG(processor, Panic(EMTPNoMatchingProcessor));
        CleanupReleasePushL(*processor);
        iActiveProcessors.AppendL(processor);
        CleanupStack::Pop();
        index = count;
        }
    return index;

    }

/**
Find a request processor that can process the event
@param aEvent	The event to be processed
@param aConnection The connection from which the request comes
@return the index of the found request processor, KErrNotFound if not found
*/	
TInt CMTPProxyDataProvider::LocateRequestProcessorL(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection)
    {
    TInt index = KErrNotFound;
    TInt count = iActiveProcessors.Count();
    for(TInt i = 0; i < count; i++)
        {
        if(iActiveProcessors[i]->Match(aEvent, aConnection))
            {
            index = i;
            break;
            }
        }
    return index;
    }
       
void CMTPProxyDataProvider::SessionClosedL(const TMTPNotificationParamsSessionChange& aSession)
    {
    TInt count = iActiveProcessors.Count();
    while(count--)
        {
        MMTPRequestProcessor* processor = iActiveProcessors[count];
        TUint32 sessionId = processor->SessionId();
        if((sessionId == aSession.iMTPId) && (processor->Connection().ConnectionId() == aSession.iConnection.ConnectionId()))
            {
            iActiveProcessors.Remove(count);
            if (count == iActiveProcessor)
    			{
    			iActiveProcessorRemoved = ETrue;
    			}
			else
    			{    			
    			processor->Release();
    			} 
            }
        }  
    }

/**
Prepares for a newly-opened session.
@param aSession notification parameter block
*/
#ifdef __FLOG_ACTIVE
void CMTPProxyDataProvider::SessionOpenedL(const TMTPNotificationParamsSessionChange& /*aSession*/)
#else
void CMTPProxyDataProvider::SessionOpenedL(const TMTPNotificationParamsSessionChange& /*aSession*/)
#endif
    {
    __FLOG(_L8("SessionOpenedL - Entry"));
    __FLOG(_L8("SessionOpenedL - Exit"));
    }