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

#include <mtp/cmtpstoragemetadata.h>

#include <mtp/mmtpconnection.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/mtpdataproviderapitypes.h>

#include <mtp/tmtptyperequest.h>

#include <mtp/cmtptypestring.h>

#include <mtp/cmtpobjectmetadata.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 "cmtpconnectionmgr.h"

#include "cmtpextndevdp.h"

// Class constants.

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()

    {

    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();

    delete iDeviceInfoTimer;

    iFrameWork.Close();

    }

void CMTPDeviceDataProvider::Cancel()

    {

    }

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

    {

    TInt index = LocateRequestProcessorL(aEvent, aConnection);

    if(index != KErrNotFound)

        {

        iActiveProcessors[index]->HandleEventL(aEvent);

        }

    }

void CMTPDeviceDataProvider::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;

    case EMTPObjectAdded:

        AddFolderRecursiveL(*reinterpret_cast<const TMTPNotificationParamsFolderChange*>( aParams ));

        break;

    default:

        // Ignore all other notifications.

        break;

        }

    }

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

    {

    TUint16 opCode( aRequest.Uint16( TMTPTypeRequest::ERequestOperationCode ) );    

    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;

    const static TInt32 KMTPUsbTransportUid = 0x102827B2;

    if((EMTPOpCodeGetDeviceInfo == opCode)&&(KMTPUsbTransportUid == iFrameWork.ConnectionMgr().TransportUid().iUid))

        {

        //If GetDeviceInfo comes and there is no OpenSession before, the timer will start. And tread the host as Mac. 

        //Only the first GetDeviceInfo in one session will start the timer.

        if((EIdle == iCommandState)&&(NULL == iDeviceInfoTimer))

            {

            iCommandState = EStartDeviceInfoTimer;

            iDeviceInfoTimer = CMTPDeviceInfoTimer::NewL(*this);

            iDeviceInfoTimer->Start();

            }

        else

            {

            }

        }

    else

       {       

       if((EMTPOpCodeOpenSession == opCode)&&(EIdle == iCommandState))

            {

            iCommandState = EOpenSession;

            }

       if(iDeviceInfoTimer)

           {

           delete iDeviceInfoTimer;

           iDeviceInfoTimer = NULL;

           }

       else

           }

       }    

    }

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

    {

    iPendingEnumerations.AppendL(aStorageId);

    if (iEnumeratingState == EUndefined)

        {

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

        iEnumeratingState = EEnumeratingDeviceDataStore;

        iStorageWatcher->Start();

        }

    else

        {

    	iEnumeratingState = EEnumeratingFolders;

    	NotifyEnumerationCompleteL(aStorageId, KErrNone);

        }

    }

void CMTPDeviceDataProvider::StartStorageEnumerationL()

    {

    iStorageWatcher->EnumerateStoragesL();

    Framework().StorageEnumerationCompleteL();

    }

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

    {

    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;

        }

    }

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

	{

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

    if (iPendingEnumerations.Count() > 0)

        {

        iPendingEnumerations.Remove(KMTPDeviceDpActiveEnumeration);

        }

	switch(iEnumeratingState)

		{

	case EEnumeratingDeviceDataStore:

	case EEnumeratingFolders:

	    iEnumeratingState = EEnumerationComplete;

	    Framework().ObjectEnumerationCompleteL(aStorageId);

		//iEnumerator->StartL(iPendingEnumerations[KMTPDeviceDpActiveEnumeration]);

		break;

	case EEnumerationComplete:

	default:

		__DEBUG_ONLY(User::Invariant());

		break;

		}

	}

/**

Constructor.

*/

CMTPDeviceDataProvider::CMTPDeviceDataProvider(TAny* aParams) :

    CMTPDataProviderPlugin(aParams),

    iActiveProcessors(KMTPDeviceDpSessionGranularity),

    iActiveProcessor(-1),

    iDeviceInfoTimer(NULL),

    iCommandState(EIdle)

    {

    }

/**

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 )

			{

            CleanupStack::PushL(extnpluginMap);

			iExtnPluginMapArray.AppendL(extnpluginMap);

			CleanupStack::Pop(extnpluginMap);

			}

		}

	CleanupStack::PopAndDestroy(&extnUidArray);

	}

void CMTPDeviceDataProvider::AddFolderRecursiveL( const TMTPNotificationParamsFolderChange& aFolder )

    {

    TPtrC folderRight( aFolder.iFolderChanged );

    if ( !BaflUtils::FolderExists( Framework().Fs(), folderRight ))

    	{

    	User::Leave( KErrArgument );

    	}

    TUint32 parentHandle( KMTPHandleNoParent );

    TUint32 handle( KMTPHandleNoParent );

    TInt pos( KErrNotFound );

    TInt lengthOfRight( folderRight.Length());

    TFileName folderLeft;

    /*

    Go through from beginning.

    when this while end, folderLeft keeps the top

    layer folder which has no handle

    */

    do 

        {

        pos = folderRight.Locate( KPathDelimiter );

        if ( KErrNotFound == pos )

            {

            break;

            }

        folderLeft.Append( folderRight.Left( pos + 1 ));

        lengthOfRight = folderRight.Length()-pos -1;

        folderRight.Set( folderRight.Right( lengthOfRight ));

        	{

        	//first time, root folder

        	//continue

        	continue;

        	}

        parentHandle = handle;

        handle = Framework().ObjectMgr().HandleL( folderLeft );

        }

    while( KMTPHandleNone != handle );

    if ( KMTPHandleNone == handle )

        {

        CMTPObjectMetaData* folderObject = CMTPObjectMetaData::NewL();

        TUint32 storageId = GetStorageIdL( folderLeft );

        while( 1 )

            {

            parentHandle = AddEntryL( folderLeft, parentHandle, storageId, *folderObject );

            OnDeviceFolderChangedL( EMTPEventCodeObjectAdded, *folderObject );

            pos = folderRight.Locate( KPathDelimiter );

            lengthOfRight = folderRight.Length()-pos -1;

            if ( KErrNotFound == pos )

            	{

            	break;

            	}

            folderLeft.Append( folderRight.Left( pos + 1  ));

            folderRight.Set( folderRight.Right( lengthOfRight ));

            }

        delete folderObject;

        }

    }

TUint32 CMTPDeviceDataProvider::AddEntryL( const TDesC& aPath, TUint32 aParentHandle, TUint32 aStorageId, CMTPObjectMetaData& aObjectInfo  )

    {

    TBool isFolder( EFalse );

    BaflUtils::IsFolder( Framework().Fs(), aPath, isFolder );

    __ASSERT_ALWAYS( isFolder, User::Leave( KErrArgument ));

    __ASSERT_ALWAYS( aParentHandle != KMTPHandleNone, User::Leave( KErrArgument ));

    __ASSERT_ALWAYS( Framework().StorageMgr().ValidStorageId( aStorageId ), User::Leave( KErrArgument ));