/*
* Copyright (c) 2006-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:  Implementation of CIRSystemEventCollector
*
*/


#include <e32cmn.h>
#include <UiklafInternalCRKeys.h>
#include <centralrepository.h>

#include "iraccessoryobserver.h"
#include "irdiskspacewatcher.h"
//#include "irrepositorymanager.h"
#include "irsystemeventcollector.h"
#include "irsystemeventdetector.h"
#include "irdebug.h"

// Constants
const TInt KIRObserverArrayGranularity( 2 );
const TInt KIR_DEFAULT_CRITICAL_LEVEL = 3145728;	// 3MB
const TInt KThree =3;  
// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CIRSystemEventCollector::CIRSystemEventCollector() : 
    iSystemEventObservers( KIRObserverArrayGranularity )
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::CIRSystemEventCollector" );
    }

// ---------------------------------------------------------------------------
// Second-phase constructor
// ---------------------------------------------------------------------------
//
void CIRSystemEventCollector::ConstructL()
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::ConstructL - Entering" );
    iSystemEventDetector = CIRSystemEventDetector::NewL( *this );

    iHeadsetObserver = CIRAccessoryObserver::NewL();
    iHeadsetObserver->SetObserver( this );

    TInt criticalLevel = 0;

	CRepository* cenrep = CRepository::NewLC(KCRUidUiklaf );
	TInt err = cenrep->Get(KUikOODDiskCriticalThreshold, criticalLevel);
	CleanupStack::PopAndDestroy(cenrep);
	if(err != KErrNone)
		{
		criticalLevel = KIR_DEFAULT_CRITICAL_LEVEL;
		IRLOG_WARNING( "CIRSystemEventCollector::ConstructL - Failed to read criticalLevel. Using default 3MB" );
		}
    criticalLevel = criticalLevel * KThree;
    iDiskSpaceWatcher = CIRDiskSpaceWatcher::NewL( static_cast<TInt64>( criticalLevel ), *this );
    iDiskSpaceWatcher->StartObservingDriveL( KVRDefaultDrive );

	IRRDEBUG3("CIRSystemEventCollector::ConstructL - DiskSpaceWather started. driveNum=%d, criticalLevel=%d ", KVRDefaultDrive, criticalLevel );

    IRLOG_DEBUG( "CIRSystemEventCollector::ConstructL - Exiting" );
    }

// ---------------------------------------------------------------------------
// Two-phased constructor
// ---------------------------------------------------------------------------
//
EXPORT_C CIRSystemEventCollector* CIRSystemEventCollector::NewL()
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::NewL - Entering" );
    CIRSystemEventCollector* self = new( ELeave ) CIRSystemEventCollector;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop(self);
    IRLOG_DEBUG( "CIRSystemEventCollector::NewL - Exiting" );
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CIRSystemEventCollector::~CIRSystemEventCollector()
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::~CIRSystemEventCollector - Entering" );
    delete iSystemEventDetector;
    delete iHeadsetObserver;
    
    if( iDiskSpaceWatcher )
	    {
	    delete iDiskSpaceWatcher;
	    iDiskSpaceWatcher = NULL;
	    }

    iSystemEventObservers.Close();
    IRLOG_DEBUG( "CIRSystemEventCollector::~CIRSystemEventCollector - Exiting" );
    }

// ---------------------------------------------------------------------------
// Adds a system event observer
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRSystemEventCollector::AddObserverL( MIRSystemEventObserver* aHeadsetObserver )
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::AddObserverL - Entering" );
    iSystemEventObservers.AppendL( aHeadsetObserver );
    IRLOG_DEBUG( "CIRSystemEventCollector::AddObserverL - Exiting" );
    }

// ---------------------------------------------------------------------------
// Removes a system event observer
// ---------------------------------------------------------------------------
//
 EXPORT_C void CIRSystemEventCollector::RemoveObserver( MIRSystemEventObserver* aSystemObserver )
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::RemoveObserver - Entering" );
    TInt objectIndex = iSystemEventObservers.Find( aSystemObserver );
    
    if ( objectIndex != KErrNotFound )
        {
        iSystemEventObservers.Remove( objectIndex );
        }
    IRLOG_DEBUG( "CIRSystemEventCollector::RemoveObserver - Exiting" );
    }

// ---------------------------------------------------------------------------
// Getter for mobile network state
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CIRSystemEventCollector::IsMobileNetworkCoverage() const
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::IsMobileNetworkCoverage" );
    return iSystemEventDetector->IsMobileNetworkCoverage();
    }

// ---------------------------------------------------------------------------
// Getter for network state
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CIRSystemEventCollector::IsNetworkCoverage() const
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::IsNetworkCoverage" );
    return iSystemEventDetector->IsNetworkCoverage();
    }

// ---------------------------------------------------------------------------
// Getter for call state
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CIRSystemEventCollector::IsCallActive() const
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::IsCallActive" );
    return iSystemEventDetector->IsCallActive();
    }

// ---------------------------------------------------------------------------
// Getter for audio resource state
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CIRSystemEventCollector::IsAudioResourcesAvailable() const
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::IsAudioResourcesAvailable" );
    return iSystemEventDetector->IsAudioResourcesAvailable();
    }

// ---------------------------------------------------------------------------
// Getter for headset connection status
// ---------------------------------------------------------------------------
EXPORT_C TBool CIRSystemEventCollector::IsHeadsetConnected() const
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::IsHeadsetConnected" );
    return iHeadsetObserver->IsHeadsetConnected();
    }
    
// ---------------------------------------------------------------------------
// Getter disk space state
// ---------------------------------------------------------------------------
EXPORT_C TBool CIRSystemEventCollector::IsDiskSpaceBelowCriticalLevel() const
    {
    return iDiskSpaceWatcher->IsBelowCriticalLevel( KVRDefaultDrive );
    }

// ---------------------------------------------------------------------------
// Getter Vocie UI state
// ---------------------------------------------------------------------------
EXPORT_C TBool CIRSystemEventCollector::IsVoiceUiActive() const
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::IsVoiceUiActive" );
    return iSystemEventDetector->IsVoiceUiActive();
    }

// ---------------------------------------------------------------------------
// Notifies the observers of system event
// ---------------------------------------------------------------------------
//
void CIRSystemEventCollector::NotifyObserversL(TIRSystemEventType aEvent)
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::NotifyObserversL - Entering" );
    for (TInt i = 0 ; i < iSystemEventObservers.Count() ; i++ )
        {
        iSystemEventObservers[i]->HandleSystemEventL( aEvent );
        }
    IRLOG_DEBUG( "CIRSystemEventCollector::NotifyObserversL - Exiting" );
    }
    
// ---------------------------------------------------------------------------
// From class MIRSystemEventDetectorObserver.
// ---------------------------------------------------------------------------
//        
void CIRSystemEventCollector::NetworkUpCallbackL()
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::NetworkUpCallbackL - Entering" );
    NotifyObserversL( EIRNetworkCoverageUp );
    IRLOG_DEBUG( "CIRSystemEventCollector::NetworkUpCallbackL - Exiting" );
    }


// ---------------------------------------------------------------------------
// From class MIRSystemEventDetectorObserver.
// ---------------------------------------------------------------------------
//        
void CIRSystemEventCollector::NetworkDownCallbackL()
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::NetworkDownCallbackL - Entering" );
    NotifyObserversL( EIRNetworkCoverageDown );
    IRLOG_DEBUG( "CIRSystemEventCollector::NetworkDownCallbackL - Exiting" );
    }


// ---------------------------------------------------------------------------
// From class MIRSystemEventDetectorObserver.
// ---------------------------------------------------------------------------
//        
void CIRSystemEventCollector::CallActivatedCallbackL()
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::CallActivatedCallbackL - Entering" );
    NotifyObserversL( EIRCallActivated );
    IRLOG_DEBUG( "CIRSystemEventCollector::CallActivatedCallbackL - Exiting" );
    }


// ---------------------------------------------------------------------------
// From class MIRSystemEventDetectorObserver.
// ---------------------------------------------------------------------------
//        
void CIRSystemEventCollector::CallDeactivatedCallbackL()
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::CallDeactivatedCallbackL - Entering" );
    NotifyObserversL( EIRCallDeactivated );
    IRLOG_DEBUG( "CIRSystemEventCollector::CallDeactivatedCallbackL - Exiting" );
    }

    
// ---------------------------------------------------------------------------
// From class MIRSystemEventDetectorObserver.
// ---------------------------------------------------------------------------
//        
void CIRSystemEventCollector::AudioResourcesAvailableL()
    { 
    IRLOG_DEBUG( "CIRSystemEventCollector::AudioResourcesAvailableL - Entering" );
    NotifyObserversL( EIRAudioResourcesAvailable );
    IRLOG_DEBUG( "CIRSystemEventCollector::AudioResourcesAvailableL - Exiting" );
    }

    
// ---------------------------------------------------------------------------
// From class MIRSystemEventDetectorObserver.
// ---------------------------------------------------------------------------
//        
void CIRSystemEventCollector::AudioAutoResumeForbiddenL()
    {    
    IRLOG_DEBUG( "CIRSystemEventCollector::AudioAutoResumeForbiddenL - Entering" );
    NotifyObserversL( EIRAudioAutoResumeForbidden );
    IRLOG_DEBUG( "CIRSystemEventCollector::AudioAutoResumeForbiddenL - Exiting" );
    }
    
// ---------------------------------------------------------------------------
// From class MIRSystemEventDetectorObserver.
// ---------------------------------------------------------------------------
//        
void CIRSystemEventCollector::ErrorCallbackL( TInt /* aError VRDEBUGVAR( aError ) d*/)
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::ErrorCallbackL" );
    // P&S get fail not considered as a critical issue.
	return;
    }

// ---------------------------------------------------------------------------
// From class MIRHeadsetEventObserver.
// ---------------------------------------------------------------------------
//        
void CIRSystemEventCollector::HeadsetConnectedCallbackL()
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::HeadsetConnectedCallbackL - Entering" );
    NotifyObserversL( EIRHeadsetConnected );
    IRLOG_DEBUG( "CIRSystemEventCollector::HeadsetConnectedCallbackL - Exiting" );
    }


// ---------------------------------------------------------------------------
// From class MIRHeadsetEventObserver.
// ---------------------------------------------------------------------------
//        
void CIRSystemEventCollector::HeadsetDisconnectedCallbackL()
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::HeadsetDisconnectedCallbackL - Entering" );
    NotifyObserversL( EIRHeadsetDisconnected );
    IRLOG_DEBUG( "CIRSystemEventCollector::HeadsetDisconnectedCallbackL - Exiting" );
    }

// ---------------------------------------------------------------------------
// From class MIRDiskSpaceWatcherObserver.
// ---------------------------------------------------------------------------
//
void CIRSystemEventCollector::NotifyLowDiskSpaceL()
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::NotifyLowDiskSpaceL - Entering" );
    NotifyObserversL( EIRLowDiskSpace );
    IRLOG_DEBUG( "CIRSystemEventCollector::NotifyLowDiskSpaceL - Exiting" );
    }

// ---------------------------------------------------------------------------
// From class MIRAudioRoutingObserver.
// ---------------------------------------------------------------------------
//
void CIRSystemEventCollector::AudioRoutingChangedL( TVROutputDestination aOutputDestination )
    {
    IRLOG_DEBUG( "CIRSystemEventCollector::AudioRoutingChangedL - Entering" );
    TIRSystemEventType ev = EIRAudioRoutingHeadset; 
    if(aOutputDestination != EVRHeadset)
        {
        ev = EIRAudioRoutingSpeaker;
        }

    NotifyObserversL( ev );
    IRLOG_DEBUG( "CIRSystemEventCollector::AudioRoutingChangedL - Exiting" );
    }