/*

* Copyright (c) 2002 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 <aknappui.h>

#include <activitymanager.h>

#include <bldvariant.hrh>

#include <featmgr.h>

#include <AknNotifierController.h>

#include <featmgr.h>

#include <ctsydomainpskeys.h>

#include <SCPClient.h>

#include "AutoLockCenRepI.h"

const TInt AutoLockOff(60000);

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

//

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

// CAutoLockModel::NewL()

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

//

CAutoLockModel* CAutoLockModel::NewL(CAutolockAppUi* aAppUi, TBool aLocked)

//

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

// CAutoLockModel::CAutoLockModel()

// C++ default constructor

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

// 

CAutoLockModel::CAutoLockModel(CAutolockAppUi* aAppUi) : 

//

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

// CAutoLockModel::ConstructL()

// Symbian OS default constructor

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

//

void CAutoLockModel::ConstructL( TBool aLocked )

    RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::ConstructL() BEGIN"));

    iCenRepI = CAutolockCenRepI::NewL(iAppUi);

    // In GSM the device is always unlocked.

    // In CDMA, SecClientUi will lock the device on boot-up if needed.

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::ConstructL() END"));

    #endif

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

// CAutoLockModel::StartActivityMonitoringL()

// Start monitoring user activity

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

//

void CAutoLockModel::StartActivityMonitoringL()

//

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

// CAutoLockModel::StopActivityMonitoring()

// Stop monitoring user activity

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

//

void CAutoLockModel::StopActivityMonitoring()

//

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

// CAutoLockModel::SetActivityManagerL()

// Initializes activymanager   

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

//

void CAutoLockModel::SetActivityManagerL()

//

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

// CAutoLockModel::CancelActivityManager()

// UnInitializes activymanager   

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

//

void CAutoLockModel::CancelActivityManager()

    if ( iActivityManager )

        {

        }

//

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

// CAutoLockModel::~CAutoLockModel()

// Destructor   

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

//

CAutoLockModel::~CAutoLockModel()

    delete iCenRepI;

    // close custom phone

//

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

// CAutoLockModel::AutoLockTimeout()

// Returns current autolock period

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

//

TInt CAutoLockModel::AutoLockTimeout()

    return iCenRepI->Timeout();

//

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

// CAutoLockModel::ResetInactivityTimeoutL()

// Gets autolock period and starts monitoring user activity 

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

//

void CAutoLockModel::ResetInactivityTimeout()

//

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

// CAutoLockModel::HandleActiveEventL()

// Handles Active event. Called by ActivityManager

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

//

TInt CAutoLockModel::HandleActiveEventL(TAny* /*aPtr*/)

//

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

// CAutoLockModel::HandleInactiveEventL()

// Handles InActive event. Called by ActivityManager

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

//

TInt CAutoLockModel::HandleInactiveEventL(TAny* aPtr)

//

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

// CAutoLockModel::LockSystemL()

// Locks system

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

//

void CAutoLockModel::LockSystemL(TInt aAutolockState)

    RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() BEGIN"));

    #endif

    // If already locked, do nothing. Otherwise we'll end up

    // on top of Screensaver

    // Check if iSideKey2 is zero or not (locked if nonzero)

    // Also, phone should not be locked if PUK1 code query is up.

    if (iAppUi->Locked() || iAppUi->IsPinBlocked())

        {

        return;

        }

    //Check which state we are in to see if it's OK to lock the phone

    //In CDMA when there is no SIM (RUIM) support we should be able to lock

    //the phone after reboot. In this case ESWStateNormal is too late to lock the phone

    //and other states below are needed.

    TBool okToLock = EFalse;

    TInt sysState = 0;

    iProperty.Get(KPSUidStartup, KPSGlobalSystemState, sysState);    

    //If NOT in CDMA the Autolock should come up only after the phone has booted up.

    if ( FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) || iAppUi->HiddenReset())

        {

        if( (sysState == ESwStateNormalRfOn       ||

            sysState == ESwStateNormalRfOff       ||

             sysState == ESwStateCriticalPhaseOK) &&

            {

            #if defined(_DEBUG)

            RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() LOCKED AFTER HIDDEN RESET"));

            #endif

            okToLock = ETrue;

            }

        }

    else //Feature Manager

        {

        if( (sysState == ESwStateNormalRfOn       ||

             sysState == ESwStateNormalRfOff)      &&

            (aAutolockState > EAutolockOff) ) // EMKK-7N3G7R

            {

            okToLock = ETrue;

            }

        }

if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ))    

{

    // Get the TARM admin flag value

    if ( tRet != KErrNone )

        {

        #if defined(_DEBUG)

        RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL():\

            Warning: failed to get TARM Admin Flag state"));

        #endif

        }

    else

        {

        #if defined(_DEBUG)

        RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL(): TARM flag: %d"),

            tarmFlag );

        #endif

        }

}

    iProperty.Get(KPSUidCtsyCallInformation, KCTsyCallState, callState);

TBool isConditionSatisfied = EFalse;

if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ))

{        

    if ( ( callState != EPSCTsyCallStateNone ) && (!( tarmFlag & KSCPFlagAdminLock )) )    

}

else

{

    if ( callState != EPSCTsyCallStateNone )

}

        {

        TBool remoteLocked(EFalse);

        #ifdef RD_REMOTELOCK

        remoteLocked = (aAutolockState == ERemoteLocked);

        #endif //RD_REMOTELOCK

         if(remoteLocked) 

         {

            #if defined(_DEBUG)

            RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() REMOTE LOCKED"));

            #endif

            okToLock = ETrue;

         }

         else

            okToLock = EFalse;        

        }

    if (!iAppUi->IsForeground() && okToLock)

        {

        #if defined(_DEBUG)

        RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() LOCK PHONE"));

        #endif   

                RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() Timer/Remote locked: %d"), aAutolockState);

                #endif

                 RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() HIDDEN RESET LOCK"));

                 #endif

         // Reset inactivity time so that Screensaver gets to

        // run again after its timeout. We'll ignore the new

        // inactivity timeout, if already locked

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() END"));

    #endif

} 

//

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

// CAutoLockModel::SetLocked

// Sets lockvalue in Publish & Subscribe and Central Repository

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

//

void CAutoLockModel::SetLockedL(TInt aAutolockState)

    RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::SetLockedL() begin"));

    #endif

        iProperty.Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, aAutolockState);

        #if defined(_DEBUG)

        RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::SetLockedL() LOCK"));

        #endif

  else

        iProperty.Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff);

        #if defined(_DEBUG)

        RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::SetLockedL() UNLOCK"));         

        #endif

    }

    iCenRepI->SetLockedL(locked);

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::SetLockedL() end"));

    #endif

// END OF FILE