/*

* Copyright (c) 2006 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:  Handles all file related activities

*  Version     : %version: da1mmcf#72.1.14.2.4.1.4.1.2 % << Don't touch! Updated by Synergy at check-out.

*

*/

#include <e32base.h>

#include <f32file.h>

#include <centralrepository.h>

#ifdef RD_MULTIPLE_DRIVE

#include <pathinfo.h>

#include <driveinfo.h>

#endif //RD_MULTIPLE_DRIVE

#include <mpxlog.h>

#include <mpxharvestercommon.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxcollectiontype.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionpath.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxdrmmediautility.h>

#include <mpxmediadrmdefs.h>

#include <mpxcollectionplugin.hrh>

#include <mpxcollectionmediator.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <DRMNotifier.h>

#include <DRMEventAddRemove.h>

#include <Oma2Agent.h>

#include <caf/caferr.h>

#include <caf/content.h>

#include <caf/data.h>

#include <UsbWatcherInternalPSKeys.h>

#include <usbpersonalityids.h>

#include "mpxharvesterfilehandlerimp.h"

#include "mpxfolderscanner.h"

#include "mpxdbsynchronizer.h"

#include "mpxfoldermonitor.h"

#include "mpxmetadatascanner.h"

#include "mpxplaylistscanner.h"

#include "mpxharvesterdbmanager.h"

#include "mpxharvesterdbtable.h"

#include "mpxharvesterdbitem.h"

#include "mpxfhcommon.h"

#include "mpxbrokenlinkcleanup.h"

// ============ CONSTANTS ==========

_LIT( KDefaultScanPath, "C:\\DATA\\|E:\\" );

_LIT( KDefaultBlockPath, "\\SYS\\|\\PRIVATE\\|\\SYSTEM\\|\\CITIES\\");

_LIT( KDefaultContainers, ".odf|.dcf|.asf|.m4a|.mp4" );

_LIT( KDefaultAutoScanFolder, "C:\\data\\sounds\\digital\\|E:\\sounds\\digital\\");

const TUid KCRUIDHarvesterFeatures  = { 0x101FFCD2 };

const TUid KMusicPlayerUid = {0x102072C3};

const TInt KHarvesterScanPathKey = 1;

const TInt KHarvesterBlockPathKey = 2;

const TInt KHarvesterContainerKey = 3;

const TInt KAutoScanDirectoryKey = 4;

const TInt KDisablePodcasting = 5;

const TInt KAutoScanDelay = 10000000;  // 10 second delay for rights to arrive

const TInt KAutoScanAfter = 10000000;

// ==========LOCAL FUNCTIONS ========

static void CleanupArray( TAny* item )

    {

    ((RPointerArray<CMPXHarvesterDbItem>*) item )->ResetAndDestroy();

    }

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// C++ Constructor

// ---------------------------------------------------------------------------

//

CMPXHarvesterFileHandlerImp::CMPXHarvesterFileHandlerImp( RFs& aFs ) :

        iFs( aFs ),

        iSynchronizing(EFalse),

        iDisablePodcasting(EFalse)

    {

    }

// ---------------------------------------------------------------------------

// 2nd Phase Constructor

// ---------------------------------------------------------------------------

//

void CMPXHarvesterFileHandlerImp::ConstructL()

    {

    // Folder monitoring related,

    //

    User::LeaveIfError( iAppArc.Connect() );

    iFolderScanner = CMPXFolderScanner::NewL( *this, *this, iFs );

    iMetadataScanner = CMPXMetadataScanner::NewL( iFs,

                                                  iAppArc,

                                                  iSupportedTypes,

                                                  *this, *this );

    iPlaylistScanner = CMPXPlaylistScanner::NewL( *this,

                                                  *this,

                                                  iSupportedTypes );

    iBrokenLink = CMPXBrokenLinkCleanup::NewL( *this, *this );

    // Database related

    //

    iDBManager = CMPXHarvesterDatabaseManager::NewL( iFs );

    // List of watchers for different drives

    //

#ifdef RD_MULTIPLE_DRIVE

    TDriveList driveList;

    TInt driveCount(0);

    User::LeaveIfError( DriveInfo::GetUserVisibleDrives(

           iFs, driveList, driveCount ) );

    for( TInt driveNum = EDriveA; driveNum <= EDriveZ; driveNum++ )

        {

        if ( driveList[driveNum] && (!iDBManager->IsRemoteDrive(static_cast<TDriveNumber>(driveNum))))

            {

            CMPXDiskSpaceWatcher* dw = CMPXDiskSpaceWatcher::NewL(

                    iFs, static_cast<TDriveNumber>(driveNum), *this );

            CleanupStack::PushL( dw );

            iDiskMonitors.AppendL( dw );

            CleanupStack::Pop( dw );

            }

        }

#else

    CMPXDiskSpaceWatcher* dw_e = CMPXDiskSpaceWatcher::NewL( iFs, EDriveE, *this );

    CleanupStack::PushL( dw_e );

    iDiskMonitors.AppendL( dw_e );

    CleanupStack::Pop( dw_e );

    CMPXDiskSpaceWatcher* dw_c = CMPXDiskSpaceWatcher::NewL( iFs, EDriveC, *this );

    CleanupStack::PushL( dw_c );

    iDiskMonitors.AppendL( dw_c );

    CleanupStack::Pop( dw_c );

#endif // RD_MULTIPLE_DRIVE

    TInt openerr = iDBManager->OpenAllDatabasesL();

    // Temporary collection utility

    //

    MMPXCollectionUtility* colUtil =

                           MMPXCollectionUtility::NewL( NULL, KMcModeDefault );

    CleanupStack::PushL( colUtil );

    // Get the collection UIDs

    RArray<TUid> ary;

    CleanupClosePushL( ary );

    ary.AppendL( TUid::Uid(EMPXCollectionPluginMusic) );

    iMusicCollectionId = colUtil->CollectionIDL( ary.Array() );

    ary.Reset();

    ary.AppendL( TUid::Uid(EMPXCollectionPluginPodCast) );

    iPodcastCollectionId = colUtil->CollectionIDL( ary.Array() );

    CleanupStack::PopAndDestroy( &ary );

    // If harvester db was corrupted, mark podcast and music db as corrupt

    if( openerr == KErrCorrupt )

        {

        colUtil->Collection().CommandL(EMcCmdDbCorrupted, iMusicCollectionId.iUid );

        colUtil->Collection().CommandL(EMcCmdDbCorrupted, iPodcastCollectionId.iUid );

        }

    // Get the list of supported types from the collection

    //

    colUtil->Collection().GetSupportedTypesL( iSupportedTypes );

    CleanupStack::Pop( colUtil );

    colUtil->Close();

    // Get the scan drives from cenrep.

    //

    ParseScanPathL();

    // Get the list of container types

    iContainerTypes = new(ELeave) CDesCArrayFlat(2);  // granularity

    ParseContainersL();

    // Get the list of automatic scanned folders

    ParseAutoScanL();

    iIdle = CPeriodic::NewL( CActive::EPriorityLow );

    // Get the podcasting enabled / disabled flag

    //

    CRepository* cenrep(NULL);

    TRAPD( err, cenrep = CRepository::NewL( KCRUIDHarvesterFeatures ) );

    if( err == KErrNone )

        {

        cenrep->Get( KDisablePodcasting, iDisablePodcasting );

        delete cenrep;

        }

    else

        {

        iDisablePodcasting = EFalse;

        }

    // Create the database synchronizer

    iDbSynchronizer = CMPXDbSynchronizer::NewL(*this,*iDBManager,iMusicCollectionId,

                                               iPodcastCollectionId,iFs, iDisablePodcasting);

#ifdef RD_MULTIPLE_DRIVE

    // Use default MMC drive as the Removable drive

    User::LeaveIfError( DriveInfo::GetDefaultDrive(

        DriveInfo::EDefaultRemovableMassStorage,

        iRemovedDrive ) );

#endif

    // Create DRM Notifier and register for AddRemove event

    iDrmNotifier = CDRMNotifier::NewL();

    iDrmNotifier->RegisterEventObserverL( *this, KEventAddRemove );

    }

// ---------------------------------------------------------------------------

// Two-Phased Constructor

// ---------------------------------------------------------------------------

//

CMPXHarvesterFileHandlerImp* CMPXHarvesterFileHandlerImp::NewL( RFs& aFs )

    {

    CMPXHarvesterFileHandlerImp* self =

                                  new( ELeave ) CMPXHarvesterFileHandlerImp(aFs);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CMPXHarvesterFileHandlerImp::~CMPXHarvesterFileHandlerImp()

    {

    MPX_DEBUG1("~CMPXHarvesterFileHandlerImp <---");

    delete iDbSynchronizer;

    delete iFolderScanner;

    delete iMetadataScanner;

    delete iPlaylistScanner;

    delete iBrokenLink;

    iDiskMonitors.ResetAndDestroy();

    iDiskMonitors.Close();

    iFolderMonitors.ResetAndDestroy();

    iFolderMonitors.Close();

    iSupportedTypes.ResetAndDestroy();

    iSupportedTypes.Close();

    if( iContainerTypes )

        {

        iContainerTypes->Reset();

        }

    delete iContainerTypes;

    iFilteredDrivesToScan.Reset();

    iFilteredDrivesToScan.Close();

    iDrivesToScan.Reset();

    iDrivesToScan.Close();

    iPathsToBlock.Reset();

    iPathsToBlock.Close();

    // Cleans up the scanning tables and arrays

    Reset();

    delete iDBManager;

    if( iCollectionUtil )

        {

        iCollectionUtil->Close();

        }

    iAppArc.Close();

    iAutoScanPaths.Reset();

    iAutoScanPaths.Close();

    delete iIdle;

    if(iDrmNotifier)

        {

        TRAP_IGNORE( iDrmNotifier->UnRegisterEventObserverL( *this, KEventAddRemove ) );

        delete iDrmNotifier;

        }

    MPX_DEBUG1("~CMPXHarvesterFileHandlerImp --->");

    }

// ---------------------------------------------------------------------------

// Scans all drives in the list of interested drives

// ---------------------------------------------------------------------------

//

void CMPXHarvesterFileHandlerImp::ScanL()

    {

    MPX_DEBUG1("CMPXHarvesterFileHandlerImp::ScanL <---");

    // Reset all previous states

    CancelScan();

    Reset();

    // Construct the collection utility

    if( iCollectionUtil )

        {

        iCollectionUtil->Close();

        iCollectionUtil = NULL;

        }

    iCollectionUtil = MMPXCollectionUtility::NewL( NULL, KMusicPlayerUid );

    // cenrep key need to be checked whether USB cable is connected in MTP/Combined Mode

    // to prevent refresh

    TInt usbStatus;

    RProperty::Get(KPSUidUsbWatcher, KUsbWatcherSelectedPersonality, usbStatus);

    if ((usbStatus == KUsbPersonalityIdMTP) || (usbStatus == KUsbPersonalityIdPCSuiteMTP))

        {

        MPX_DEBUG1("USB is active, Leave with KErrLocked");

        // need to call back even if it leaves here

        iCollectionUtil->Collection().NotifyL( EMcMsgRefreshEnd, KErrLocked );

        //User::Leave(KErrLocked);

        return;

        }

    iCollectionUtil->Collection().NotifyL( EMcMsgRefreshStart, KErrNone );

    // Reopen databases

    iDBManager->OpenAllDatabasesL();

    // Begin transaction on databases

    iDBManager->BeginL();

    //Remove out of disk space drives from scanned drives list

    iFilteredDrivesToScan.Reset();

    CopyArrayL(iDrivesToScan.Array(),iFilteredDrivesToScan);

    iOutOfDisk = EFalse;

    TInt driveCount (iDiskMonitors.Count());

    TBool outOfDisk(EFalse);

    for( TInt driveIndex = 0; driveIndex < driveCount; ++driveIndex )

        {

        //Check if the current drive is low on disk

        outOfDisk = iDiskMonitors[driveIndex]->IsLowOnDisk();

        iDiskMonitors[driveIndex]->StartL();

        if(outOfDisk)

            {

            TInt count( iFilteredDrivesToScan.Count() );

            TInt index(0);

            TInt currentDriveNumber = iDiskMonitors[driveIndex]->CurrentDrive();

            while(index < count)

                {

                // Remove current drive from the scanned drives list

                TParse fileNameParser;

                User::LeaveIfError(fileNameParser.Set(iFilteredDrivesToScan[index],NULL,NULL));

                TFileName driveName(fileNameParser.Drive());

                TInt driveNumber = TDriveUnit( driveName );

                if (currentDriveNumber == driveNumber)

                    {

                    iFilteredDrivesToScan.Remove(index);

                    count--;

                    }

                else

                    {

                    index++;

                    }

                }

            TRAP_IGNORE(iDBManager->RemoveDatabaseL(static_cast<TDriveNumber>(currentDriveNumber)));

            }

        }

    iSynchronizing = CheckDbInSyncL();

    if(!iSynchronizing)

        {

        // Start the scanning process

        iRefreshCount++;

        iFolderScanner->ScanL( iFilteredDrivesToScan );

        iMetadataScanner->Reset();

        iBrokenLink->Reset();

        iPlaylistScanner->Reset();

        iIdle->Cancel();

        // Keep a count of how many we added to synchronize the number

        iAddedCount = 0;

        iRefreshing = ETrue;

        }

    if (iFilteredDrivesToScan.Count() == 0 )

        {

        iOutOfDisk = ETrue;

        MPX_DEBUG1("CMPXHarvesterFileHandlerImp::ScanL -- cancelling scan");

        // Cancel the scan in this case, will goto HandleScanStateCompleteL()

        CancelScan();

        }

    MPX_DEBUG1("CMPXHarvesterFileHandlerImp::ScanL --->");

    }

// ---------------------------------------------------------------------------

// Cancels Scanning

// ---------------------------------------------------------------------------

//

void CMPXHarvesterFileHandlerImp::CancelScan()

    {

    iDbSynchronizer->Cancel();

    iFolderScanner->Cancel();

    iBrokenLink->Cancel();

    iMetadataScanner->Stop();

    iPlaylistScanner->Cancel();

    }

// ---------------------------------------------------------------------------

// Handles a system event

// ---------------------------------------------------------------------------

//

void CMPXHarvesterFileHandlerImp::HandleSystemEventL( TSystemEvent aEvent,

                                                      TInt aData )

    {

    MPX_DEBUG2("CMPXHarvesterFileHandlerImp::HandleSystemEventL %i", aEvent);

    // How to handle each event

    //

    // 1: Format and eject, we stop scanning and close only the mmc db

    // 2: Format end and disk insert we reopen db and scan for new files

    // 3: USB start we stop scan and close all db

    // 4: USB end we re-open all db and scan for new files

    // 5: MTP start we stop monitoring for new files (no dismount)

    // 6: MTP end we re-open all db, files added already, restart monitor

    //

#ifdef RD_MULTIPLE_DRIVE

    // Get all visible drives

    TDriveList driveList;

    TInt driveCount(0);

    TPtrC drivePresent(_L("present"));

    TPtrC driveNotPresent(_L("not present"));

    TPtrC driveInUse(_L("in use"));

    TPtrC driveAvailable(_L("available"));

    TPtrC driveFormatted(_L("formatted"));

    TPtrC driveNotFormatted(_L("not formatted"));

    User::LeaveIfError( DriveInfo::GetUserVisibleDrives(

           iFs, driveList, driveCount ) );

    MPX_DEBUG2 ("CMPXHarvesterFileHandlerImp::HandleSystemEventL - driveCount = %d", driveCount);

    for( TInt driveNum = EDriveA; driveNum <= EDriveZ; driveNum++ )

        {

        if (driveList[driveNum])

            {

            // Get the drive status

            TUint driveStatus(0);

            User::LeaveIfError( DriveInfo::GetDriveStatus(

                iFs, driveNum, driveStatus ) );

            MPX_DEBUG3 ("CMPXHarvesterFileHandlerImp::HandleSystemEventL - drive %d status=0x%x", driveNum, driveStatus);

            TChar driveChar;

            User::LeaveIfError(

                iFs.DriveToChar( driveNum, driveChar ) );

            MPX_DEBUG5 ("CMPXHarvesterFileHandlerImp::HandleSystemEventL - drive %c: is %S, %S and %S",

                driveChar,

                (driveStatus&DriveInfo::EDrivePresent)?&drivePresent:&driveNotPresent,

                (driveStatus&DriveInfo::EDriveInUse)?&driveInUse:&driveAvailable,

                (driveStatus&DriveInfo::EDriveFormatted)?&driveFormatted:&driveNotFormatted);

            }

        }

#endif //RD_MULTIPLE_DRIVE

    switch( aEvent )

        {

        case EFormatStartEvent:

            {

            MPX_DEBUG1("Disk Format start event");

            CancelScan();

            iDBManager->CloseDatabase( (TDriveNumber) aData );

            break;

            }

        case EDiskRemovedEvent:

            {

            MPX_DEBUG1("Disk Removed event");

            iIdle->Cancel();

            CancelScan();

#ifdef RD_MULTIPLE_DRIVE

            for( TInt driveNum = EDriveA; driveNum <= EDriveZ; driveNum++ )

                {

                if (driveList[driveNum] && (!iDBManager->IsRemoteDrive(static_cast<TDriveNumber>(driveNum))))

                    {

                    TUint driveStatus(0);

                    User::LeaveIfError( DriveInfo::GetDriveStatus(

                        iFs, driveNum, driveStatus ) );

                    if (!(driveStatus & DriveInfo::EDrivePresent ))

                        {

                        // Close database for non-present drive

                        iDBManager->CloseDatabase( (TDriveNumber) driveNum );

                        // Save the drive

                        iRemovedDrive = driveNum;

                        break;

                        }

                    }

                }

#else

            iDBManager->CloseDatabase( (TDriveNumber) aData );

#endif // RD_MULTIPLE_DRIVE

            break;

            }

        case EFormatEndEvent:

            {

            MPX_DEBUG1("Disk Format end event");

            CancelScan();

            iDBManager->OpenDatabaseL( (TDriveNumber) aData );

            break;

            }

        case EDiskInsertedEvent:

            {

            MPX_DEBUG1("Disk Insert event");

            CancelScan();

#ifdef RD_MULTIPLE_DRIVE

            iDBManager->OpenDatabaseL( (TDriveNumber) iRemovedDrive );

#else

            iDBManager->OpenDatabaseL( (TDriveNumber) aData );

#endif // RD_MULTIPLE_DRIVE

            break;