/*

* Copyright (c) 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: 

*

*/

// INCLUDE FILES

#include    <pathinfo.h>

#include    <driveinfo.h>

#include    <UsbWatcherInternalPSKeys.h>

#include    <usbpersonalityids.h>

#include    "CamDriveChangeNotifier.h"

#include    "camlogging.h"

#include    "CamUtility.h"

_LIT(KDriveE, "E:\\");

_LIT(KDriveF, "F:\\");

const TInt KUSBTimeout = 1000000;  //1 sec

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

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

// CCamDriveChangeNotifier::CCamDiskChangeListener::NewL

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

//

CCamDriveChangeNotifier::CCamDiskChangeListener* 

    CCamDriveChangeNotifier::CCamDiskChangeListener::NewLC(

                  RFs& aFs,

                  TDriveNumber aDrive,                                         

                  CCamDriveChangeNotifier& aObserver )

  {

  PRINT( _L( "Camera => CCamDiskChangeListener::NewLC" ) );

  CCamDiskChangeListener* self = 

        new( ELeave ) CCamDiskChangeListener( aFs, aDrive, aObserver );

  CleanupStack::PushL( self );

  PRINT( _L( "Camera <= CCamDiskChangeListener::NewLC" ) );

  return self;

  }

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

// CCamDriveChangeNotifier::CCamDiskChangeListener::~CCamDiskChangeListener

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

//

CCamDriveChangeNotifier::CCamDiskChangeListener::~CCamDiskChangeListener()

  {

  PRINT( _L( "Camera => CCamDiskChangeListener::~CCamDiskChangeListener" ) );

  Cancel();

  PRINT( _L( "Camera <= CCamDiskChangeListener::~CCamDiskChangeListener" ) );

  }

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

// CCamDriveChangeNotifier::CCamDiskChangeListener::CCamDiskChangeListener

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

//

CCamDriveChangeNotifier::CCamDiskChangeListener::CCamDiskChangeListener(

                  RFs& aFs,

                  TDriveNumber aDrive,                                         

                  CCamDriveChangeNotifier& aObserver )

    : CActive( CActive::EPriorityIdle ),

      iFs( aFs ),

      iDrive( aDrive ),

      iObserver( aObserver )                                          

  {

  CActiveScheduler::Add( this );

  }

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

// CCamDriveChangeNotifier::CCamDiskChangeListener::Start

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

//

void CCamDriveChangeNotifier::CCamDiskChangeListener::Start()

  {

  PRINT( _L( "Camera => CCamDiskChangeListener::Start" ) );

  if ( !IsActive() )

    {

    PRINT( _L( "Camera <> CCamDiskChangeListener::Start SetActive()" ) );

    // Start listening for change events

    if(iDrive == EDriveE)

        {

        iFs.NotifyChange( ENotifyDisk, iStatus, KDriveE );

        }

    else if( iDrive == EDriveF )

        {

        iFs.NotifyChange( ENotifyDisk, iStatus, KDriveF );

        }

    else

        {

        iFs.NotifyChange( ENotifyDisk, iStatus );

        }

    SetActive();

    }

  PRINT( _L( "Camera <= CCamDiskChangeListener::Start" ) );

  }

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

// CCamDriveChangeNotifier::CCamDiskChangeListener::Stop

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

//

void CCamDriveChangeNotifier::CCamDiskChangeListener::Stop()

  {

  PRINT( _L( "Camera => CCamDiskChangeListener::Stop" ) );

  Cancel();

  PRINT( _L( "Camera <= CCamDiskChangeListener::Stop" ) );

  }

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

// CCamDriveChangeNotifier:::CCamDiskChangeListener::DoCancel

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

//

void CCamDriveChangeNotifier::CCamDiskChangeListener::DoCancel()

  {

  PRINT( _L( "Camera => CCamDiskChangeListener::DoCancel" ) );

  iFs.NotifyChangeCancel();

  PRINT( _L( "Camera <= CCamDiskChangeListener::DoCancel" ) );

  }

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

// CCamDriveChangeNotifier::CCamDiskChangeListener::RunL

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

//

void CCamDriveChangeNotifier::CCamDiskChangeListener::RunL()

  {

  PRINT1( _L( "Camera => CCamDiskChangeListener::RunL, iStatus: %d" ), iStatus.Int() );

  TInt ret = KErrNone;

  if ( iStatus == KErrNone )

    {

    TUint driveStatus;  

    ret = DriveInfo::GetDriveStatus(iFs, iDrive, driveStatus );

    if( ret == KErrNone)

        {

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

                ( ( driveStatus & DriveInfo::EDrivePresent ==  DriveInfo::EDrivePresent ) &&

                  ( driveStatus & DriveInfo::EDriveInUse ==  DriveInfo::EDriveInUse ) ) )

            {

            RDebug::Print(_L("CCamDiskChangeListener::RunL Dismount:%d"),iDrive);

            ret = iObserver.NotifyChangeL( MCamDriveChangeNotifierObserver::EDriveDismount );

            }

        else if( ( driveStatus & DriveInfo::EDrivePresent ) == DriveInfo::EDrivePresent )

            {

            RDebug::Print(_L("CCamDiskChangeListener::RunL Mount:%d"),iDrive);

            ret = iObserver.NotifyChangeL( MCamDriveChangeNotifierObserver::EDriveMount );

            }

        }

    if( ret == KErrNone )

      {

      Start();

      }

    }

  else if ( iStatus == KErrNotReady )

    {

    // Give other threads chance to run	

    User::After( 0 );	

    Start();

    }	

  PRINT( _L( "Camera <= CCamDiskChangeListener::RunL" ) );

  }

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

// CCamDriveChangeNotifier::CCamDriveChangeNotifier

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

//

CCamDriveChangeNotifier::CCamDriveChangeNotifier(

                                    RFs& aFs,

                                    MCamDriveChangeNotifierObserver& aObserver )

    : iObserver( aObserver ),

      iFs( aFs )

  {

  }

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

// CCamDriveChangeNotifier::NewL

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

//

CCamDriveChangeNotifier* CCamDriveChangeNotifier::NewL(

                                  RFs& aFs,

                                  MCamDriveChangeNotifierObserver& aObserver )

  {

  PRINT( _L( "Camera => CCamDriveChangeNotifier::NewL" ) );

  CCamDriveChangeNotifier* self =

                      new( ELeave ) CCamDriveChangeNotifier( aFs, aObserver );

  self->ConstructL();

  PRINT( _L( "Camera <= CCamDriveChangeNotifier::NewL" ) );

  return self;

  }

// Destructor

CCamDriveChangeNotifier::~CCamDriveChangeNotifier()

  {

  PRINT( _L( "Camera => CCamDriveChangeNotifier::~CCamDriveChangeNotifier" ) );

  CancelMonitoring();

  iListeners.ResetAndDestroy();

  if( iUsbMSWatcher )

      {

      if( iUsbMSWatcher->IsActive() )

          {

          iUsbMSWatcher->Cancel();

          }

      delete iUsbMSWatcher;

      iUsbMSWatcher = NULL;

      }

  if ( iUSBTimer )

      {

      if( iUSBTimer->IsActive() )

          {

          iUSBTimer->Cancel();

          }

      delete iUSBTimer;

      iUSBTimer = NULL;

      }

  PRINT( _L( "Camera <= CCamDriveChangeNotifier::~CCamDriveChangeNotifier" ) );

  }

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

// CCamDriveChangeNotifier::StartMonitoring

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

//

void CCamDriveChangeNotifier::StartMonitoring()

  {

  PRINT( _L( "Camera => CCamDriveChangeNotifier::StartMonitoring" ) );

  for ( TInt i = iListeners.Count(); --i >= 0; )

    {

    iListeners[i]->Start();

    }

  iUsbMSWatcher->Subscribe();

  PRINT( _L( "Camera <= CCamDriveChangeNotifier::StartMonitoring" ) );

  }

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

// CCamDriveChangeNotifier::CancelMonitoring

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

//

void CCamDriveChangeNotifier::CancelMonitoring()

  {

  PRINT( _L( "Camera => CCamDriveChangeNotifier::CancelMonitoring" ) );

  for ( TInt i = iListeners.Count(); --i >= 0; )

    {

    iListeners[i]->Stop();

    }

  //iUsbMSWatcher->Cancel();

  PRINT( _L( "Camera <= CCamDriveChangeNotifier::CancelMonitoring" ) );

  }

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

// CCamDriveChangeNotifier::NotifyChangeL

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

//

TInt CCamDriveChangeNotifier::NotifyChangeL( 

                  MCamDriveChangeNotifierObserver::TCamDriveChangeType aType )

  {

  PRINT( _L( "Camera => CCamDriveChangeNotifier::NotifyChangeL" ) );

  TInt ret = iObserver.DriveChangeL( aType );

  if ( ret == KErrNone && aType == 

                            MCamDriveChangeNotifierObserver::EDriveDismount )

    {

    PRINT( _L("Camera <> iFs.AllowDismount( EDriveE )") )

    iFs.AllowDismount( EDriveE );

    PRINT( _L("Camera <> iFs.AllowDismount( EDriveD )") )

    iFs.AllowDismount( EDriveF );

    }

  PRINT( _L( "Camera <= CCamDriveChangeNotifier::NotifyChangeL" ) );        

  return ret;

  }

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

// CCamDriveChangeNotifier::SendAllowDismount

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

//

void CCamDriveChangeNotifier::SendAllowDismount()

  {

  PRINT( _L( "Camera => CCamDriveChangeNotifier::SendAllowDismount" ) );

  iFs.AllowDismount( EDriveE );

  iFs.AllowDismount( EDriveF );

  StartMonitoring();

  PRINT( _L( "Camera <= CCamDriveChangeNotifier::SendAllowDismount" ) );

  }

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

// CCamDriveChangeNotifier::HandlePropertyChangedL

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

//

void CCamDriveChangeNotifier::HandlePropertyChangedL( const TUid& aCategory, const TUint aKey )

    {

    PRINT( _L( "Camera => CCamDriveChangeNotifier::HandlePropertyChangedL" ) );

    if(KPSUidUsbWatcher == aCategory && 

       KUsbWatcherSelectedPersonality == aKey)

        {

        TInt value = 0;

        iUsbMSWatcher->Get( value );

        if( KUsbPersonalityIdMS == value )

            {

            PRINT( _L( "Camera => CCamDriveChangeNotifier::HandlePropertyChangedL StartTimer" ) );

            iUSBTimer->Cancel();

            iUSBTimer->StartTimer();

            }

        else

            {

            if( iMassStorageModeOn )

                {

                PRINT( _L("CCamDriveChangeNotifier::HandlePropertyChangedL KUsbPersonalityIdMS Off") );

                iMassStorageModeOn = EFalse;

                iObserver.DriveChangeL( MCamDriveChangeNotifierObserver::EDriveUSBMassStorageModeOff );

                }

            }

        }

    PRINT( _L( "Camera <= CCamDriveChangeNotifier::HandlePropertyChangedL" ) );

    }

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

// CCamDriveChangeNotifier::ConstructL

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

//

void CCamDriveChangeNotifier::ConstructL()

    {

    iListeners.AppendL( CCamDiskChangeListener::NewLC( iFs, EDriveE, 

                          *this ) );

    iListeners.AppendL( CCamDiskChangeListener::NewLC( iFs, EDriveF, 

                         *this ) );  

    iUsbMSWatcher = CCamPropertyWatcher::NewL(*this, KPSUidUsbWatcher, 

                        KUsbWatcherSelectedPersonality );

    iUSBTimer = CCamTimer::NewL( KUSBTimeout, TCallBack(USBTimerCallBack, this));

    CleanupStack::Pop(); // listener

    CleanupStack::Pop(); // listener 2

    //if USB has been inserted as Mass Storage, USB timer need to start

    TInt value = 0;

    iUsbMSWatcher->Get( value );

    if( iUSBTimer && KUsbPersonalityIdMS == value ) 

        {

        iUSBTimer->Cancel();

        iUSBTimer->StartTimer();

        }

    StartMonitoring();

    }

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

// CCamDriveChangeNotifier::USBTimerCallBackL

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

//

void CCamDriveChangeNotifier::USBTimerCallBackL()

    {

    TInt value = 0;

    iUsbMSWatcher->Get( value );

    if( KUsbPersonalityIdMS == value )

        {

        PRINT( _L("CCamDriveChangeNotifier::USBTimerCallBackL KUsbPersonalityIdMS On") );

        iMassStorageModeOn = ETrue;

        iObserver.DriveChangeL( MCamDriveChangeNotifierObserver::EDriveUSBMassStorageModeOn );

        }

    else

        {

        if( iMassStorageModeOn )

            {

            PRINT( _L("CCamDriveChangeNotifier::USBTimerCallBackL KUsbPersonalityIdMS Off") );

            iMassStorageModeOn = EFalse;

            iObserver.DriveChangeL( MCamDriveChangeNotifierObserver::EDriveUSBMassStorageModeOff );

            }

        }

    }

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

// CCamDriveChangeNotifier::USBTimerCallBack

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

//

TInt CCamDriveChangeNotifier::USBTimerCallBack( TAny* aPtr )

    {

    CCamDriveChangeNotifier* self = static_cast<CCamDriveChangeNotifier*>(aPtr);

    if( self )

        {

        TRAP_IGNORE( self->USBTimerCallBackL() );

        }

    return KErrNone;

    }

//  End of File