// 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/cmtpstoragemetadata.h>

#include <mtp/mmtpconnection.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mtpdataproviderapitypes.h>

#include <mtp/tmtptyperequest.h>

#include "cmtpdevdpexclusionmgr.h"

#include "cmtpdevicedatastore.h"

#include "cmtpdevicedp.h"

#include "cmtpdevicedpconfigmgr.h"

#include "cmtpfsenumerator.h"

#include "cmtprequestprocessor.h"

#include "cmtpstoragewatcher.h"

#include "mtpdevicedpconst.h"

#include "mtpdevicedpprocessor.h"

#include "mtpdevdppanic.h"

#include "cmtpextndevdp.h"

// Class constants.

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

static const TInt KMTPDeviceDpSessionGranularity(3);

static const TInt KMTPDeviceDpActiveEnumeration(0);

/**

MTP device data provider plug-in factory method.

@return A pointer to an MTP device data provider plug-in. Ownership IS

transfered.

@leave One of the system wide error codes, if a processing failure occurs.

*/

TAny* CMTPDeviceDataProvider::NewL(TAny* aParams)

    {

    CMTPDeviceDataProvider* self = new (ELeave) CMTPDeviceDataProvider(aParams);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

Destructor

*/

CMTPDeviceDataProvider::~CMTPDeviceDataProvider()

    {

    __FLOG(_L8("~CMTPDeviceDataProvider - Entry"));

    iPendingEnumerations.Close();

    TInt count = iActiveProcessors.Count();

    while(count--)

        {

        iActiveProcessors[count]->Release();

        }

    iActiveProcessors.Close();

    delete iStorageWatcher;

    iDevDpSingletons.Close();

    iDpSingletons.Close();

    delete iEnumerator;

    delete iExclusionMgr;

    iExtnPluginMapArray.ResetAndDestroy();

    iExtnPluginMapArray.Close();

	iEvent.Reset();

    __FLOG(_L8("~CMTPDeviceDataProvider - Exit"));

    __FLOG_CLOSE;

    }

void CMTPDeviceDataProvider::Cancel()

    {

    }

void CMTPDeviceDataProvider::ProcessEventL(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection)

    {

    __FLOG(_L8("ProcessEventL - Entry"));

    TInt index = LocateRequestProcessorL(aEvent, aConnection);

    if(index != KErrNotFound)

        {

        iActiveProcessors[index]->HandleEventL(aEvent);

        }

    __FLOG(_L8("ProcessEventL - Exit"));

    }

void CMTPDeviceDataProvider::ProcessNotificationL(TMTPNotification aNotification, const TAny* aParams)

    {

    __FLOG(_L8("ProcessNotificationL - Entry"));

    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;

        }

    __FLOG(_L8("ProcessNotificationL - Exit"));

    }

void CMTPDeviceDataProvider::ProcessRequestPhaseL(TMTPTransactionPhase aPhase, const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)

    {

    __FLOG(_L8("ProcessRequestPhaseL - Entry"));

    TInt index = LocateRequestProcessorL(aRequest, aConnection);

    __ASSERT_DEBUG(index != KErrNotFound, Panic(EMTPDevDpNoMatchingProcessor));

    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;

    __FLOG(_L8("ProcessRequestPhaseL - Exit"));

    }

void CMTPDeviceDataProvider::StartObjectEnumerationL(TUint32 aStorageId, TBool /*aPersistentFullEnumeration*/)

    {

    __FLOG(_L8("StartObjectEnumerationL - Entry"));

    iPendingEnumerations.AppendL(aStorageId);

    if (iEnumeratingState == EUndefined)

        {

        iDevDpSingletons.DeviceDataStore().StartEnumerationL(aStorageId, *this);

        iEnumeratingState = EEnumeratingDeviceDataStore;

        iStorageWatcher->Start();

        }

    else if (iPendingEnumerations.Count() == 1)

        {

    	iEnumeratingState = EEnumeratingFolders;

    	iEnumerator->StartL(iPendingEnumerations[KMTPDeviceDpActiveEnumeration]);

        }

    __FLOG(_L8("StartObjectEnumerationL - Exit"));

    }

void CMTPDeviceDataProvider::StartStorageEnumerationL()

    {

    __FLOG(_L8("StartStorageEnumerationL - Entry"));

    iStorageWatcher->EnumerateStoragesL();

    Framework().StorageEnumerationCompleteL();

    __FLOG(_L8("StartStorageEnumerationL - Exit"));

    }

void CMTPDeviceDataProvider::Supported(TMTPSupportCategory aCategory, RArray<TUint>& aArray) const

    {

    __FLOG(_L8("Supported - Entry"));

    TInt mode = Framework().Mode();

    switch (aCategory)

        {

    case EAssociationTypes:

        aArray.Append(EMTPAssociationTypeGenericFolder);        

        break;

    case EDeviceProperties:

        {

        TInt count = sizeof(KMTPDeviceDpSupportedProperties) / sizeof(TUint16);

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

            {

            if(( (EModePTP == mode) ||(EModePictBridge == mode) )

				&& ( 0x4000 == (KMTPDeviceDpSupportedProperties[i] & 0xE000)))

            	{

            	//in ptp mode support only ptp properties

            	aArray.Append(KMTPDeviceDpSupportedProperties[i]);

            	}

            else

            	{

            	aArray.Append(KMTPDeviceDpSupportedProperties[i]);

            	}

            }

        TInt noOfEtxnPlugins = iExtnPluginMapArray.Count();

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

	        {

	        iExtnPluginMapArray[i]->ExtPlugin()->Supported(aCategory, *iExtnPluginMapArray[i]->SupportedOpCodes(), (TMTPOperationalMode)mode );// or pass the incoming array

	        TInt count =iExtnPluginMapArray[i]->SupportedOpCodes()->Count();

       												  														//bcoz it needs to b updated

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

	        	{

	        	aArray.Append((*iExtnPluginMapArray[i]->SupportedOpCodes())[r]);

	        	}

	       }

       TRAP_IGNORE(iPtrDataStore->SetSupportedDevicePropertiesL(aArray));

       }

        break;

    case EEvents:

        {

        TInt count = sizeof(KMTPDeviceDpSupportedEvents) / sizeof(TUint16);

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

            {

            TUint16 event = KMTPDeviceDpSupportedEvents[i];

            switch(mode)

                {

            case EModePTP:

            case EModePictBridge:

                // In the initial implementation all device DP events pass this test, but this

                // catches any others added in the future that fall outside this range.

                if(event <= EMTPEventCodePTPEnd)

                    {

                    aArray.Append(event);

                    }

                break;

            case EModeMTP:

                // In the initial implementation all device DP events pass this test, but this

                // catches any others added in the future that fall outside this range.

                if(event <= EMTPEventCodeMTPEnd)

                    {

                    aArray.Append(event);

                    }

                break;

            default:

            	// No other valid modes are defined

                break;

                }

            }

        }

        break;

    case EObjectCaptureFormats:

    case EObjectPlaybackFormats:

  		// Only supports association objects

        aArray.Append(EMTPFormatCodeAssociation);

        break;

    case EOperations:

        {

        TInt count = sizeof(KMTPDeviceDpSupportedOperations) / sizeof(TUint16);

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

            {

            aArray.Append(KMTPDeviceDpSupportedOperations[i]);

            }

        }

        break;

    case EStorageSystemTypes:

        aArray.Append(CMTPStorageMetaData::ESystemTypeDefaultFileSystem);

        break;

    case EObjectProperties:

        {

        TInt count(sizeof(KMTPDeviceDpSupportedObjectProperties) / sizeof(KMTPDeviceDpSupportedObjectProperties[0]));

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

            {

            aArray.Append(KMTPDeviceDpSupportedObjectProperties[i]);

            }

        }

        break;

    default:

        // Unrecognised category, leave aArray unmodified.

        break;

        }

    __FLOG(_L8("Supported - Exit"));

    }

#ifdef __FLOG_ACTIVE

void CMTPDeviceDataProvider::NotifyEnumerationCompleteL(TUint32 aStorageId, TInt aError)

#else

void CMTPDeviceDataProvider::NotifyEnumerationCompleteL(TUint32 aStorageId, TInt /*aError*/)

#endif // __FLOG_ACTIVE

	{

    __FLOG(_L8("NotifyEnumerationCompleteL - Entry"));

    __ASSERT_DEBUG((aStorageId == iPendingEnumerations[KMTPDeviceDpActiveEnumeration]), User::Invariant());

	switch(iEnumeratingState)

		{

	case EEnumeratingDeviceDataStore:

		iEnumeratingState = EEnumeratingFolders;

		iEnumerator->StartL(iPendingEnumerations[KMTPDeviceDpActiveEnumeration]);

		break;

	case EEnumeratingFolders:

        __FLOG_VA((_L8("Enumeration of storage 0x%08X completed with error status %d"), aStorageId, aError));

        iPendingEnumerations.Remove(KMTPDeviceDpActiveEnumeration);

        Framework().ObjectEnumerationCompleteL(aStorageId);

        if (iPendingEnumerations.Count() > 0)

            {

        	iEnumerator->StartL(iPendingEnumerations[KMTPDeviceDpActiveEnumeration]);

            }

        else

            {

    		iEnumeratingState = EEnumerationComplete;

            }

		break;

	case EEnumerationComplete:

	default:

		__DEBUG_ONLY(User::Invariant());

		break;

		}

    __FLOG(_L8("NotifyEnumerationCompleteL - Exit"));

	}

/**

Constructor.

*/

CMTPDeviceDataProvider::CMTPDeviceDataProvider(TAny* aParams) :

    CMTPDataProviderPlugin(aParams),

    iActiveProcessors(KMTPDeviceDpSessionGranularity),

    iActiveProcessor(-1)

    {

    }

/**

Load devdp extension plugins if present

*/

void CMTPDeviceDataProvider::LoadExtnPluginsL()

	{

	RArray<TUint> extnUidArray;

	CleanupClosePushL(extnUidArray);

	iDevDpSingletons.ConfigMgr().GetRssConfigInfoArrayL( extnUidArray, EDevDpExtnUids);

	TInt count = extnUidArray.Count();

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

		{

		CDevDpExtnPluginMap* extnpluginMap = NULL;

		extnpluginMap = CDevDpExtnPluginMap::NewL(*this, TUid::Uid(extnUidArray[i]));

		if(extnpluginMap )

			{

			iExtnPluginMapArray.Append(extnpluginMap);

			}

		}

	CleanupStack::PopAndDestroy(&extnUidArray);

	}

/**

Second phase constructor.

*/