// 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"));

    }