/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 FILES

#include "videosettingsdrivemonitor.h"

#include "mvideosettingsdrivemonitorobserver.h"

#include "tvideosettingsdrivemonitorevent.h"

#include "tvideosettingsdriveinfo.h"

#include <bldvariant.hrh>

#ifdef RD_MULTIPLE_DRIVE_ENABLERS

#include <driveinfo.h>

#endif

#include <centralrepository.h>

#include "videoplayercenrepkeys.h"

#include "mpxlog.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

#if IPTV_LOGGING_METHOD != 0

_LIT( KIptvMediaNotPresentDes, "EMediaNotPresent");

_LIT( KIptvMediaUnknownDes, "EMediaUnknown");

_LIT( KIptvMediaFloppyDes, "EMediaFloppy");

_LIT( KIptvMediaHardDiskDes, "EMediaHardDisk");

_LIT( KIptvMediaCdRomDes, "EMediaCdRom");

_LIT( KIptvMediaRamDes, "EMediaRam");

_LIT( KIptvMediaFlashDes, "EMediaFlash");

_LIT( KIptvMediaRomDes, "EMediaRom");

_LIT( KIptvMediaRemoteDes, "EMediaRemote");

_LIT( KIptvMediaNANDFlashDes, "EMediaNANDFlash");

#endif

_LIT( KIptvEmptyDes, "" );

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CVideoSettingsDriveMonitor::CVideoSettingsDriveMonitor

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CVideoSettingsDriveMonitor::CVideoSettingsDriveMonitor()

: CActive( EPriorityStandard )

    {

    MPX_FUNC("CIptvDriveMonitor::CIptvDriveMonitor()");

    }

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

// CIptvEvents::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVideoSettingsDriveMonitor::ConstructL( const RFs& aFileSession )

    {

    iFs                  = aFileSession;

    iIfsIsProvidedByUser = ETrue;

    ConstructL();    

    }

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

// CIptvEvents::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVideoSettingsDriveMonitor::ConstructL()

    {

    iObservers.Reset();

    iAvailableDrives.Reset();

    iPreviousAvailableDrives.Reset();

    if ( !iIfsIsProvidedByUser )

        {

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

        }

    CActiveScheduler::Add( this );

    RefreshAvailableDrivesL();

    MPX_DEBUG2("CIptvDriveMonitor:: PhoneMemoryDrive() returns %d",

        PhoneMemoryDrive());

    MPX_DEBUG2("CIptvDriveMonitor:: MemoryCardDrive() returns %d",

        MemoryCardDrive());

    MPX_DEBUG2("CIptvDriveMonitor:: MassStorageDrive() returns %d",

        MassStorageDrive());

    MPX_DEBUG2("CIptvDriveMonitor:: FixedDrive(c-drive excluded) returns %d",

        FixedDrive( ETrue ));

    }

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

// CVideoSettingsDriveMonitor::NewL

// Two-phased constructor.

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

//

EXPORT_C CVideoSettingsDriveMonitor* CVideoSettingsDriveMonitor::NewL()

    {

    MPX_FUNC("CIptvDriveMonitor::NewL() start");

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CVideoSettingsDriveMonitor::NewL

// Two-phased constructor.

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

//

EXPORT_C CVideoSettingsDriveMonitor* CVideoSettingsDriveMonitor::NewL( const RFs& aFileSession )

    {

    MPX_FUNC("CIptvDriveMonitor::NewL(RFs&) start");

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

    CleanupStack::PushL( self );

    self->ConstructL( aFileSession );

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

EXPORT_C CVideoSettingsDriveMonitor::~CVideoSettingsDriveMonitor()

    {

    iObservers.Close();

    iAvailableDrives.Close();

    iPreviousAvailableDrives.Close();

    Cancel();

    if ( !iIfsIsProvidedByUser )

        {

        iFs.Close();

        }

    }

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

// CVideoSettingsDriveMonitor::RegisterObserverL

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

//

EXPORT_C void CVideoSettingsDriveMonitor::RegisterObserverL( MIptvDriveMonitorObserver* aObserver )

    {

    iObservers.AppendL( aObserver );

    if ( !IsActive() )

        {

        iFs.NotifyChange( ENotifyDisk, iStatus );

        SetActive();

        }

    }

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

// CVideoSettingsDriveMonitor::RemoveObserverL

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

//

EXPORT_C void CVideoSettingsDriveMonitor::RemoveObserverL( MIptvDriveMonitorObserver* aObserver )

    {

    TInt i;

    for ( i = 0; i < iObservers.Count(); i++ )

        {

        if ( aObserver == iObservers[i] )

            {

            iObservers.Remove( i );

            iObservers.Compress();

            break;

            }

        }

    if ( iObservers.Count() == 0 )

        {

        iFs.NotifyChangeCancel();

        }    

    }

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

// CVideoSettingsDriveMonitor::RefreshAvailableDrivesL

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

//

EXPORT_C void CVideoSettingsDriveMonitor::RefreshAvailableDrivesL()

    {

    MPX_FUNC("CIptvDriveMonitor::RefreshAvailableDrivesL() start");

    TDriveList driveList;

    User::LeaveIfError( iFs.DriveList( driveList ) );

    iPreviousAvailableDrives.Reset();

    TInt i;

    for ( i = 0; i < iAvailableDrives.Count(); i++ )

        {

        iPreviousAvailableDrives.Append( iAvailableDrives[i] );

        }

    iAvailableDrives.Reset();

    for ( i = 0; i < driveList.Length(); i++ )

        {

        if ( driveList[i] != 0 && i != EDriveY ) // Some phones have a 1MB small flash drive at y-drive, rule it out

            {

            TDriveInfo driveInfo;

            User::LeaveIfError( iFs.Drive( driveInfo, i ) );

            /*

            From e32cost.h:

            const TUint KMediaAttVariableSize   = 0x01;

            const TUint KMediaAttDualDensity    = 0x02;

            const TUint KMediaAttFormattable    = 0x04;

            const TUint KMediaAttWriteProtected = 0x08;

            const TUint KMediaAttLockable       = 0x10;

            const TUint KMediaAttLocked         = 0x20;

            const TUint KMediaAttHasPassword    = 0x40;

            const TUint KMediaAttReadWhileWrite = 0x80;

            const TUint KMediaAttDeleteNotify   = 0x100;

            The drive attributes.    

            const TUint KDriveAttLocal          = 0x01;

            const TUint KDriveAttRom            = 0x02;

            const TUint KDriveAttRedirected     = 0x04;

            const TUint KDriveAttSubsted        = 0x08;

            const TUint KDriveAttInternal       = 0x10;

            const TUint KDriveAttRemovable      = 0x20;

            const TUint KDriveAttRemote         = 0x40;

            const TUint KDriveAttTransaction    = 0x80;

            */

            MPX_DEBUG3("CIptvDriveMonitor:: drive[%d]: type = %S",

                                     i,

                                     &DriveTypeDes( driveInfo.iType ));

            MPX_DEBUG3(

                "CIptvDriveMonitor::           MediaAtt flags = %x DriveAtt flags = %x",

                    driveInfo.iMediaAtt,

                    driveInfo.iDriveAtt );

#ifdef __WINSCW__

            // (2) c-drive is EMediaRam

            // (3) d-drive is EMediaHardDisk

            // (4) e-drive is EMediaHardDisk or EMediaNotPresent

            // (25) z-drive is EMediaRom

            if ( (driveInfo.iType == EMediaRam) ||                                     // c

                 ((driveInfo.iType == EMediaHardDisk) && i != EDriveD /* skip d */) || // e

                 (driveInfo.iType == EMediaNANDFlash) ||                               // nothing

                 (driveInfo.iType == EMediaNotPresent) )                               // e

#else

            // (2) c-drive is EMediaNANDFlash

            // (3) d-drive is EMediaRam

            // (4) e-drive is EMediaHardDisk or EMediaNotPresent

            // (5) f-drive is EMediaHardDisk or EMediaNotPresent

            // (25) z-drive is EMediaRom

            if ( (driveInfo.iType == EMediaHardDisk) ||  // e,f

                 (driveInfo.iType == EMediaNANDFlash) || // c

                 (driveInfo.iType == EMediaNotPresent) ) // e,f

#endif // __WINSCW__

                {                

                if ( !(driveInfo.iMediaAtt & KMediaAttWriteProtected) &&

                      (driveInfo.iDriveAtt & KDriveAttLocal) )

                    {

                    TIptvDriveInfo iptvDriveInfo;

                    TVolumeInfo volumeInfo;

                    TChar ch;

                    iFs.DriveToChar( i, ch );

                    iptvDriveInfo.iDrive     = i;

                    iptvDriveInfo.iDriveChar = ch;

                    iptvDriveInfo.iType      = driveInfo.iType;

#ifdef RD_MULTIPLE_DRIVE_ENABLERS

                    TUint driveStatus;

                    TInt err = DriveInfo::GetDriveStatus( iFs, i, driveStatus );

                    if ( err == KErrNone )

                        {

                        if ( driveStatus & DriveInfo::EDriveRemovable )

                            {

                            iptvDriveInfo.iFlags |= TIptvDriveInfo::ERemovable;

                            }

                        }

                    TInt massStorageDrive;

                    err = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage,

                                                      massStorageDrive );

                    if ( err == KErrNone )

                        {

                        if ( i == massStorageDrive )

                            {

                            iptvDriveInfo.iFlags |= TIptvDriveInfo::EMassStorage;

                            }                        

                        }

#else

                    if ( driveInfo.iDriveAtt & KDriveAttRemovable )

                        {

                        if ( driveInfo.iMediaAtt & KMediaAttLockable )

                            {

                            //memory card has KDriveAttRemovable and KMediaAttLockable flags set

                            iptvDriveInfo.iFlags |= TIptvDriveInfo::ERemovable;

                            }

                        else

                            {

                            //mass storage has KDriveAttRemovable set and KMediaAttLockable not set

                            iptvDriveInfo.iFlags |= TIptvDriveInfo::EMassStorage;

                            }

                        }

#endif // RD_MULTIPLE_DRIVE_ENABLERS

                    if ( driveInfo.iMediaAtt & KMediaAttLocked )

                        {

                        iptvDriveInfo.iFlags |= TIptvDriveInfo::ELocked;

                        }

                    if ( driveInfo.iType == EMediaNotPresent )

                        {

                        iptvDriveInfo.iFlags |= TIptvDriveInfo::EMediaNotPresent;

                        }

                    // When mass storage mode is activated while application is running,

                    // the only hint about that is the TVolumeInfo not being available. 

                    // Therefore we mark drive as EMediaNotPresent if that structure

                    // is not available.

                    if ( iFs.Volume( volumeInfo, i ) != KErrNone )

                        {

                        iptvDriveInfo.iFlags |= TIptvDriveInfo::EMediaNotPresent;

                        iptvDriveInfo.iVolumeName.Zero();

                        }

                    else

                        {

                        iptvDriveInfo.iVolumeName = volumeInfo.iName;

                        }

                    if ( iptvDriveInfo.iFlags & TIptvDriveInfo::EMediaNotPresent )

                        {

                        iptvDriveInfo.iFlags |= TIptvDriveInfo::ERemovable;

                        }

                    iAvailableDrives.AppendL( iptvDriveInfo );

                    }

                }

            }

        } // for

    // if e and f-drives are available, then c-drive is removed from the available drives list

    if ( ArrayPos( EDriveE ) != KErrNotFound &&

         ArrayPos( EDriveF ) != KErrNotFound )

        {

        TInt cDrivePos = ArrayPos( EDriveC );

        if ( cDrivePos != KErrNotFound )

            {

            MPX_DEBUG1(

                "CIptvDriveMonitor:: e & f-drives available -> removing c from available drives");

            iAvailableDrives.Remove( cDrivePos );

            iAvailableDrives.Compress();

            }

        }

    }

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

// CVideoSettingsDriveMonitor::ArrayPos

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

//

EXPORT_C TInt CVideoSettingsDriveMonitor::ArrayPos( TInt aDrive )

    {

    TInt i;

    for (i = 0; i < iAvailableDrives.Count(); i++ )

        {

        if ( iAvailableDrives[i].iDrive == aDrive )

            {

            return i;

            }

        }

    return KErrNotFound;

    }

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

// CVideoSettingsDriveMonitor::ArrayPosL

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

//

EXPORT_C TInt CVideoSettingsDriveMonitor::ArrayPosL( TInt aDrive )

    {

    TInt pos;

    User::LeaveIfError( pos = ArrayPos( aDrive ) );

    return pos;

    }

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

// CVideoSettingsDriveMonitor::FindMemoryCardDriveL

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

//

EXPORT_C TInt CVideoSettingsDriveMonitor::MemoryCardDriveL()

    {

    TInt drive;

    User::LeaveIfError( drive = MemoryCardDrive() );

    return drive;

    }

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

// CVideoSettingsDriveMonitor::MemoryCardDrive

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

//

EXPORT_C TInt CVideoSettingsDriveMonitor::MemoryCardDrive()

    {

    TInt i;

    for ( i = 0; i < iAvailableDrives.Count(); i++ )

        {

        if ( iAvailableDrives[i].iFlags & TIptvDriveInfo::ERemovable )

            {

            return iAvailableDrives[i].iDrive;

            }

        }

    return KErrNotFound;

    }

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

// CVideoSettingsDriveMonitor::MassStorageDriveL

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

//

EXPORT_C TInt CVideoSettingsDriveMonitor::MassStorageDriveL()

    {

    TInt drive;

    User::LeaveIfError( drive = MassStorageDrive() );

    return drive;

    }

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

// CVideoSettingsDriveMonitor::MassStorageDrive

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

//

EXPORT_C TInt CVideoSettingsDriveMonitor::MassStorageDrive()

    {

    TInt i;

    for ( i = 0; i < iAvailableDrives.Count(); i++ )

        {

        if ( iAvailableDrives[i].iFlags & TIptvDriveInfo::EMassStorage )

            {

            return iAvailableDrives[i].iDrive;

            }

        }

    return KErrNotFound;

    }

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

// CVideoSettingsDriveMonitor::PhoneMemoryDriveL

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

//

EXPORT_C TInt CVideoSettingsDriveMonitor::PhoneMemoryDriveL()

    {

    TInt drive;

    User::LeaveIfError( drive = PhoneMemoryDrive() );

    return drive;

    }

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

// CVideoSettingsDriveMonitor::PhoneMemoryDrive

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

//

EXPORT_C TInt CVideoSettingsDriveMonitor::PhoneMemoryDrive()

    {

    TInt i;

    for ( i = 0; i < iAvailableDrives.Count(); i++ )

        {

        if ( iAvailableDrives[i].iDrive == EDriveC )

            {

            return iAvailableDrives[i].iDrive;

            }

        }

    return KErrNotFound;

    }

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

// CVideoSettingsDriveMonitor::FixedDriveL

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

//

EXPORT_C TInt CVideoSettingsDriveMonitor::FixedDriveL( TBool aExcludeCDrive )

    {

    TInt drive;

    User::LeaveIfError( drive = FixedDrive( aExcludeCDrive ) );

    return drive;

    }

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

// CVideoSettingsDriveMonitor::FixedDrive

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

//

EXPORT_C TInt CVideoSettingsDriveMonitor::FixedDrive( TBool aExcludeCDrive )