/*
* Copyright (c) 2010 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 "cactivitymanager.h"
#include <f32file.h>
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "cactivitymanagerTraces.h"
#endif


// ---------------------------------------------------------------------------
// CActivityManager::NewL()
// ---------------------------------------------------------------------------
//
CActivityManager* CActivityManager::NewL(MActivityManagerObserver* aObserver, TInt aTimeout)
    {    
    OstTraceFunctionEntry0( CACTIVITYMANAGER_NEWL_ENTRY );
    CActivityManager* self = new (ELeave) CActivityManager(aObserver, aTimeout);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    OstTraceFunctionExit0( CACTIVITYMANAGER_NEWL_EXIT );
    return self;
    }
 
// ---------------------------------------------------------------------------
// CActivityManager::CActivityManager()
// ---------------------------------------------------------------------------
//
CActivityManager::CActivityManager(MActivityManagerObserver* aObserver, TInt aTimeout)
: CActive(CActive::EPriorityHigh), iObserver(aObserver), iTimeout(aTimeout), iPreviousStatus(KErrNotFound)
    {   
    OstTraceFunctionEntry0( CACTIVITYMANAGER_CACTIVITYMANAGER_ENTRY );
    CActiveScheduler::Add(this);
    OstTraceFunctionExit0( CACTIVITYMANAGER_CACTIVITYMANAGER_EXIT );
    }

// ---------------------------------------------------------------------------
// CActivityManager::~CActivityManager()
// ---------------------------------------------------------------------------
//
CActivityManager::~CActivityManager()
    {
    OstTraceFunctionEntry0( DUP1_CACTIVITYMANAGER_CACTIVITYMANAGER_ENTRY );
    
    iObserver = NULL;
    Cancel();
    
#ifdef MONITOR_LIGHTS
    delete iLight;
    iLight = NULL;
#endif

    iTimer.Cancel();
    iTimer.Close();
    OstTraceFunctionExit0( DUP1_CACTIVITYMANAGER_CACTIVITYMANAGER_EXIT );
    }
 
// ---------------------------------------------------------------------------
// CActivityManager::ConstructL()
// ---------------------------------------------------------------------------
//
void CActivityManager::ConstructL()
    {    
    iTimer.CreateLocal();
    iWatch = ENone;
    }

// ---------------------------------------------------------------------------
// CTMActivityManager::SetTimeout()
// ---------------------------------------------------------------------------
//
void CActivityManager::SetTimeout(TInt aTimeout)
    {    
    iTimeout = aTimeout;
    Reset();
    }

// ---------------------------------------------------------------------------
// CActivityManager::Reset()
// ---------------------------------------------------------------------------
//
void CActivityManager::Reset()
    {    
#ifdef MONITOR_LIGHTS
    delete iLight;
    iLight = NULL;
#endif
    
    Cancel();
    Start();
    }
 
// ---------------------------------------------------------------------------
// CActivityManager::DoCancel()
// ---------------------------------------------------------------------------
void CActivityManager::DoCancel()
    {
    
#ifdef MONITOR_LIGHTS
    delete iLight;
    iLight = NULL;
#endif
    
    iTimer.Cancel();
    iWatch = ENone;
    }

// ---------------------------------------------------------------------------
// CActivityManager::Start()
// ---------------------------------------------------------------------------
//
void CActivityManager::Start()
    {
    OstTraceFunctionEntry0( CACTIVITYMANAGER_START_ENTRY );
    
#ifdef MONITOR_LIGHTS
    if(!iLight)
        {
        TRAP_IGNORE(iLight = CHWRMLight::NewL(this));
        }
#endif
    
    if ( iWatch == ENone )
        {
        iFirstRound = ETrue;
        
        if( !IsActive() )
            {
            SetActive();
            TRequestStatus* statusPtr = &iStatus;
            User::RequestComplete( statusPtr, KErrNone );
            }
        }
    OstTraceFunctionExit0( CACTIVITYMANAGER_START_EXIT );
    }

// ---------------------------------------------------------------------------
// CActivityManager::RunL()
// ---------------------------------------------------------------------------
//
void CActivityManager::RunL()
    {    
    OstTraceFunctionEntry0( CACTIVITYMANAGER_RUNL_ENTRY );
    if(iFirstRound)
        {        
        iFirstRound = EFalse;
        if (!IsActive())
             {
             iWatch = EWaitingForInactivity;
             iTimer.Inactivity(iStatus, iTimeout);
             SetActive();
             }
        NotifyObserver();
        OstTraceFunctionExit0( CACTIVITYMANAGER_RUNL_EXIT );
        return;
        }
    
    if (iStatus == KErrNone)
        {
        if (iWatch == EWaitingForInactivity)
            {
            TInt inactivity = User::InactivityTime().Int();
            if (inactivity >= iTimeout)
                {                
                NotifyObserver();

                if (!IsActive()) //observer might have called a Reset()
                    {
                    iTimer.Inactivity(iStatus,0);
                    iWatch = EWaitingForActivity;
                    }
                }
            else
                {
                iTimer.Inactivity(iStatus,iTimeout);
                }
            }
        else if (iWatch == EWaitingForActivity)
            {            
            NotifyObserver();
             
            if (!IsActive()) //observer might have called a Reset()
                {
                iTimer.Inactivity(iStatus,iTimeout);
                iWatch = EWaitingForInactivity;
                }
            }
    
        if (!IsActive()) //observer might have called a Reset()
            {
            SetActive();
            }
        }
    else
        {
        iWatch = ENone;
        }      
    OstTraceFunctionExit0( DUP1_CACTIVITYMANAGER_RUNL_EXIT );
    }

// ---------------------------------------------------------------------------
// CActivityManager::RunError()
// ---------------------------------------------------------------------------
//
TInt CActivityManager::RunError(TInt aError)
    {    
    OstTraceFunctionEntry0( CACTIVITYMANAGER_RUNERROR_ENTRY );
    if (aError != KErrNone)
        {
        Reset();
        }
    
    // nothing to do
    OstTraceFunctionExit0( CACTIVITYMANAGER_RUNERROR_EXIT );
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// IsInactive()
// -----------------------------------------------------------------------------
//
TBool CActivityManager::IsInactive()
    {
    OstTraceFunctionEntry0( CACTIVITYMANAGER_ISINACTIVE_ENTRY );
    
#ifdef MONITOR_LIGHTS
#ifdef _DEBUG
TInt inactivityTime = User::InactivityTime().Int();
#endif
#else
TInt inactivityTime = User::InactivityTime().Int();
#endif

    //if lights are off or inactivity timer is less that target the device is not idle
    if( User::InactivityTime() >= TTimeIntervalSeconds(iTimeout)
#ifdef MONITOR_LIGHTS
            || !iLights
#endif
            )
      {      
      OstTraceFunctionExit0( CACTIVITYMANAGER_ISINACTIVE_EXIT );
      return ETrue;
      }    
    OstTraceFunctionExit0( DUP1_CACTIVITYMANAGER_ISINACTIVE_EXIT );
    return EFalse;
    }

#ifdef MONITOR_LIGHTS
// -----------------------------------------------------------------------------
// LightStatusChanged()
// -----------------------------------------------------------------------------
//
void CActivityManager::LightStatusChanged(TInt aTarget, CHWRMLight::TLightStatus aStatus)
    {    
    if(aTarget & CHWRMLight::EPrimaryDisplay)
        {
         if( aStatus == CHWRMLight::ELightOff )
            {
            iLights = EFalse;
            }
        else
            {
            iLights = ETrue;
            }
     
        NotifyObserver();
        }
    }
#endif

// -----------------------------------------------------------------------------
// NotifyObserver()
// -----------------------------------------------------------------------------
//
void CActivityManager::NotifyObserver()
    {    
    OstTraceFunctionEntry0( CACTIVITYMANAGER_NOTIFYOBSERVER_ENTRY );
    TBool status = IsInactive();
    OstTrace1( TRACE_NORMAL, CACTIVITYMANAGER_NOTIFYOBSERVER, "CActivityManager::NotifyObserver;status=%d", status );
    
    if( iPreviousStatus != status )
        {
        iPreviousStatus = status; 
        if (iObserver)
            {
            iObserver->ActivityChanged(status);
            }
        }    
    OstTraceFunctionExit0( CACTIVITYMANAGER_NOTIFYOBSERVER_EXIT );
    }