/*
* 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 CSsmUiSpecific class.
*
*/

#include <ctsydomainpskeys.h>
#include <f32file.h>
#include <mmtsy_names.h>
#include <pathinfo.h>
#include <securitynotification.h>
#include <ssm/ssmstate.h>
#include <startupdomainpskeys.h>

#include "ssmuispecific.h"
#include "ssmmapperutilitystatic.h"
#include "ssmmapperutilityinternalpskeys.h"
#include "ssmsubstateext.hrh"
#include "ssmswp.hrh"
#include "trace.h"

/** Channel used to communicate with Security Notifier. */
static const TUid KSecurityNotifierChannel = { 0x1000598F };

// Type definitions for a buffer containing a drive id (drive letter + :).
const TInt KDriveIdLength = 2;
//Number of clusterSize to be reserve for phone memory space 
const TInt KNumberOfCluster = 2;
typedef TBuf<KDriveIdLength> TDriveId;

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

// ---------------------------------------------------------------------------
// CSsmUiSpecific::~CSsmUiSpecific
// ---------------------------------------------------------------------------
//
EXPORT_C CSsmUiSpecific::~CSsmUiSpecific()
	{
    FUNC_LOG;
    iReservedPhoneMemoryFs.Close();
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::InstanceL
// ---------------------------------------------------------------------------
//
EXPORT_C CSsmUiSpecific* CSsmUiSpecific::InstanceL()
	{
    FUNC_LOG;

	CSsmUiSpecific* self( NULL );
	if ( Dll::Tls() )
		{
		self = static_cast<CSsmUiSpecific*>( Dll::Tls() );
		self->iReferenceCount++;
		}
	else
		{
		self = new ( ELeave ) CSsmUiSpecific;
		CleanupStack::PushL( self );
		self->ConstructL();
		User::LeaveIfError( Dll::SetTls( self ) );
		CleanupStack::Pop( self );
		}

	return self;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::Release
// ---------------------------------------------------------------------------
//
EXPORT_C void CSsmUiSpecific::Release()
	{
    FUNC_LOG;

    TAny* tlsPtr = Dll::Tls();
	ASSERT_TRACE( tlsPtr );

    CSsmUiSpecific* self = static_cast<CSsmUiSpecific*>( tlsPtr );
    if ( --self->iReferenceCount == 0 )
        {
        Dll::FreeTls();
        delete self;
        }
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::StartupPSUid
// ---------------------------------------------------------------------------
//
EXPORT_C TUid CSsmUiSpecific::StartupPSUid()
	{
    FUNC_LOG;

	return KPSUidStartup;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::StarterPSUid
// ---------------------------------------------------------------------------
//
EXPORT_C TUid CSsmUiSpecific::StarterPSUid()
	{
    FUNC_LOG;

	return KPSStarterUid;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::EmergencyCallPropertyCategory
// ---------------------------------------------------------------------------
//
EXPORT_C TUid CSsmUiSpecific::EmergencyCallPropertyCategory()
	{
    FUNC_LOG;

	return KPSUidCtsyCallInformation;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::SecurityPinNotifierUid
// ---------------------------------------------------------------------------
//
EXPORT_C TUid CSsmUiSpecific::SecurityPinNotifierUid()
	{
    FUNC_LOG;

	return KSecurityNotifierUid;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::ScreenOutputChannelUid
// ---------------------------------------------------------------------------
//
EXPORT_C TUid CSsmUiSpecific::ScreenOutputChannelUid()
	{
    FUNC_LOG;

	return KSecurityNotifierChannel;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::RFStatusPropertyCategory
// ---------------------------------------------------------------------------
//
EXPORT_C TUid CSsmUiSpecific::RFStatusPropertyCategory()
    {
    FUNC_LOG;

	return TUid::Uid( SWP_UID_SSM_RF_STATUS );
    }


// ---------------------------------------------------------------------------
// CSsmUiSpecific::EmergencyCallPropertyKey
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CSsmUiSpecific::EmergencyCallPropertyKey()
	{
    FUNC_LOG;

	return KCTsyCallState;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::SimStatusPropertyKey
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CSsmUiSpecific::SimStatusPropertyKey()
	{
    FUNC_LOG;

	return KPSSimStatus;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::RFStatusPropertyKey
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CSsmUiSpecific::RFStatusPropertyKey()
    {
    FUNC_LOG;

	return SWP_UID_SSM_RF_STATUS;
    }


// ---------------------------------------------------------------------------
// CSsmUiSpecific::GetTsyModuleNameL
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC* CSsmUiSpecific::GetTsyModuleNameL()
	{
    FUNC_LOG;

    /*****************************************************
    *   Series 60 Customer / TSY
    *   Needs customer TSY implementation
    *****************************************************/

	HBufC* name = KMmTsyModuleName().AllocL();
    INFO_1( "TSY name: %S", name );
	return name;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::PhoneTsyNameL
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC* CSsmUiSpecific::PhoneTsyNameL()
	{
    FUNC_LOG;

    /*****************************************************
    *   Series 60 Customer / TSY
    *   Needs customer TSY implementation
    *****************************************************/

	HBufC* name = KMmTsyPhoneName().AllocL();
    INFO_1( "Phone name: %S", name );
	return name;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::SetSecurityStatus
// ---------------------------------------------------------------------------
//
EXPORT_C void CSsmUiSpecific::SetSecurityStatus(
    const TStrtSecurityStatus& aSecurityStatus )
	{
    FUNC_LOG;

	iStrtSecurityStatus = aSecurityStatus;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::SecurityStatus
// ---------------------------------------------------------------------------
//
EXPORT_C TStrtSecurityStatus CSsmUiSpecific::SecurityStatus() const
	{
    FUNC_LOG;

	return iStrtSecurityStatus;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::IsAmaStarterSupported
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CSsmUiSpecific::IsAmaStarterSupported()
	{
    FUNC_LOG;

	return SsmMapperUtility::FeatureStatus( TUid::Uid( KFeatureIdExtendedStartup ) );
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::IsSimSupported
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CSsmUiSpecific::IsSimSupported()
	{
    FUNC_LOG;

    return SsmMapperUtility::FeatureStatus( TUid::Uid( KFeatureIdSimCard ) );
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::IsSimlessOfflineSupported
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CSsmUiSpecific::IsSimlessOfflineSupported()
	{
    FUNC_LOG;

    return SsmMapperUtility::FeatureStatus(
        TUid::Uid( KFeatureIdFfSimlessOfflineSupport ) );
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::IsSimPresent
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CSsmUiSpecific::IsSimPresent()
	{
    FUNC_LOG;

    TInt value( 0 );
    TInt err = RProperty::Get( SsmMapperUtility::PsUid( KPSUidStartup ), KPSSimStatus, value );
    ERROR( err, "Failed to get value of KPSUidStartup::KPSSimStatus" );
    return ( err == KErrNone &&
             ( value == ESimUsable ||
               value == ESimReadable ||
               value == ESimNotReady ) );
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::IsSimStateChangeAllowed
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CSsmUiSpecific::IsSimStateChangeAllowed()
	{
    FUNC_LOG;

    TSsmState state;
    TInt err = SsmMapperUtility::GetCurrentState( state );
    ERROR( err, "Failed to get current state" );
    return ( err == KErrNone &&
             ( state.MainState() == ESsmStartup && state.SubState() == ESsmStateSecurityCheck ) ||
             ( state.MainState() == ESsmStartup && state.SubState() == ESsmStateNonCritical ) ||
               state.MainState() == ESsmNormal );
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::IsNormalBoot
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CSsmUiSpecific::IsNormalBoot()
	{
    FUNC_LOG;

    TInt value( 0 );
    TInt errorCode = RProperty::Get( SsmMapperUtility::PsUid( KPSUidStartup ), KPSStartupReason, value );
    ERROR( errorCode, "Failed to get value of KPSUidStartup::KPSStartupReason" );

    TBool ret = ( errorCode == KErrNone && value == ENormalStartup );
    INFO_1( "Is normal boot = %d", ret );
    return ret;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::IsSimChangedReset
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CSsmUiSpecific::IsSimChangedReset()
	{
    FUNC_LOG;

    TUid startupPsUid( SsmMapperUtility::PsUid( KPSUidStartup ) );
    TInt value( 0 );
    TInt errorCode = RProperty::Get( startupPsUid, KPSStartupReason, value );
    ERROR( errorCode, "Failed to get value of KPSUidStartup::KPSStartupReason" );

    TBool ret( EFalse );
	if ( errorCode == KErrNone && value == ESIMStatusChangeReset )
        {
	    errorCode = RProperty::Get( startupPsUid, KPSSimChanged, value );
        ret = ( errorCode == KErrNone && value == ESimChanged );
        }

    INFO_1( "Is SIM changed reset = %d", ret );
    return ret;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::ValidateRTCPropertyKey
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CSsmUiSpecific::ValidateRTCPropertyKey()
	{
    FUNC_LOG;

	return KRTCPropertyKey;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::ValidateRTCPropertyCategory
// ---------------------------------------------------------------------------
//
EXPORT_C TUid CSsmUiSpecific::ValidateRTCPropertyCategory()
	{
    FUNC_LOG;

	return KPSStarterUid;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::PhoneMemoryRootDriveId
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CSsmUiSpecific::PhoneMemoryRootDriveId()
	{
    FUNC_LOG;

    TInt driveId = EDriveC;
    TDriveId driveIdBuf = PathInfo::PhoneMemoryRootPath().Left( KDriveIdLength );
    if ( driveIdBuf.Length() > 0 )
        {
        RFs::CharToDrive( driveIdBuf[0], driveId ) ;
        }

    INFO_1( "Phone memory root path ID: %d", driveId );
	return driveId;
	}


// ---------------------------------------------------------------------------
// CSsmUiSpecific::CSsmUiSpecific
// ---------------------------------------------------------------------------
//
CSsmUiSpecific::CSsmUiSpecific() : iReferenceCount(1), iReservedPhoneMemory(0)
	{
    FUNC_LOG;
    }
/**
Leaving construction inside ConstructL
*/
void CSsmUiSpecific::ConstructL()
	{
	FUNC_LOG;
	
	User::LeaveIfError( iReservedPhoneMemoryFs.Connect() );
	}

/**
ReservePhoneMemorySpace
*/
EXPORT_C TInt CSsmUiSpecific::ReservePhoneMemorySpace()
    {
	FUNC_LOG;
	TVolumeIOParamInfo volumeParamInfo; 
	const TInt phoneMemoryDriveID = PhoneMemoryRootDriveId();
	TInt errorCode = iReservedPhoneMemoryFs.VolumeIOParam(phoneMemoryDriveID, volumeParamInfo); 
	if( KErrNone == errorCode )
		{
#ifdef __WINS__
		//512 bytes for __WINS__
		const TInt reservedMemory = 512;
#else
		//Reserving two clusterSize Phone memory 
		const TInt reservedMemory = KNumberOfCluster * (volumeParamInfo.iClusterSize);
#endif //__WINS__
		errorCode = iReservedPhoneMemoryFs.ReserveDriveSpace(phoneMemoryDriveID, reservedMemory);

		if ( KErrNone == errorCode )
			{
			iReservedPhoneMemory = reservedMemory;
			}
		}
    return errorCode;
    }

/**
FreeReservedPhoneMemorySpace
*/
EXPORT_C TInt CSsmUiSpecific::FreeReservedPhoneMemorySpace(const TInt aSpaceToFree)
    {
	FUNC_LOG;
    TInt errorCode(KErrGeneral);
	INFO_2("Reserved memory is = %d bytes, Request to free memory is = %d bytes", iReservedPhoneMemory, aSpaceToFree);
    if(0 < iReservedPhoneMemory)
        {
		if(0 == aSpaceToFree)
		    {
		   	//Free complete reserved phone memory
			errorCode = iReservedPhoneMemoryFs.ReserveDriveSpace( PhoneMemoryRootDriveId(), 0 );
			INFO_1("Freeing memory completed with = %d", errorCode);
			iReservedPhoneMemory = 0; 
		    }
		else
		    {
		    TInt newReserveSize = iReservedPhoneMemory - aSpaceToFree;
		    newReserveSize = newReserveSize >= 0 ? newReserveSize : 0;
		    errorCode = iReservedPhoneMemoryFs.ReserveDriveSpace( PhoneMemoryRootDriveId(), newReserveSize );
			INFO_1("Freeing partial phone memory completed with = %d", errorCode);
		    if(KErrNone == errorCode)
			    {
			    iReservedPhoneMemory = newReserveSize;
			    }
		    }
		}
    return errorCode;
    }