/*

* Copyright (c) 2006-2008 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:  Main class for UsbMscPersonality

*

*/

#include <centralrepository.h>

#include <AknSkinsInternalCRKeys.h>

#include <usbman.h>

#include <e32property.h>

#include <tusbpersonalityparams.h>

#include <startupdomainpskeys.h>

#include <SettingsInternalCRKeys.h>

#include "CUsbActiveMscHandlerMdrv.h"

#include "CUsbMscPersonalityTimer.h"

#include "debug.h"

#include <featmgr.h> // for checking DE feature

#include <DevEncSessionBase.h>

#include <DevEncEngineConstants.h>

// LITERALS

_LIT( KMsFs,"MSFS.FSY" );

_LIT( KMsFsyName, "MassStorageFileSystem" );

_LIT( KFatFsyName, "Fat" );

const TUint32 KDismountFatTimeoutValue = 5000000; // 5 seconds

const TInt KMscDismountRetryCount = 3;

const TUint32 KWaitMscToComplete = 50000; // 50 ms

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

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

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

// might leave.

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

//

CUsbActiveMscHandler::CUsbActiveMscHandler(TUsbPersonalityParams& aPersonalityParams)

    : CUsbPersonalityPlugin(aPersonalityParams), iMountChanged(EFalse)

    {

    CActiveScheduler::Add( this );

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CUsbActiveMscHandler::ConstructL()

    {

    FLOG( _L( "[USBWATCHER]\tCUsbActiveMscHandler: ConstructL" ) );

    iDismountFatTimer = new (ELeave) CUsbMscPersonalityTimer(

        TCallBack(DismountFatCallBack, this), KDismountFatTimeoutValue);

    iMscState = EUsbMscStateIdle;

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

    iRepository = CRepository::NewL(KCRUidSecuritySettings); 

    LoadDevEncSessionL();

    }

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

// Two-phased constructor.

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

//

CUsbActiveMscHandler* CUsbActiveMscHandler::NewL(TUsbPersonalityParams& aPersonalityParams)

    {

    CUsbActiveMscHandler* self 

        = new ( ELeave ) CUsbActiveMscHandler(aPersonalityParams);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); // pop self

    return self;

    }

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

// Destructor

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

//

CUsbActiveMscHandler::~CUsbActiveMscHandler()

    {

    FLOG( _L( "[USBWATCHER]\tCUsbActiveMscHandler::~CUsbActiveMscHandler" ) );

    if ( iMountChanged ) 

        {        

        UnmountMassStorage();

        }

    RemoveMassStorageFileSystem();

    Cancel();

    delete iDismountFatTimer;

    iDrives.Close();

    iFs.Close();

    delete iRepository;

    UnloadDevEncSession();    

    }

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

// State machine for the class.

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

//

void CUsbActiveMscHandler::RunL()

    {

    FTRACE( FPrint(

        _L( "[USBWATCHER]\tCUsbActiveMscHandler::RunL error = %d" ),

        iStatus.Int() ) );

    FTRACE( FPrint(

        _L( "[USBWATCHER]\tCUsbActiveMscHandler::RunL iMscState = %d" ),

        iMscState ) );

    switch (iMscState)

        {

        case EUsbMscStateMounting:

            // DismountFatTimer is not exprired but RunL called with error

            if (KErrNone!=iStatus.Int())

              {

              /* Print error code, drive name and wait for timer to be expired expired (5sec) 

               * which will call forcibly dismount*/

              if(KErrNone!=iStatus.Int() )

               {

               FLOG( _L( "[USBWATCHER]\tCUsbActiveMscHandler::RunL*** Drive Dismounting failed ") );

               FTRACE( FPrint(

                   _L( "[USBWATCHER]\tCUsbActiveMscHandler::RunL*** Dismount failed on DriveIndex= %d" ),

                   iDriveIndex));

               FTRACE( FPrint(

                   _L( "[USBWATCHER]\tCUsbActiveMscHandler::RunL*** Dismount failed on Drive = %d" ),

                   iDrives[iDriveIndex]) );

               }

              }

            else

              {

              //dismount FAT done for one drive

              if (iDismountFatTimer)

               {

               iDismountFatTimer->Cancel();

               } 

              StartDismountFat();

              }

            break;

        case EUsbMscStateForciblyDismounting:

            // If Even ForciblyDismount failed with error we cannot do much here, and just print Error message 

            if(KErrNone!=iStatus.Int() )

              {

              FLOG( _L( "[USBWATCHER]\tCUsbActiveMscHandler::RunL*** FS has seroius dismounting problem" ) );

              }

            // we change the state and continue with other drives 

            iMscState = EUsbMscStateMounting;                 

            StartDismountFat();

            break; 

        default:

            break;

        }

    }

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

// Not possible to come here.

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

//

TInt CUsbActiveMscHandler::RunError( TInt /*aError*/ )

    {

    return KErrNone;

    }

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

// This method always confirms the personality unloading.

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

//

void CUsbActiveMscHandler::ConfirmPersonalityUnload(TRequestStatus& aStatus)

    {

    FTRACE( FPrint(

        _L( "[USBWATCHER]\tCUsbActiveMscHandler: ConfirmPersonalityUnload iMscState = %d" ),

        iMscState ) );

    iRequestStatus = &aStatus;

    aStatus = KRequestPending;

    CompleteRequest(KErrNone);

    }

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

// Called by personality handler when personality start needs to be

// prepared. Adds mass storage file system. 

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

//

void CUsbActiveMscHandler::PreparePersonalityStart(TRequestStatus& aStatus)

    {

    TInt ret = KErrNone;

    FLOG( _L( "[USBWATCHER]\tCUsbActiveMscHandler: PreparePersonalityStart" ) );

    iRequestStatus = &aStatus;

    aStatus = KRequestPending;

    iMscState = EUsbMscStateStarting;

    ret = AddMassStorageFileSystem();

    CompleteRequest(ret);

    }

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

// Called by personality handler when personality start needs to be finished.

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

//

void CUsbActiveMscHandler::FinishPersonalityStart(TRequestStatus& aStatus)

    {

    FLOG( _L( "[USBWATCHER]\tCUsbActiveMscHandler: FinishPersonalityStart" ) );

    iRequestStatus = &aStatus;

    aStatus = KRequestPending;

    CompleteRequest(KErrNone);

    }

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

// Called by personality handler when personality stop needs to be prepared. 

// Changes state of the personality.

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

//

void CUsbActiveMscHandler::PreparePersonalityStop(TRequestStatus& aStatus)

    {

    FLOG( _L( "[USBWATCHER]\tCUsbActiveMscHandler: PreparePersonalityStop" ) );

    //Mounting may be ongoing

    iRequestStatus = NULL; //do not complete in DoCancel

    Cancel(); 

    iRequestStatus = &aStatus;

    aStatus = KRequestPending;

    iMscState = EUsbMscStateStopping;

    CompleteRequest(KErrNone);

    }

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

// Called by personality handler when personality stop needs to be finished. 

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

//

void CUsbActiveMscHandler::FinishPersonalityStop(TRequestStatus& aStatus)

    {

    FLOG(_L("[USBWATCHER]\tCUsbActiveMscHandler: FinishPersonalityStop"));

    //Mounting may be ongoing

    iRequestStatus = NULL; //do not complete in DoCancel

    Cancel(); 

    //unmount in case device state not yet Undefined

    if (iMountChanged)

        {

        UnmountMassStorage();

        }

    RemoveMassStorageFileSystem();

    // Remove all queries shown by this personality

    iPersonalityParams.PersonalityNotifier().CancelQuery(KQueriesNotifier);

    iMscState = EUsbMscStateIdle;

    iRequestStatus = &aStatus;

    aStatus = KRequestPending;

    CompleteRequest(KErrNone);

    }

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

// Indicates USB device state change to personality. 

// There is no need to Cancel, because Confirm unload can not be ongoing 

// before Address state. 

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

// 

void CUsbActiveMscHandler::StateChangeNotify( TUsbDeviceState aState )

    {

    FTRACE( FPrint(

        _L( "[USBWATCHER]\tCUsbActiveMscHandler::StateChangeNotify aState = %d" ),

        aState ) );

    switch( aState )

        {        

        //Note that Address state may be caused also by cable disconnection.

        case EUsbDeviceStateAddress: 

            {

            //Do not start mounting if already ongoing 

            //e.g. fast state changes Address-->Suspended-->Address

            if ( !iMountChanged && (GetDrives() == KErrNone) )

                {

                if (iDrives.Count())

                    {

                    iDriveIndex = iDrives.Count();

                    StartDismountFat();

                    }

                else

                    {

                    if ( GlobalSystemState() == EUsbGSStateCategoryNormal )

                        {

                        // if the error is something abnormal, note still needs to be shown

                        iQueryParams().iQuery = EUSBStorageMediaFailure;

                        iPersonalityParams.PersonalityNotifier().ShowQuery(

                            KQueriesNotifier, iQueryParams, iDummy);

                        }            

                    }    

                }

            }

            break;

        case EUsbDeviceStateUndefined: 

            {

            if (iMountChanged)

                {

                UnmountMassStorage();

                iMscState = EUsbMscStateIdle;

                }

            }

            break;

        default:

            break;

        }

    FLOG(_L("[USBWATCHER]\tCUsbActiveMscHandler::StateChangeNotify completed"));

    }

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

// Start FAT dismounting sequence.

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

// 

void CUsbActiveMscHandler::StartDismountFat()

    {

    FLOG(_L("[USBWATCHER]\tCUsbActiveMscHandler::StartDismountFat"));

    iMountChanged = ETrue;

    if (!iDriveIndex)

        {

        //FAT dismounted from all the drives

        MountMassStorage();            

        //MSFS mounted to all the drives

        iMscState = EUsbMscStateFileTransfer;

        }

    else

        {

        --iDriveIndex;

        FTRACE( FPrint(

            _L( "[USBWATCHER]\tCUsbActiveMscHandler::StartDismountFat iDriveIndex = %d " ),

            iDriveIndex) );

        // see if FAT file system exists in drive and if it does, try to dismount it

        DismountFat(iDrives[iDriveIndex]);

        }

    }

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

// Add mass storage file system

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

// 

TInt CUsbActiveMscHandler::AddMassStorageFileSystem()

    {

    FLOG(_L("[USBWATCHER]\tCUsbActiveMscHandler::AddMassStorageFileSystem"));

    TInt ret = KErrNone;

    // To be done only once during the lifetime of this object:

    // 5b. add Mass Storage File System to the file server.

    // (done like this to avoid Symbian crash)

    if (!iMsfsAdded)

        {

        FLOG( _L( "[USBWATCHER]\tCUsbActiveMscHandler::AddMassStorageFileSystem: Loading MSFS" ) );

        ret = iFs.AddFileSystem(KMsFs);

        if ((ret != KErrNone) && (ret != KErrAlreadyExists))

            {

            FTRACE( FPrint(

                _L( "[USBWATCHER]\tCUsbActiveMscHandler::AddMassStorageFileSystem: ERROR: MSFS loading failed. Code: %d " ),

                ret) );

            }

        else

            {

            iMsfsAdded = ETrue;

            if (ret == KErrAlreadyExists)

                {

                ret = KErrNone;

                }

            }

        }

    FTRACE(FPrint(_L("[USBWATCHER]\tCUsbActiveMscHandler::AddMassStorageFileSystem: ret=%d"), ret));

    return ret;

    }

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

// Remove mass storage file system (MSFS) from file server

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

// 

void CUsbActiveMscHandler::RemoveMassStorageFileSystem()

    {

    FLOG(_L("[USBWATCHER]\tCUsbActiveMscHandler::RemoveMassStorageFileSystem"));

    if (iMsfsAdded)

        {

        if (iFs.RemoveFileSystem(KMsFsyName) != KErrNone)

            {

            FLOG( _L( "[USBWATCHER]\tCUsbActiveMscHandler: RemoveMassStorageFileSystem: MSFS not removed from file server." ) );

            }

        else

            {

            iMsfsAdded = EFalse;

            }

        }    

    }

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

// Mount mass storage to all drives. Does not mount in charging state if device 

// locked.

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

// 

void CUsbActiveMscHandler::MountMassStorage()

    {

    FLOG(_L("[USBWATCHER]\tCUsbActiveMscHandler::MountMassStorage"));

    TInt ret = KErrNone;

    TBool locked = DeviceLocked();

    TUsbGlobalSystemState state = GlobalSystemState();

    FTRACE(FPrint(_L("[USBWATCHER]\tCUsbActiveMscHandler::MountMassStorage: locked=%d, state=%d"), locked, state));

    if ( (state == EUsbGSStateCategoryNormal) || 

       (!locked && (state==EUsbGSStateCharging)) )

        {

        for ( TInt driveIndex = iDrives.Count() - 1; driveIndex >= 0; driveIndex-- )

            {

            // Try mount Mass Storage File System into drive.

            ret = TryMountMassStorage(iDrives[driveIndex]);

            if (ret != KErrNone)

                {

                FTRACE(FPrint(_L("[USBWATCHER]\tCUsbActiveMscHandler::MountMassStorage: driveIndex=%d ret=%d"), 

                    driveIndex, ret));

                }

            }

        }

    }

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

// Return removable drives in system.

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

//  

TInt CUsbActiveMscHandler::GetDrives()

    {    

    TInt i;

    TInt ret = KErrNone;

    // go through drives A-Z except for C and Z

    TDriveInfo driveInfo;

    iDrives.Reset();

    for (i = EDriveA; i < EDriveZ; i++)

        {

        // skip drive C: and get drive info

        if ( EDriveC == i ) 

            {

            continue;

            }

    // unmounting FAT from the card when a decrypting/encrypting operation

    // is ongoing will corrupt the card, so it must be prevented.      

	if( ( i == EDriveE ) || ( i == EDriveF ) )

		{

        if(IsEncProtectionRequired(i))

			{

			FTRACE( FPrint( _L(" Skipping drive %d"), i));

			continue;

			}

		}

        iFs.Drive(driveInfo, i);

        // if drive is not removable and local, it can be skipped

        if ((driveInfo.iDriveAtt & (KDriveAttRemovable | KDriveAttLocal))

            != (KDriveAttRemovable | KDriveAttLocal))

            {

            continue;

            }    

        FTRACE( FPrint(

            _L( "[USBWATCHER]\tCUsbActiveMscHandler::GetDrives, removable drive %d: MediaAtt: %d" ),

            i,driveInfo.iMediaAtt ) );

        FTRACE( FPrint(

            _L( "[USBWATCHER]\tCUsbActiveMscHandler::GetDrives, removable drive %d: Media info: %d" ),

            i, driveInfo.iType ) );

        // The memory card may be locked. No memory card password query is shown. 

        FTRACE(FPrint(

               _L("[USBWATCHER]\tCUsbActiveMscHandler::GetDrives: MMC inserted into drive %d"),

               i) );

        ret = iDrives.Append(i);

        }

    if (!iDrives.Count())

        {

        FLOG( _L( "[USBWATCHER]\tCUsbActiveMscHandler::GetDrives: No removable drives found." ) );

        iQueryParams().iQuery = EUSBStorageMediaFailure;

        iPersonalityParams.PersonalityNotifier().ShowQuery(KQueriesNotifier, iQueryParams, iDummy);

        return KErrNotFound;

        }

    return ret;

    }

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

// Dismounts FAT File System.

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

//   

void CUsbActiveMscHandler::DismountFat( TInt aDrive )

    {

    FLOG( _L( "[USBWATCHER]\tCUsbActiveMscHandler::DismountFat" ) );

    //nothing to do if FAT file system not in aDrive

    if ( GetDriveFileSystem(aDrive) != EFsyFat )

        {

        FTRACE( FPrint(

            _L( "[USBWATCHER]\tCUsbActiveMscHandler::DismountFat: FAT FSY not found in drive %d" ),

            aDrive ) );

        //continue to the next drive

        TRequestStatus* status = &iStatus;

        User::RequestComplete(status, KErrNotFound);

        SetActive();

        }

    else

        {

        //FAT file system exists in aDrive -> dismount it

        iFs.NotifyDismount(iDrives[iDriveIndex], iStatus, EFsDismountNotifyClients);

        SetActive();

        //Give some time for applications before dismounting forcefully