/*
* Copyright (c) 2002-2004 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:  Xuikon hspshspsFileChangeListenerEmu listens to given file folder and notifies it observer (Only in Emulator environment)
*                if there is any file change.
*
*
*/


#include "hsps_builds_cfg.hrh"

#ifdef _hsps_EMULATOR_SUPPORT_

#include "hspsfilechangelisteneremu.h"

#ifdef HSPS_LOG_ACTIVE
#include <hspslogbus.h>
#endif

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

// -----------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::ChspsFileChangeListenerEmu
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
ChspsFileChangeListenerEmu::ChspsFileChangeListenerEmu( RFs& aFs, 
                              MhspsEmuFileChangeObserver& aObserver,
                              TEmuNotifyType aNotifyType) :
    CTimer(EPriorityLow),
    iFs( aFs ), 
    iObserver( aObserver), 
    iNotifyType( aNotifyType )
    {
    }

// -----------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void ChspsFileChangeListenerEmu::ConstructL( const TDesC& aFullPath )
    {
    
    iFileList = new( ELeave ) CDesCArraySeg(KFilelistGranularity );
    iState = EEmuStateIdle;
   
    if ( aFullPath.Length() > 0 )
        {
        iFullPath.Append( aFullPath );
        }
    CTimer::ConstructL();
    CActiveScheduler::Add( this );
    }

// -----------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
ChspsFileChangeListenerEmu* ChspsFileChangeListenerEmu::NewL(   RFs& aFs, 
                                        MhspsEmuFileChangeObserver& aObserver, 
                                        TEmuNotifyType aNotifyType,
                                        const TDesC& aFullPath)
    {
    ChspsFileChangeListenerEmu* self = new(ELeave) ChspsFileChangeListenerEmu( aFs, 
        aObserver, 
        aNotifyType);
    CleanupStack::PushL( self );
    self->ConstructL( aFullPath );
    CleanupStack::Pop( self );

    return self;
    }


// ------------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::~ChspsFileChangeListenerEmu
// Destructor
// ------------------------------------------------------------------------------
ChspsFileChangeListenerEmu::~ChspsFileChangeListenerEmu()
    {
    Cancel();
    
    if (iFileList)
        {
        delete iFileList;
        iFileList = NULL;
        }
        
    }

// -----------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::RunL
// From CActive. Called when asynchronous request is completed. 
// Notifies the observer
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void ChspsFileChangeListenerEmu::RunL()
    {
    TBool Diff(EFalse);
    TInt errCode = KErrNone;
    if (iStatus.Int() == KErrNone)
        {
        CDesCArraySeg* CurFileList = new( ELeave ) CDesCArraySeg(KFilelistGranularity );
        CleanupStack::PushL(CurFileList);

        // Retrieve current list of files in filesystem
        TRAP(errCode, RetrieveFileListL(*CurFileList, iFullPath);)
        if (errCode)
            {
#ifdef HSPS_LOG_ACTIVE
            if( iLogBus )
                {
                iLogBus->LogText( _L( "ChspsFileChangeListenerEmu::RunL():RetrieveFileListL, Error=%d" ),
                        errCode );
                }
#endif    
            }

        // Compare files  
        TRAP(errCode, Diff = CompareFilesL(*CurFileList);)
        if (errCode)
            {
#ifdef HSPS_LOG_ACTIVE
            if( iLogBus )
                {
                iLogBus->LogText( _L( "ChspsFileChangeListenerEmu::RunL():CompareFilesL, Error=%d" ),
                        errCode );
                }
#endif
            }
        
        // If changes, call observer handle function
        if (Diff) 
            {
            InformObserver(); 
            }

        // Store current file situation
        TRAP(errCode, StoreFileListL(*CurFileList);)
        if (errCode)
            {
#ifdef HSPS_LOG_ACTIVE
            if( iLogBus )
                {
                iLogBus->LogText( _L( "ChspsFileChangeListenerEmu::RunL():StoreFileListL, Error=%d" ),
                        errCode );
                }
#endif
            }
            
        CleanupStack::Pop( CurFileList );
        if ( CurFileList )
            {
        	delete CurFileList;
        	CurFileList = NULL;
            }
                        
        // Restart timer
        After(KFileSystemPollingTime);  
        }
 
    }

// -----------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::RunError
// From CActive. Called when error occurred in asynchronous request
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt ChspsFileChangeListenerEmu::RunError( TInt /*aError*/ )
    {
    return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::DoCancel()
// Not implemented yet
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//   
void ChspsFileChangeListenerEmu::DoCancel()
    {
    iState = EEmuStateIdle;
    CTimer::DoCancel();
    } 
    
// ------------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::StartL
// Starts polling directory for changes
// ------------------------------------------------------------------------------
//
void ChspsFileChangeListenerEmu::StartL()
    {
    TInt errCode = KErrNone;
    
    if (iState == EEmuStateIdle)
        {
        CDesCArraySeg* CurFileList = new( ELeave ) CDesCArraySeg(KFilelistGranularity );
        
        CleanupStack::PushL(CurFileList);
        
        // Retrieve current list of files in filesystem
        TRAP(errCode, RetrieveFileListL(*CurFileList, iFullPath);)
        if (errCode)
            {
            User::Leave(errCode);
            }
        
        // Store current file situation
        TRAP(errCode, StoreFileListL(*CurFileList);)
        if (errCode)
            {
            User::Leave(errCode);
            }
        
        CleanupStack::Pop( CurFileList );
        if ( CurFileList )
            {
        	delete CurFileList;
        	CurFileList = NULL;
            }

        // Start timer
        After(KFileSystemPollingTime);
        
        iState = EEmuStateRunning;
        }
    
    }
   
// ------------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::Stop
// Stops polling of directory
// ------------------------------------------------------------------------------
//
void ChspsFileChangeListenerEmu::Stop()
    {
    Cancel();
    }

#ifdef HSPS_LOG_ACTIVE
// ------------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::SetLogBus
// Set log bus to be used.
// ------------------------------------------------------------------------------
//
void ChspsFileChangeListenerEmu::SetLogBus( ChspsLogBus* aLogBus )
    {
    iLogBus = aLogBus;
    }
#endif

    
// ------------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::InformObserver
// Informs observer of file change
// ------------------------------------------------------------------------------
//
void ChspsFileChangeListenerEmu::InformObserver()
    {
    iObserver.HandleEmuFileSystemChange();        
    }

// ------------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::RetrieveFileListL
// Retrieves current list of files in filesystem
// ------------------------------------------------------------------------------
//
void ChspsFileChangeListenerEmu::RetrieveFileListL( CDesCArraySeg& aFileList, const TDesC& aPath )
    {  
   CDirScan* dir_list = CDirScan::NewL( iFs );
   CleanupStack::PushL( dir_list );
   
   dir_list->SetScanDataL( aPath,
           KEntryAttNormal,
           ESortByName | EAscending,
           CDirScan::EScanDownTree );
   
   CDir* dirEntries = NULL;   
   dir_list->NextL( dirEntries );   
   while( dirEntries != NULL )
       {
       CleanupStack::PushL( dirEntries );
       
       TInt iDirCount = dirEntries->Count();
       for( TInt i = 0; i < iDirCount; i++ )
           {
           const TEntry a = dirEntries->operator[]( i );
           aFileList.AppendL( a.iName );
           }
       
       CleanupStack::PopAndDestroy( dirEntries );
       dirEntries = NULL;
       dir_list->NextL( dirEntries );       
       }

   CleanupStack::PopAndDestroy(dir_list);

   }
    
// ------------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::StoreFileListL
// Stores list of files to memory
// ------------------------------------------------------------------------------
//
void ChspsFileChangeListenerEmu::StoreFileListL(CDesCArraySeg& aFileList)
    {
    
    if (iFileList)
        {
        iFileList->Reset();
        
        for ( TInt i = 0; i < aFileList.Count(); i++)
            {
            TPtrC t = aFileList.MdcaPoint(i);
            iFileList->AppendL(t);	
            }
        }
    }    
    

// ------------------------------------------------------------------------------
// ChspsFileChangeListenerEmu::CompareFilesL
// Compares given filelist to filelist on memory
// ------------------------------------------------------------------------------
//
TBool ChspsFileChangeListenerEmu::CompareFilesL(CDesCArraySeg& aFileList)
    {
    TInt p = 0;
    TBool ret(EFalse);
    
    if (iFileList->Count() == aFileList.Count() )
        {
        for (p = 0;p < iFileList->Count(); p++)
            {
               TBool found(EFalse);
               TInt i=0;
               while (!found && i<aFileList.Count())
                  {
                     TPtrC t = iFileList->MdcaPoint(i);
                     if (!(t.CompareF(aFileList.MdcaPoint(p)) ) )
                     {
                        found=ETrue;
                        break;
                     }
                     
                    i++;
                  }
                  
               if (!found)
               {
                  ret = ETrue;
                  break;
               }
            }
        }
    else
        {
        ret = ETrue;        
        }
          
   return ret;
  
   }

#endif // _hsps_EMULATOR_SUPPORT_
    
// End of File