/*

* Copyright (c) 2009-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:

* Implementation of CSsmInitPsKeys class.

*

*/

#include "ssminitpskeys.h"

#include "ssmmapperutility.h"

#include "ssmmapperutilityinternalpskeys.h"

#include "ssmcustcmdsprivatepskeys.h"

#include "trace.h"

#include <ssm/startupdomainpskeys.h>

#include <ssm/starterdomaincrkeys.h>

#include <ssm/ssmrefcustomcmdcommon.h>

_LIT_SECURITY_POLICY_C1( KReadDeviceDataPolicy, ECapabilityReadDeviceData );

_LIT_SECURITY_POLICY_C1( KWriteDeviceDataPolicy, ECapabilityWriteDeviceData );

_LIT_SECURITY_POLICY_C1( KPowerMgmtPolicy, ECapabilityPowerMgmt );

_LIT_SECURITY_POLICY_PASS( KAlwaysPassPolicy );

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

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

// CSsmInitPsKeys::NewL

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

//

CSsmInitPsKeys* CSsmInitPsKeys::NewL()

	{

    FUNC_LOG;

    return new ( ELeave ) CSsmInitPsKeys();

	}

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

// CSsmInitPsKeys::~CSsmInitPsKeys

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

//

CSsmInitPsKeys::~CSsmInitPsKeys()

    {

    FUNC_LOG;

    }

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

// CSsmInitPsKeys::Initialize

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

//

TInt CSsmInitPsKeys::Initialize( CSsmCustomCommandEnv* /*aCmdEnv*/ )

    {

    FUNC_LOG;

    return KErrNone;

    }

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

// CSsmInitPsKeys::Execute

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

//

void CSsmInitPsKeys::Execute(

    const TDesC8& /*aParams*/,

    TRequestStatus& aRequest )

    {

    FUNC_LOG;

    aRequest = KRequestPending;

    TRAPD( errorCode, InitializeKeysL() );

    ERROR( errorCode, "Failed to initialize P&S keys" );

    TRequestStatus* request = &aRequest;

    User::RequestComplete( request, errorCode );

    }

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

// CSsmInitPsKeys::ExecuteCancel

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

//

void CSsmInitPsKeys::ExecuteCancel()

    {

    FUNC_LOG;

    // Nothing to do.

    }

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

// CSsmInitPsKeys::Close

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

//

void CSsmInitPsKeys::Close()

    {

    FUNC_LOG;

    /**

    * Close resources initialized in the previous call to Initialize.

    */

    }

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

// CSsmInitPsKeys::Release

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

//

void CSsmInitPsKeys::Release()

    {

    FUNC_LOG;

	delete this;

    }

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

// CSsmInitPsKeys::InitializeKeysL

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

//

void CSsmInitPsKeys::InitializeKeysL()

    {

    FUNC_LOG;

// Startup Security Status API

    INFO( "KPSUidStartup::KStartupSimSecurityStatus" );

    DefineL( KPSUidStartup,

             KStartupSimSecurityStatus,

             KReadDeviceDataPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSUidStartup,

          KStartupSimSecurityStatus,

          ESimSecurityStatusUninitialized );

    INFO( "KPSUidStartup::KStartupSimLockStatus" );

    DefineL( KPSUidStartup,

             KStartupSimLockStatus,

             KReadDeviceDataPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSUidStartup,

          KStartupSimLockStatus,

          ESimLockStatusUninitialized );

    INFO( "KPSUidStartup::KStartupSecurityCodeStatus" );

    DefineL( KPSUidStartup,

             KStartupSecurityCodeStatus,

             KReadDeviceDataPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSUidStartup,

          KStartupSecurityCodeStatus,

          ESecurityCodeStatusUninitialized );

    INFO( "KPSUidStartup::KStartupSecurityCodeQueryStatus" );

    DefineL( KPSUidStartup,

             KStartupSecurityCodeQueryStatus,

             KReadDeviceDataPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSUidStartup,

          KStartupSecurityCodeQueryStatus,

          ESecurityQueryUninitialized );

// System Application Startup API

    INFO( "KPSUidStartup::KStartupBootIntoOffline" );

    DefineL( KPSUidStartup,

             KStartupBootIntoOffline,

             KReadDeviceDataPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSUidStartup,

          KStartupBootIntoOffline,

          EBootIntoOnlineModeUninitialized );

    INFO( "KPSUidStartup::KStartupCleanBoot" );

    DefineL( KPSUidStartup,

             KStartupCleanBoot,

             KReadDeviceDataPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSUidStartup, KStartupCleanBoot, EStartupCleanBootUninitialized );

// SIM Utils API

    INFO( "KPSUidStartup::KPSSimStatus" );

    DefineL( KPSUidStartup,

             KPSSimStatus,

             KReadDeviceDataPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSUidStartup, KPSSimStatus, ESimStatusUninitialized );

    INFO( "KPSUidStartup::KPSSimOwned" );

    DefineL( KPSUidStartup,

             KPSSimOwned,

             KReadDeviceDataPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSUidStartup, KPSSimOwned, ESimOwnedUninitialized );

    INFO( "KPSUidStartup::KPSSimChanged" );

    DefineL( KPSUidStartup,

             KPSSimChanged,

             KReadDeviceDataPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSUidStartup, KPSSimChanged, ESimChangedUninitialized );

// System State API

    INFO( "KPSUidStartup::KPSGlobalSystemState" );

    DefineL( KPSUidStartup,

             KPSGlobalSystemState,

             KAlwaysPassPolicy,

             KPowerMgmtPolicy );

    INFO( "KPSUidStartup::KPSGlobalStartupMode" );

    DefineL( KPSUidStartup,

             KPSGlobalStartupMode,

             KAlwaysPassPolicy,

             KPowerMgmtPolicy );

    INFO( "KPSUidStartup::KPSIdlePhase1Ok" );

    DefineL( KPSUidStartup,

             KPSIdlePhase1Ok,

             KAlwaysPassPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSUidStartup, KPSIdlePhase1Ok, EIdlePhase1NOK );

    INFO( "KPSUidStartup::KPSPhonePhase1Ok" );

    DefineL( KPSUidStartup,

             KPSPhonePhase1Ok,

             KAlwaysPassPolicy,

             KPowerMgmtPolicy );

    SetL( KPSUidStartup, KPSPhonePhase1Ok, EPhonePhase1NOK );

    INFO( "KPSUidStartup::KPSStartupReason" );

    DefineL( KPSUidStartup,

             KPSStartupReason,

             KAlwaysPassPolicy,

             KPowerMgmtPolicy );

// Wakeup Alarm API

    INFO( "KPSUidStartup::KPSWakeupAlarmStatus" );

    DefineL( KPSUidStartup,

             KPSWakeupAlarmStatus,

             KAlwaysPassPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSUidStartup, KPSWakeupAlarmStatus, EWakeupAlarmUninitialized );

    // Startup Security Phase API

    INFO( "KPSStarterUid::KStarterSecurityPhase" );

    DefineL( KPSStarterUid,

             KStarterSecurityPhase,

             KAlwaysPassPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSStarterUid, KStarterSecurityPhase, EStarterSecurityPhaseUninitialized );

// Disk Reserver API

    INFO( "KPSStarterUid::KDiskReserveKey" );

    DefineL( KPSStarterUid,

             KDiskReserveKey,

             KReadDeviceDataPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSStarterUid, KDiskReserveKey, 0 );

// RTC validation API

    INFO( "KPSStarterUid::KRTCPropertyKey" );

    DefineL( KPSStarterUid,

             KRTCPropertyKey,

             KReadDeviceDataPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSStarterUid, KRTCPropertyKey, 0 );

    INFO( "KPSUidStartup::KIgnoreSecurityEvent" );

    DefineL( KPSUidStartup,

             KIgnoreSecurityEvent,

             KReadDeviceDataPolicy,

             KWriteDeviceDataPolicy );

    SetL( KPSUidStartup,

          KIgnoreSecurityEvent,

          EPSIgnoreSecurityEventUninitialized );

// Store FirstBoot Value from cenrep

TInt csVal( 0 );

TInt psVal( 0 );

    CSsmMapperUtility& util = MapperUtilityL(); 

    User::LeaveIfError( util.CrValue( KCRUidStartup, 

                                      KStartupFirstBoot,

                                      csVal ) );

    INFO( "KPSUidStartup::KPSStartupFirstBoot" );

    psVal = ( csVal == EStartupIsFirstBoot )? EPSStartupFirstBoot : EPSStartupNotFirstBoot;

    DefineL( KPSUidStartup,

             KPSStartupFirstBoot,

             KAlwaysPassPolicy,

             KWriteDeviceDataPolicy );

    SetL(  KPSUidStartup, KPSStartupFirstBoot, psVal );

    }