/*
* Copyright (c) 2000 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: Observer for Set System Locked event
*/
#include    <bldvariant.hrh>
#include    <e32property.h>
#include	<PSVariables.h>
#include	<coreapplicationuisdomainpskeys.h>
#include <ctsydomainpskeys.h>
//#include    <SecurityUIsPrivatePSKeys.h>
#include "secui.hrh"
#include "SCPLockObserver.h"
#include "SCPQueryDialog.h"
#include "SCPDebug.h"

// ================= MEMBER FUNCTIONS =======================
//
// ----------------------------------------------------------
// CSCPLockObserver::NewL()
// Constructs a new entry with given values.
// ----------------------------------------------------------
//
CSCPLockObserver* CSCPLockObserver::NewL(CSCPQueryDialog* aDialog, TInt aType)
    {
    
    Dprint(_L("CSCPLockObserver::NewL() BEGIN"));
    
    CSCPLockObserver* self = new (ELeave) CSCPLockObserver(aDialog, aType);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();
    
    Dprint(_L("CSCPLockObserver::NewL() END"));
    
    return self;
    }
//
// ----------------------------------------------------------
// CSCPLockObserver::CSCPLockObserver()
// Destructor
// ----------------------------------------------------------
//
CSCPLockObserver::~CSCPLockObserver()
    {
    
    Dprint(_L("CSCPLockObserver::~CSCPLockObserver >>>"));
    Cancel();
    Dprint(_L("CSCPLockObserver::~CSCPLockObserver <<<"));
    }
//
// ----------------------------------------------------------
// CSCPLockObserver::Start()
// Starts listening an event 
// ----------------------------------------------------------
//
TInt CSCPLockObserver::Start()
    {
    
    Dprint(_L("CSCPLockObserver::Start() BEGIN"));
    
    if (IsActive())
    {
    
    Dprint(_L("CSCPLockObserver::Start() In use!!!"));
    
    return KErrInUse;
    }
        
    iStatus = KRequestPending;
    
    switch(iType) {
        case ESecUiDeviceLockObserver:
            
            Dprint(_L("CSCPLockObserver::Start() Device Lock Observer"));
            
            iProperty.Attach(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus); 
            break;
        case ESecUiCallStateObserver: {
            Dprint(_L("CSCPLockObserver::Start() Call State Observer"));                
            iProperty.Attach(KPSUidCtsyCallInformation, KCTsyCallState);
        }
        break;

        default:
            break;
    }
    
    iProperty.Subscribe(iStatus);
    iSubscribedToEvent = ETrue;
    SetActive();
    Dprint(_L("CSCPLockObserver::Start() END"));    
    return KErrNone;
    }
//
// ----------------------------------------------------------
// CLockObserver::CLockObserver()
// C++ constructor
// ----------------------------------------------------------
// 
CSCPLockObserver :: CSCPLockObserver(CSCPQueryDialog* aDialog, TInt aType) : CActive(0),
        iDialog(aDialog), iType(aType), 
        iInformCallEnding(EFalse), iSubscribedToEvent(EFalse) {
    
    TInt lStatus;
    RProperty :: Get(KPSUidCtsyCallInformation, KCTsyCallState, lStatus);
    
    switch(lStatus) {
        default:
        case EPSCTsyCallStateUninitialized:
        case EPSCTsyCallStateNone:
            iInformCallEnding = EFalse;
            break;
        case EPSCTsyCallStateDisconnecting:
        case EPSCTsyCallStateAlerting:
        case EPSCTsyCallStateHold:
        case EPSCTsyCallStateRinging:
        case EPSCTsyCallStateDialling:
        case EPSCTsyCallStateAnswering:
        case EPSCTsyCallStateConnected:
            iInformCallEnding = ETrue;
            break;
    };
}
//
// ----------------------------------------------------------
// CSCPLockObserver::ConstructL()
// Symbian OS default constructor
// ----------------------------------------------------------
// 
void CSCPLockObserver::ConstructL()
    {
    
    Dprint(_L("CSCPLockObserver::ConstructL() BEGIN"));
    
    // Add this active object to the scheduler.
	CActiveScheduler::Add(this);
	// Begin obsering PubSub event  
	Start();
	
    Dprint(_L("CSCPLockObserver::ConstructL() END"));
    	
    }
//
// ----------------------------------------------------------
// CSCPLockObserver::RunL()
// Called by Active Scheduler
// ----------------------------------------------------------
// 
void CSCPLockObserver :: RunL() {
    Dprint(_L("[CSCPLockObserver]-> RunL() >>>"));
    
    switch(iType) {
        case ESecUiDeviceLockObserver:
        TInt autolockState;
        iProperty.Get(autolockState);
        
        if(autolockState > EAutolockOff) {            
            Dprint(_L("CSCPLockObserver::RunL() TryCancelQueryL Device Lock"));
            iDialog->TryCancelQueryL(ESecUiDeviceLocked);
            iSubscribedToEvent = EFalse;
        }
        break;
        case ESecUiCallStateObserver: {
            TInt callState;
            iProperty.Get(callState);
            Dprint( (_L("CSCPLockObserver::RunL() callState before Start() : %d"), callState ));
            Start();
            
            switch(callState) {
                default:
                    break;
                case EPSCTsyCallStateNone:
                    if(iInformCallEnding) {
                        Dprint( (_L("CSCPLockObserver::RunL() Branched to EPSCTsyCallStateNone")));
                        iDialog->TryCancelQueryL(EEnded);                    
                        iInformCallEnding = EFalse;
                    }
                    break;
                case EPSCTsyCallStateAlerting:
                case EPSCTsyCallStateHold:
                case EPSCTsyCallStateRinging:
                case EPSCTsyCallStateDialling:
                case EPSCTsyCallStateAnswering:
                case EPSCTsyCallStateConnected: {
                        Dprint(_L("CSCPLockObserver::RunL() TryCancelQueryL Active Call"));                
                        TRAPD(lErr, iDialog->TryCancelQueryL(EInProgress));
                        Dprint( (_L("CSCPLockObserver::RunL() lErr : %d"), lErr ));                        
                        iInformCallEnding = ETrue;
                }
                break;
            };
        }
        break;
        default:
            break;
    }
    
    Dprint(_L("[CSCPLockObserver]-> RunL() <<<"));    
}

// ----------------------------------------------------------------------------
// CSCPLockObserver::RunError
// ----------------------------------------------------------------------------
TInt CSCPLockObserver::RunError ( TInt /*aError*/ )
    {
        return KErrNone;
    }	
    
   
//
// ----------------------------------------------------------
// CSCPLockObserver::DoCancel()
// Cancels event listening
// ----------------------------------------------------------
// 
void CSCPLockObserver::DoCancel()
    {
    
    Dprint(_L("CSCPLockObserver::DoCancel() BEGIN"));
    
    if(iSubscribedToEvent)
        iProperty.Cancel();
    
    iStatus = KErrNone;
    
    Dprint(_L("CSCPLockObserver::DoCancel() END"));
    
    }
//
// ----------------------------------------------------------
// CSCPLockObserver::StopObserver()
// Cancels event listening
// ----------------------------------------------------------
//     
void CSCPLockObserver::StopObserver()
	{
	
    Dprint(_L("CSCPLockObserver::StopObserver() BEGIN"));
    
    Cancel();
    
    Dprint(_L("CSCPLockObserver::StopObserver() END"));
    
    }
//
// ----------------------------------------------------------
// CSCPLockObserver::StartObserver()
// Start event listening
// ----------------------------------------------------------
//     
void CSCPLockObserver::StartObserver()
	{
	
    Dprint(_L("CSCPLockObserver::StartObserver() BEGIN"));
    
    Start();
    
    Dprint(_L("CSCPLockObserver::StartObserver() END"));
    
    }
//
// ----------------------------------------------------------
// CSCPLockObserver::SetAddress()
// Start event listening
// ----------------------------------------------------------
//  
void CSCPLockObserver::SetAddress(CSCPQueryDialog* aDialog)
{
	
    Dprint(_L("CSCPLockObserver::SetAddress() BEGIN"));
    
	iDialog = aDialog;
	
    Dprint(_L("CSCPLockObserver::SetAddress() END"));
    
}
// End of file