// 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/cmtpdataproviderplugin.h>
#include <mtp/mmtpdataproviderframework.h>
#include <mtp/mtpprotocolconstants.h>
#include <mtp/mtpdataproviderapitypes.h>

#include "cmtpdataprovider.h"
#include "cmtpdataprovidercontroller.h"
#include "cmtpframeworkconfig.h"
#include "cmtpstoragemgr.h"
#include "cmtpobjectmgr.h"
#include "cmtpstoragewatcher.h"
#include "rmtpdevicedpsingletons.h"
#include "cmtpdevicedpconfigmgr.h"


// Class constants.
__FLOG_STMT(_LIT8(KComponent,"StorageWatcher");)
static const TBool KAllDrives(ETrue);
static const TBool KAvailableDrives(EFalse);

const TInt KFolderExclusionGranularity = 8;

/**
MTP system storage watcher factory method.
@return A pointer to an MTP system storage watcher object. Ownership IS 
transfered.
@leave One of the system wide error codes, if a processing failure occurs.
*/
CMTPStorageWatcher* CMTPStorageWatcher::NewL(MMTPDataProviderFramework& aFramework)
    {
    CMTPStorageWatcher* self = new (ELeave) CMTPStorageWatcher(aFramework);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

/**
Destructor.
*/    
CMTPStorageWatcher::~CMTPStorageWatcher()
    {
    __FLOG(_L8("~CMTPStorageWatcher - Entry"));
    Cancel();
    delete iFolderExclusionList;
    iDpSingletons.Close();
    iDrivesExcluded.Close();
    iFrameworkSingletons.Close();
    __FLOG(_L8("~CMTPStorageWatcher - Exit"));
    __FLOG_CLOSE;
    }
    
void CMTPStorageWatcher::EnumerateStoragesL()
    {
    __FLOG(_L8("EnumerateStoragesL - Entry"));

    //Use Hash to replace it
    AppendFolderExclusionListL();
    
    // Retrieve the drive exclusion list.
    iFrameworkSingletons.FrameworkConfig().GetValueL(CMTPFrameworkConfig::EExcludedStorageDrives, iDrivesExcluded);
    iDrivesExcluded.Sort();
    
    // Claim system storages ownership.
    CMTPStorageMgr& mgr(iFrameworkSingletons.StorageMgr());
    mgr.SetFrameworkId(iFramework.DataProviderId());
    
    /* 
    Enumerate the initial drive set. 
    
        1.   Enumerate each known drive as a physical storage.
    */
    iDrivesConfig = DriveConfigurationL(KAllDrives);
    CMTPStorageMetaData* storage = CMTPStorageMetaData::NewLC();
    storage->SetUint(CMTPStorageMetaData::EStorageSystemType, CMTPStorageMetaData::ESystemTypeDefaultFileSystem);
    _LIT(KSuidTemplate, "?:");
    RBuf suid;
    suid.CleanupClosePushL();
    suid.Assign((KSuidTemplate().AllocL()));
    
    for (TInt drive(0); (drive < KMaxDrives); drive++)
        {
        const TUint32 mask(1 << drive);
        if (iDrivesConfig & mask)
            {
            TChar driveChar;
            User::LeaveIfError(iFramework.Fs().DriveToChar(drive, driveChar));
            suid[0] = driveChar;
            storage->SetDesCL(CMTPStorageMetaData::EStorageSuid, suid);
                    
            TUint32 id(mgr.AllocatePhysicalStorageIdL(iFramework.DataProviderId(), *storage));
            mgr.SetDriveMappingL(static_cast<TDriveNumber>(drive), id);
            }
        }
        
    CleanupStack::PopAndDestroy(&suid);
    CleanupStack::PopAndDestroy(storage);
    
    /* 
        2.  If so configured, enumerate a single logical storage for each of 
            the available drives.
    */
    if (iAllocateLogicalStorages)
        {
        iDrivesConfig = DriveConfigurationL(KAvailableDrives);

        for (TInt drive(0); (drive < KMaxDrives); drive++)
            {
            const TUint32 mask(1 << drive);
            if (iDrivesConfig & mask)
                {
                StorageAvailableL(static_cast<TDriveNumber>(drive));
                }
            }
        }
    
    // Set the default storage.
    TUint defaultDrive;
    iFrameworkSingletons.FrameworkConfig().GetValueL(CMTPFrameworkConfig::EDefaultStorageDrive, defaultDrive);
    
    if ( defaultDrive <= EDriveZ )
        {
        // Default drive is specified by drive number.. retrieve from manager..
        if (iAllocateLogicalStorages)
            {
            mgr.SetDefaultStorageId(mgr.FrameworkStorageId(static_cast<TDriveNumber>(defaultDrive)));
            }
        else
            {
            mgr.SetDefaultStorageId(mgr.PhysicalStorageId(static_cast<TDriveNumber>(defaultDrive)));
            }
        }
    else
       {
       // Default drive is specified by storage number
       mgr.SetDefaultStorageId(defaultDrive);
       }
       
    __FLOG(_L8("EnumerateStoragesL - Exit"));
    }

/**
Initiates storage change notice subscription.
*/
void CMTPStorageWatcher::Start()
    {
    __FLOG(_L8("Start - Entry"));
    if (!(iState & EStarted))
        {
        __FLOG(_L8("Starting RFs notifier"));
        TRequestStatus* status(&iStatus);
        User::RequestComplete(status, KErrNone);
        SetActive();
        iState |= EStarted;
        }
    __FLOG(_L8("Start - Exit"));    
    }
    
void CMTPStorageWatcher::DoCancel()
    {
    __FLOG(_L8("DoCancel - Entry"));
    __FLOG(_L8("Stopping RFs notifier"));
    iFrameworkSingletons.Fs().NotifyChangeCancel();
    iState &= (!EStarted);
    __FLOG(_L8("DoCancel - Exit"));
    }

/**
Append all DPs folder exclusion list strings in Device DP
 */
void CMTPStorageWatcher::AppendFolderExclusionListL()
    {
    CDesCArraySeg* folderExclusionSets = new (ELeave) CDesCArraySeg(KFolderExclusionGranularity);
    CleanupStack::PushL(folderExclusionSets);
    CMTPDataProviderController& dps(iFrameworkSingletons.DpController());
    TUint currentDpIndex = 0, count = dps.Count();
    while (currentDpIndex < count)
        {
        CMTPDataProvider& dp(dps.DataProviderByIndexL(currentDpIndex));
        if(KMTPImplementationUidDeviceDp != dp.ImplementationUid().iUid)
            {
            folderExclusionSets->Reset();
            dp.Plugin().SupportedL(EFolderExclusionSets,*folderExclusionSets);
            for(TInt i = 0; i < folderExclusionSets->Count(); ++i)
                {
                TPtrC16 excludedFolder = (*folderExclusionSets)[i];
                iFolderExclusionList->AppendL(excludedFolder);
                }
            }
        currentDpIndex++;
        }
    CleanupStack::PopAndDestroy(folderExclusionSets);
    }

/**
Handles leaves occurring in RunL.
@param aError leave error code
@return KErrNone
*/
#ifdef __FLOG_ACTIVE
TInt CMTPStorageWatcher::RunError(TInt aError)
#else
TInt CMTPStorageWatcher::RunError(TInt /*aError*/)
#endif
    {
    __FLOG(_L8("RunError - Entry"));
    __FLOG_VA((_L8("Error = %d"), aError));

    // Ignore the error, meaning that the storages may not be accurately accounted for
    RequestNotification();

    __FLOG(_L8("RunError - Exit"));
    return KErrNone;
    }
    
void CMTPStorageWatcher::RunL()
    {
    __FLOG(_L8("RunL - Entry"));
    const TUint32 previous(iDrivesConfig);
    const TUint32 current(DriveConfigurationL(KAvailableDrives));
    if (current != previous)
        {        
        const TUint32 changed(current ^ previous);
        const TUint32 added(changed & current);
        const TUint32 removed(changed & previous);
        TInt i(KMaxDrives);
        while (i--)
            {
            const TUint32 mask(1 << i);
            if (added & mask)
                {
                StorageAvailableL(static_cast<TDriveNumber>(i));
                }
            else if (removed & mask)
                {
                StorageUnavailableL(static_cast<TDriveNumber>(i));
                }
            }
        }
    iDrivesConfig = current;
    RequestNotification();
    __FLOG(_L8("RunL - Exit"));
    }
    
/**
Constructor.
@param aConnectionMgr The MTP connection manager interface.
*/
CMTPStorageWatcher::CMTPStorageWatcher(MMTPDataProviderFramework& aFramework) :
    CActive(EPriorityStandard),
    iFramework(aFramework)
    {
    CActiveScheduler::Add(this);
    }
    
/**
Second phase constructor.
*/
void CMTPStorageWatcher::ConstructL()
    {
    __FLOG_OPEN(KMTPSubsystem, KComponent);
    __FLOG(_L8("ConstructL - Entry"));
    iFrameworkSingletons.OpenL();
    iFrameworkSingletons.FrameworkConfig().GetValueL(CMTPFrameworkConfig::ELogicalStorageIdsAllocationEnable, iAllocateLogicalStorages);
    
    RMTPDeviceDpSingletons devSingletons;
    devSingletons.OpenL(iFramework);
    CleanupClosePushL(devSingletons);
    
    iDpSingletons.OpenL(iFramework);
    iFolderExclusionList = devSingletons.ConfigMgr().GetArrayValueL(CMTPDeviceDpConfigMgr::EFolderExclusionList); 
    CleanupStack::PopAndDestroy(&devSingletons);
    __FLOG(_L8("ConstructL - Exit"));
    }
    
TUint32 CMTPStorageWatcher::DriveConfigurationL(TBool aAllDrives) const
    {
    __FLOG(_L8("DriveConfigurationL - Entry"));
    TUint32     config(0);
    TDriveList  drives;
    RFs&        fs(iFrameworkSingletons.Fs());
    User::LeaveIfError(fs.DriveList(drives));
    TInt i(KMaxDrives);
    while (i--)
        {        
        __FLOG_VA((_L8("Drive number %d, available = 0x%02d"), i, drives [i]));
        if ((drives[i]) &&
            (!Excluded(static_cast<TDriveNumber>(i))))
            {
            TDriveInfo info;
            User::LeaveIfError(fs.Drive(info, i));
            if ((info.iType != EMediaNotPresent) || (aAllDrives))
                {
                TVolumeInfo volumeInfo;
                if(KErrNone == fs.Volume(volumeInfo,i))
                	{
                	config |=  (1 << i);
                	}
                }
            }
        }
    __FLOG_VA((_L8("Drives list = 0x%08X, AllDrives = %d"), config, aAllDrives));
    __FLOG(_L8("DriveConfigurationL - Exit"));
    return config;
    }

TBool CMTPStorageWatcher::Excluded(TDriveNumber aDriveNumber) const
    {
    __FLOG(_L8("Excluded - Entry"));
    TBool ret(iDrivesExcluded.FindInOrder(aDriveNumber) != KErrNotFound);
    __FLOG_VA((_L8("Drive = %d, excluded = %d"), aDriveNumber, ret));
    __FLOG(_L8("Excluded - Exit"));
    return ret;
    }
    
void CMTPStorageWatcher::RequestNotification()
    {
    __FLOG(_L8("RequestNotification - Entry"));
    _LIT(KPath, "?:\\..");
    iFrameworkSingletons.Fs().NotifyChange(ENotifyEntry, iStatus, KPath);
    SetActive();
    __FLOG(_L8("RequestNotification - Exit"));
    }
 
void CMTPStorageWatcher::SendEventL(TUint16 aEvent, TUint32 aStorageId)
    {
    __FLOG(_L8("SendEventL - Entry"));
    if (iState & EStarted)
        {
        __FLOG_VA((_L8("Sending event 0x%04X for StorageID 0x%08X"), aEvent, aStorageId));
        iEvent.Reset();
        iEvent.SetUint16(TMTPTypeEvent::EEventCode, aEvent);
        iEvent.SetUint32(TMTPTypeEvent::EEventSessionID, KMTPSessionAll);
        iEvent.SetUint32(TMTPTypeEvent::EEventTransactionID, KMTPTransactionIdNone);
        iEvent.SetUint32(TMTPTypeEvent::EEventParameter1, aStorageId);
        iFramework.SendEventL(iEvent);
        }
    __FLOG(_L8("SendEventL - Exit"));
    }

/**
Configures the specified drive as an available MTP storage.
@param aDriveNumber The Symbian OS file system drive number.
@leave One of the system wide error codes, if a processing failure occurs.
*/    
void CMTPStorageWatcher::StorageAvailableL(TDriveNumber aDriveNumber)
    {
    __FLOG(_L8("StorageAvailableL - Entry"));
    __FLOG_VA((_L8("Drive = %d is available."), aDriveNumber));
    CMTPStorageMgr& mgr(iFrameworkSingletons.StorageMgr());
    TInt32 physical(mgr.PhysicalStorageId(aDriveNumber));
    _LIT(KSuidTemplate, "?:");
    // Generate the storage SUID as the drive root folder.
    RBuf suid;
    suid.CleanupClosePushL();
    suid.Assign((KSuidTemplate().AllocL()));
    TChar driveChar;
    User::LeaveIfError(iFramework.Fs().DriveToChar(aDriveNumber, driveChar));
    driveChar.LowerCase();
    suid[0] = driveChar;
    // Create the storage meta-data.
    CMTPStorageMetaData* storage = CMTPStorageMetaData::NewLC();
    storage->SetUint(CMTPStorageMetaData::EStorageSystemType, CMTPStorageMetaData::ESystemTypeDefaultFileSystem);
    storage->SetDesCL(CMTPStorageMetaData::EStorageSuid, suid);
    if(physical == KErrNotFound)
    	{
        TUint32 id(mgr.AllocatePhysicalStorageIdL(iFramework.DataProviderId(), *storage));
        mgr.SetDriveMappingL(aDriveNumber, id);
    	}
    physical = mgr.PhysicalStorageId(aDriveNumber);

    User::LeaveIfError(physical);
    TUint32 logical(physical);

    // If configured to do so, assign a logical storage ID mapping.
    if (iAllocateLogicalStorages)
        {
        __FLOG(_L8("Assigning local storage ID mapping"));
        
        // Try to read from resource file to use a specified root dir path, if available.
        RBuf rootDirPath;
        rootDirPath.CreateL(KMaxFileName);
        rootDirPath.CleanupClosePushL();
        RMTPDeviceDpSingletons devSingletons;
        devSingletons.OpenL(iFramework);
        CleanupClosePushL(devSingletons);
        TRAPD(resError, devSingletons.ConfigMgr().GetRootDirPathL(aDriveNumber, rootDirPath));
        __FLOG_VA((_L8("ResError = %d"), resError));
        if ((KErrNone == resError) && (0 < rootDirPath.Length()))
            {
            __FLOG(_L8("Reading resource file succeeded"));
            // If there is a root directory information in rss file then check the directory exist or not. 
            // If not exists, then create it. 
            // Before doing anything, delete the leading and trailing white space.
            rootDirPath.Trim();       
            TBuf<KMaxFileName> buffer;
            buffer.Append(driveChar);
            _LIT(KSeperator,":");
            buffer.Append(KSeperator);
            buffer.Append(rootDirPath);
            TInt error = iFramework.Fs().MkDir(buffer);
            suid.Close();
            _LIT(KSuidTemplate, "?:\\");
            suid.Assign((KSuidTemplate().AllocL()));
            driveChar.LowerCase();
            suid[0] = driveChar;

            if ((KErrNone == error) || (KErrAlreadyExists == error))
                {
                __FLOG(_L8("Overwriting SUID to specified root dir path from resource file"));  
                //if dir already existed or created, make that as root directory
                suid.ReAllocL(buffer.Length());
                suid = buffer;
                }
            }
        CleanupStack::PopAndDestroy(&devSingletons);
        CleanupStack::PopAndDestroy(&rootDirPath);
        
        // Set up folder exclusion list
        CDesCArraySeg* storageExclusions = new (ELeave) CDesCArraySeg(KFolderExclusionGranularity);
        CleanupStack::PushL(storageExclusions);
        TInt excludedFolderCount = iFolderExclusionList->Count();

        for (TInt i = 0; i < excludedFolderCount; ++i)
            {
            TPtrC16 excludedFolder = (*iFolderExclusionList)[i];

            if (excludedFolder[0] == '?' ||
                excludedFolder[0] == '*' ||
                excludedFolder[0] == suid[0])
                {
                storageExclusions->AppendL(excludedFolder);
                }
            }
        for ( TInt i=0; i<storageExclusions->Count();++i)
            {
            HBufC16* temp = static_cast<TPtrC16>((*storageExclusions)[i]).AllocL();
            TPtr16 tempptr(temp->Des());
            tempptr[0] = suid[0];
            storage->SetHashPath(tempptr,i);
            delete temp;
            }
        
        storage->SetDesCL(CMTPStorageMetaData::EStorageSuid, suid);
        storage->SetDesCArrayL(CMTPStorageMetaData::EExcludedAreas, *storageExclusions);
        CleanupStack::PopAndDestroy(storageExclusions);

        // Create the logical StorageID and drive mapping.
        logical = mgr.AllocateLogicalStorageIdL(iFramework.DataProviderId(), physical, *storage);
        mgr.SetDriveMappingL(aDriveNumber, logical);

        __FLOG_VA((_L8("Drive = %d mapped as storage 0x%08X"), aDriveNumber, logical));
        }

    CleanupStack::PopAndDestroy(storage);
    CleanupStack::PopAndDestroy(&suid);
    
    // Notify the active data providers.
    if (iState & EStarted)
        {
        TMTPNotificationParamsStorageChange params = {physical};
        iFrameworkSingletons.DpController().NotifyDataProvidersL(EMTPStorageAdded, static_cast<TAny*>(&params));
        }

    // Notify any connected Initiator(s).
    if (iAllocateLogicalStorages)
        {
        SendEventL(EMTPEventCodeStoreAdded, logical);
        }
        
    __FLOG(_L8("StorageAvailableL - Exit"));
    }

/**
Configures the specified drive as an unavailable MTP storage.
@param aDriveNumber The Symbian OS file system drive number.
@leave One of the system wide error codes, if a processing failure occurs.
*/    
void CMTPStorageWatcher::StorageUnavailableL(TDriveNumber aDriveNumber)
{
    __FLOG(_L8("StorageUnavailableL - Entry"));
    __FLOG_VA((_L8("Drive = %d is unavailable."), aDriveNumber));
    CMTPStorageMgr& mgr(iFrameworkSingletons.StorageMgr());
    TInt32 physical(mgr.PhysicalStorageId(aDriveNumber));
    User::LeaveIfError(physical);
    TUint32 logical(0);
    
    // If configured to do so, assign a logical storage ID mapping.
    if (iAllocateLogicalStorages)
        {
        logical = mgr.FrameworkStorageId(aDriveNumber);

        // Deassign the logical storage ID mapping.
        mgr.DeallocateLogicalStorageIds(iFramework.DataProviderId(), physical);
        mgr.SetDriveMappingL(aDriveNumber, physical);
        __FLOG_VA((_L8("Drive = %d unmapped as storage 0x%08X"), aDriveNumber, logical));
        }

    // Notify the active data providers.
    TMTPNotificationParamsStorageChange params = {physical};
    iFrameworkSingletons.DpController().NotifyDataProvidersL(EMTPStorageRemoved, static_cast<TAny*>(&params));

    // Notify any connected Initiator(s).
    if (iAllocateLogicalStorages)
        {
        SendEventL(EMTPEventCodeStoreRemoved, logical);
        }   
    __FLOG(_L8("StorageUnavailableL - Exit"));
    }