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

#include <barsread.h> 

#include <e32property.h>

#include <mtp/cmtpdataproviderplugin.h>

#include <mtp/mtpprotocolconstants.h>

#include <mtp/rmtpclient.h>

#include "cmtpdataprovider.h"

#include "cmtpdataproviderconfig.h"

#include "cmtpdataprovidercontroller.h"

#include "cmtpobjectmgr.h"

#include "mtpframeworkconst.h"

#include "cmtpframeworkconfig.h"

#include "cmtpstoragemgr.h"

// Class constants.

_LIT(KMTPDpResourceDirectory, "z:\\resource\\mtp\\");

_LIT(KMTPDpDummyResourcefile, "z:\\resource\\mtp\\dummydp.rsc");

// Class constants.

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

static const TUint KOpaqueDataLength(64);

/**

CMTPDataProviderController panics

*/

_LIT(KMTPPanicCategory, "CMTPDataProviderController");

enum TMTPPanicReasons

    {

    EMTPPanicStorageEnumeration = 0,

    EMTPPanicFrameworkEnumeration = 1,

    EMTPPanicDataProviderStorageEnumeration = 2,

    EMTPPanicDataProviderEnumeration = 3

    };

LOCAL_C void Panic(TInt aReason)

    {

    User::Panic(KMTPPanicCategory, aReason);

    }

/**

CMTPDataProviderController factory method. 

@return A pointer to a new CMTPDataProviderController instance. Ownership IS 

transfered.

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

*/

CMTPDataProviderController* CMTPDataProviderController::NewL()

    {

    CMTPDataProviderController* self = new (ELeave) CMTPDataProviderController();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

Destructor.

*/

CMTPDataProviderController::~CMTPDataProviderController()

    {

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

    Cancel();

    UnloadDataProviders();

    iDataProviderIds.Close();

    iEnumeratingDps.Close();

    iEnumeratingStorages.Close();

    iSingletons.Close();

    CloseRegistrySessionAndEntryL();

    delete iOpenSessionWaiter;

    delete iPendingRequestTimer;

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

    __FLOG_CLOSE;

    }

/**

Loads the set of available data providers and initiates the data provider

enumeration sequence.

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

*/

EXPORT_C void CMTPDataProviderController::LoadDataProvidersL()

    {

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

    // Retrieve the ECOM data provider implementations list

    RImplInfoPtrArray   implementations;

    TCleanupItem        cleanup(ImplementationsCleanup, reinterpret_cast<TAny*>(&implementations));

    CleanupStack::PushL(cleanup);

    REComSession::ListImplementationsL(KMTPDataProviderPluginInterfaceUid, implementations);

    implementations.Sort(TLinearOrder<CImplementationInformation>(ImplementationsLinearOrderUid));

    // Retrieve the data provider registration resource file list.

    CDir* registrations;

    User::LeaveIfError(iSingletons.Fs().GetDir(KMTPDpResourceDirectory, KEntryAttNormal, ESortByName, registrations));

    CleanupStack::PushL(registrations);

    CreateRegistrySessionAndEntryL();

    // Load the registered data providers. 

    const TUint KCount(registrations->Count());

    TInt index = 0; 

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

        {

        TUint uid = 0;

        if(Uid((*registrations)[i].iName, uid) != KErrNone)

        	{

        	__FLOG_1(_L8("LoadDataProvidersL - Fail to get UID = %s"),&((*registrations)[i].iName) );

        	continue;

        	}

        index = implementations.FindInOrder(TUid::Uid(uid), ImplementationsLinearOrderUid);

        if (KErrNotFound == index)

        	{

        	continue;

        	}

		if( uid != KMTPImplementationUidDeviceDp && uid != KMTPImplementationUidProxyDp && uid != KMTPImplementationUidFileDp )

			{

	        //get the dpid for the uid from dpidstore table

	        TBool tFlag;

		    iNextDpId = iSingletons.ObjectMgr().DPIDL(uid, tFlag);

		    if(tFlag == EFalse)

		    	{

		    	iSingletons.ObjectMgr().InsertDPIDObjectL(iNextDpId,uid);

		    	}	       	

			}

		else

			{

			switch (uid)

				{

				case KMTPImplementationUidDeviceDp : 

					iNextDpId = KMTPDeviceDPID;

					break;

				case KMTPImplementationUidFileDp   : 

					iNextDpId = KMTPFileDPID;

					break;

				case KMTPImplementationUidProxyDp  : 

					iNextDpId = KMTPProxyDPID;

					break;				

				}

			}

		LoadROMDataProvidersL((*registrations)[i].iName, implementations);

		delete implementations[index];

		implementations.Remove(index);

        }

    //Load installed DPs on non-ROM drives.

    for (index = 0; index < implementations.Count(); ++index)

        {

        TRAPD(err, LoadInstalledDataProvidersL(implementations[index]));

        if (KErrNone != err)

            {

            __FLOG_VA((_L8("Load installed data provider[0x%x] failed."),implementations[index]->ImplementationUid().iUid));

            }

        }

    CleanupStack::PopAndDestroy(registrations);

    CleanupStack::PopAndDestroy(&implementations);    

    // Verify that the framework data providers are loaded.

    User::LeaveIfError(DpId(KMTPImplementationUidDeviceDp));

    User::LeaveIfError(DpId(KMTPImplementationUidProxyDp));

    User::LeaveIfError(DpId(KMTPImplementationUidFileDp));

	// Sort the data provider set on enumeration phase order.

	iDataProviders.Sort(TLinearOrder<CMTPDataProvider>(CMTPDataProvider::LinearOrderEnumerationPhase));

	// Add the DP IDs into DP ID array, except for device DP, File DP and proxy DP

	for (TUint index=0; index < iDataProviders.Count(); index++)

	  {

	  if ((iDataProviders[index]->DataProviderId() != iDpIdDeviceDp)

	  	  && (iDataProviders[index]->DataProviderId() != iDpIdProxyDp))

	    {

	    }

	  }

    // Ensure that the data provider set is ordered on DataProvider Id.

    iDataProviders.Sort(TLinearOrder<CMTPDataProvider>(CMTPDataProvider::LinearOrderDPId));

    // Start enumerating.

    iEnumeratingStorages.AppendL(KMTPStorageAll);

    iEnumerationState = EEnumerationStarting;

    Schedule();

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

    }

/**

Unloads all active data providers.

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

*/

EXPORT_C void CMTPDataProviderController::UnloadDataProviders()

    {

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

    TRAP_IGNORE(iSingletons.ObjectMgr().ObjectStore().CleanL());

    iDataProviders.ResetAndDestroy();

    iDataProviderIds.Reset();

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

    }

/**

Issues the specified notification to all loaded data providers.

@param aNotification The notification type identifier.

@param aParams The notification type specific parameter block

@leave One of the system wide error code if a processing failure occurs

in the data provider.

*/

EXPORT_C void CMTPDataProviderController::NotifyDataProvidersL(TMTPNotification aNotification, const TAny* aParams)

    {

    NotifyDataProvidersL(KMTPDataProviderAll, aNotification, aParams);

    }

EXPORT_C void CMTPDataProviderController::NotifyDataProvidersL(TUint aDPId, TMTPNotification aNotification, const TAny* aParams)

    {

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

    // Schedule any long running operations.

    switch (aNotification)

        {

    case EMTPStorageAdded:

        {

        // Queue a storage enumeration operation.

        __ASSERT_DEBUG(aParams, User::Invariant());

        const TMTPNotificationParamsStorageChange* params(static_cast<const TMTPNotificationParamsStorageChange*>(aParams));

        iEnumeratingStorages.AppendL(params->iStorageId);

        // Only schedule the operation start if there is not one currently underway.

        if (iEnumerationState == EEnumeratedFulllyCompleted) 

            {

            iNextDpId           = iDpIdDeviceDp;

            iEnumerationState   = EEnumeratingFrameworkObjects;

            Schedule();

            }

        }

        break;

	case EMTPStorageRemoved:

		{

		// Dequeue an unhandled storage enumeration operations if existed.

        // If not existed, just ignore the remove event, since the logical storageId already removed from StorageMgr

        // by the caller, i.e. CMTPStorageWatcher. 

        __ASSERT_DEBUG(aParams, User::Invariant());

        const TMTPNotificationParamsStorageChange* params(static_cast<const TMTPNotificationParamsStorageChange*>(aParams));

        //Start checking from the second event, since iEnumeratingStorages[0] is the event being handled by DPs.

        TUint32 storageId = params->iStorageId;

        for(TInt i=1; i<iEnumeratingStorages.Count(); i++)

            {

            if(storageId==iEnumeratingStorages[i])

                {

                iEnumeratingStorages.Remove(i);

                __FLOG_VA((_L8("Unhandle memory card add event removed, storageId: %d"), storageId));

                }

            }

        }

        break;

    case EMTPObjectAdded:

        break;

    default:

        break;        

        }

    // Issue the notification.    

    const TUint KLoadedDps(iDataProviders.Count());

    if(aDPId == KMTPDataProviderAll)

        {

        for (TUint i(0); i < KLoadedDps; ++i)

            {

            CMTPDataProvider *dp = iDataProviders[i];

            if ((dp->DataProviderId() != iDpIdDeviceDp) &&

                (dp->DataProviderId() != iDpIdProxyDp))

                {

                dp->Plugin().ProcessNotificationL(aNotification, aParams);

                }

            //DeviceDP need handle the SessionClose Notification

            if ((dp->DataProviderId() == iDpIdDeviceDp) &&

                ( EMTPSessionClosed == aNotification))

                {

                dp->Plugin().ProcessNotificationL(aNotification, aParams);

                }            

            }

        }

    else

        {

        for (TUint i(0); i < KLoadedDps; ++i)

            {

            CMTPDataProvider *dp = iDataProviders[i];

            if ( dp->DataProviderId() == aDPId )

                {

                dp->Plugin().ProcessNotificationL(aNotification, aParams);

                break;

                }

            }

        }    

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

    }

/**

Provides the number of active data providers.

@return the number of active data providers.

*/

EXPORT_C TUint CMTPDataProviderController::Count()

    {

    return iDataProviders.Count();

    }

/**

Provides a reference to the data provider with the specified identifier.

@param aId The data provider identifier.

@return The data provider reference.

*/

EXPORT_C CMTPDataProvider& CMTPDataProviderController::DataProviderL(TUint aId)

    {

    return DataProviderByIndexL(iDataProviders.FindInOrder(aId, CMTPDataProvider::LinearOrderDPId));

    }  

/**

Provides a reference to the data provider with the specified index.

@param aIndex The data provider index.

@return The data provider reference.

*/

EXPORT_C CMTPDataProvider& CMTPDataProviderController::DataProviderByIndexL(TUint aIndex)

    {

    __ASSERT_DEBUG((aIndex < iDataProviders.Count()), User::Invariant());

    return *(iDataProviders[aIndex]);

    }  

/**

 * Determine whether a data provider with the specified data provider id has been loaded

 * @param aId the id of the data provider to be checked

 * @return true if the data provider has been loaded, otherwise false

 */

EXPORT_C TBool CMTPDataProviderController::IsDataProviderLoaded(TUint aId) const

	{

	TInt index = iDataProviders.FindInOrder(aId, CMTPDataProvider::LinearOrderDPId);

	if (index >= 0 && index < iDataProviders.Count())

		{

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

/**

Provides the identifier of the device data provider.

@return TInt The device data provider identifier.

*/

EXPORT_C TInt CMTPDataProviderController::DeviceDpId()

    {

    return iDpIdDeviceDp;

    }

/**

Provides the identifier of the data provider with the specified implementation 

UID.

@param aUid The implementation UID.

@return TInt The proxy data provider identifier.

*/  

EXPORT_C TInt CMTPDataProviderController::DpId(TUint aUid)

    {

    TInt dpId = KErrNotFound;

    for (TUint index=0; index < iDataProviders.Count(); index++)

      {

      if (iDataProviders[index]->ImplementationUid().iUid == aUid)

        {

        dpId = iDataProviders[index]->DataProviderId();

        break;

        }

      }

    return dpId;

    }

/**

Provides the identifier of the proxy data provider.

@return TInt The proxy data provider identifier.

*/  

EXPORT_C TInt CMTPDataProviderController::ProxyDpId()

    {

    return iDpIdProxyDp;

    }

EXPORT_C TInt CMTPDataProviderController::FileDpId()

    {

    return iDpIdFileDp;

    }

/**

Wait for the enumeration complete.

*/ 

EXPORT_C void CMTPDataProviderController::WaitForEnumerationComplete()

{

	if((EnumerateState() < CMTPDataProviderController::EEnumeratingPhaseOneDone) && ( !iOpenSessionWaiter->IsStarted()))

		{

		iOpenSessionWaiter->Start();

		}

}

TBool CMTPDataProviderController::FreeEnumerationWaiter()

	{

	if(iOpenSessionWaiter->IsStarted())

		{

		iOpenSessionWaiter->AsyncStop();

		return ETrue;

		}

	return EFalse;

	}

/**

Data provider enumeration state change notification callback.

@param aDp The notifying data provider.

*/    

void CMTPDataProviderController::EnumerationStateChangedL(const CMTPDataProvider& aDp)

    {

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

    __FLOG_VA((_L8("Entry iEnumerationState: 0x%x DpId: %d"), iEnumerationState, aDp.DataProviderId()));

    switch (iEnumerationState)

        {        

    case EEnumeratingFrameworkStorages:

    	switch (aDp.ImplementationUid().iUid)

            {

        case KMTPImplementationUidDeviceDp:

            iNextDpId = iDpIdProxyDp;

            break;

        case KMTPImplementationUidProxyDp:

            iNextDpId = iDpIdFileDp;

            break;

        case KMTPImplementationUidFileDp:

            iEnumerationState   = EEnumeratingDataProviderStorages;

            iDpIdArrayIndex     = 0;

            break;

            }

        Schedule();

        break;    

    case EEnumeratingDataProviderStorages:

        // Data provider storage enumerations execute sequentially.

        if (++iDpIdArrayIndex >= iDataProviderIds.Count())

            {

            iNextDpId           = iDpIdDeviceDp;

            iEnumerationState   = EEnumeratingFrameworkObjects;

            }

        Schedule();

        break;

    case EEnumeratingFrameworkObjects:

        switch (aDp.ImplementationUid().iUid)

            {

        case KMTPImplementationUidDeviceDp:

            iSingletons.ObjectMgr().RemoveNonPersistentObjectsL(aDp.DataProviderId());

            iNextDpId = iDpIdProxyDp;

            Schedule();

            break;

        case KMTPImplementationUidProxyDp:

            iEnumerationState   = EEnumeratingDataProviderObjects;

            iEnumerationPhase   = DataProviderL(iDataProviderIds[0]).DataProviderConfig().UintValue(MMTPDataProviderConfig::EEnumerationPhase);

            iDpIdArrayIndex     = 0;                

            Schedule();

            break;

            }

        break;

    case EEnumeratingDataProviderObjects:

    case EEnumeratingSubDirFiles:

        if(KMTPImplementationUidFileDp == aDp.ImplementationUid().iUid && NeedEnumeratingPhase2())

            {

            __FLOG(_L8("File DP first level enum complete"));

            Cancel();

            //clean the root level snapshot

            iSingletons.ObjectMgr().ObjectStore().CleanDBSnapshotL(ETrue);

            //Schedule again to scan subdir

            iEnumerationState   = EEnumeratingSubDirFiles;

            }

        else

            {

            iEnumeratingDps.Remove(iEnumeratingDps.FindInOrderL(aDp.DataProviderId()));

            // Remove any non-persistent objects that are still marked.

            iSingletons.ObjectMgr().RemoveNonPersistentObjectsL(aDp.DataProviderId());

            if ((iEnumeratingDps.Count() == 0) && iDpIdArrayIndex >= iDataProviderIds.Count())

                {

                Cancel();

                iEnumerationState   = EEnumeratingCleanDBSnapshot;

                iSingletons.ObjectMgr().ObjectStore().CleanDBSnapshotL(EFalse);

                }

            else

                {

                if ((iEnumeratingDps.Count() == 0) && (iEnumerationPhase != DataProviderL(iDataProviderIds[iDpIdArrayIndex]).DataProviderConfig().UintValue(MMTPDataProviderConfig::EEnumerationPhase)))

                    {

                    // Enter next enumeration phase

                    iEnumerationPhase = DataProviderL(iDataProviderIds[iDpIdArrayIndex]).DataProviderConfig().UintValue(MMTPDataProviderConfig::EEnumerationPhase);

                    } 

                Schedule();

                }

            }

        break;

    case EEnumeratedFulllyCompleted:

    case EUnenumerated:

    case EEnumerationStarting:

    case EEnumeratingPhaseOneDone: