/*

* Copyright (c) 2005 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:  Container for the Device & SIM security sub-folder

*

*/

#include "GSSimSecPluginContainer.h"

#include "GSSimSecPluginModel.h"

#include "GSSimSecPlugin.hrh"

#include <aknlists.h>

#include <etelmm.h>

#include <RSSSettings.h>

#include <StringLoader.h>

#include <featmgr.h>

#include <csxhelp/cp.hlp.hrh>

#include <gsfwviewuids.h>

#include <GSSimSecPluginRsc.rsg>

#include <gslistbox.h>

#include <AknsConstants.h>

#include <secuisecuritysettings.h>

#ifdef RD_REMOTELOCK

#include <RemoteLockSettings.h>

_LIT( KRemoteLockEmptyItem, " " );

#endif

#include    <SCPClient.h>                                                  

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

_LIT( CodeItem,"****" );

_LIT( SecurityCodeItem, "*****" );

const TInt KMaxStringLength = 50;

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ==============================

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

// CGSSimSecPluginContainer::ConstructL()

// 

// Symbian OS two phased constructor

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

//

void CGSSimSecPluginContainer::ConstructL( const TRect& aRect )

    { 

    iListBox = new( ELeave ) CAknSettingStyleListBox;

    BaseConstructL( aRect, R_GS_SIM_SECURITY_VIEW_TITLE, R_SIM_SECURITY_LBX );

    FeatureManager::InitializeLibL();

    }

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

// CGSSimSecPluginContainer::~CGSSettListSecurityContainer()

// 

// Destructor 

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

//

CGSSimSecPluginContainer::~CGSSimSecPluginContainer()

    {

    if(iCodeItems)

        delete iCodeItems;

    if(iUpinItems)

        delete iUpinItems;

    if(iAutoLockItems)

        delete iAutoLockItems;

    if(iPinItems)

        delete iPinItems;

    if(iSecurityItems)

        delete iSecurityItems;

    if(iSatItems)

        delete iSatItems;

    if(iSecurity)

        delete iSecurity;

    if(iListboxItemArray)

        delete iListboxItemArray;

#ifdef RD_REMOTELOCK

    if(iRemoteLockItems)

        delete iRemoteLockItems;

#endif // RD_REMOTELOCK    

FeatureManager::UnInitializeLib();

    }

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

// CGSSimSecPluginContainer::CGSSimSecPluginContainer()

// 

// Constructor

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

//

CGSSimSecPluginContainer::CGSSimSecPluginContainer(

                          CGSSimSecPluginModel* aModel )

    : iModel ( aModel )

    {

    }

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

// CGSSimSecPluginContainer::ConstructListBoxL()

// 

//  

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

//

void CGSSimSecPluginContainer::ConstructListBoxL( TInt aResLbxId )

    {

    iSecurity= CSecuritySettings::NewL();

    TBool wcdmaSupported(FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ));

    TBool upinSupported(FeatureManager::FeatureSupported( KFeatureIdUpin ));

    if(wcdmaSupported || upinSupported)

        {

        //check if UPIN code is supported and not rejected

        TBool resp = iSecurity->IsUpinSupportedL();

        if( resp )

            {

            iUpinCodeSupported = ETrue;

            //check if UPIN code is active

            if( iSecurity->IsUpinActive() )

                {

                iUpinCodeActive = ETrue;

                }

            else

                {

                iUpinCodeActive = EFalse;

                }

            //Check whether UPIN is blocked

            resp = iSecurity->IsUpinBlocked();

            if( !resp )

                {

                iUpinCodeRejected = EFalse;

                }

            else

                {

                iUpinCodeRejected = ETrue;    

                }

            }

        else

            {

            iUpinCodeSupported = EFalse;

            iUpinCodeActive = EFalse;

            }

        }

    iListBox->ConstructL( this, EAknListBoxSelectionList );

    iListboxItemArray = CGSListBoxItemTextArray::NewL( aResLbxId, 

                        *iListBox, *iCoeEnv );

    iListBox->Model()->SetItemTextArray( iListboxItemArray );

    iListBox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );

    iAutoLockItems = iCoeEnv->ReadDesC16ArrayResourceL( R_AUTOLOCK_ARRAY );

#ifdef RD_REMOTELOCK

    #ifdef _DEBUG

    RDebug::Print( _L( "(GS)CGSSettListSimSecurityContainer::ConstructListBoxL() - Reading R_REMOTELOCK_ARRAY resource" ) );

    #endif // DEBUG

    iRemoteLockItems = iCoeEnv->ReadDesC16ArrayResourceL( R_REMOTELOCK_ARRAY );

#endif // RD_REMOTELOCK

    if(wcdmaSupported || upinSupported)

      {

        iUpinItems = iCoeEnv->ReadDesC16ArrayResourceL( R_UPIN_ARRAY );

        iCodeItems = iCoeEnv->ReadDesC16ArrayResourceL( R_CODE_ARRAY );

      }

    else

        {

        iUpinItems = NULL;

        iCodeItems = NULL;

        }

    iPinItems = iCoeEnv->ReadDesC16ArrayResourceL( R_PIN_ARRAY );

    iSecurityItems = iCoeEnv->ReadDesC16ArrayResourceL( R_SECURITY_ARRAY );

    iSatItems = iCoeEnv->ReadDesC16ArrayResourceL( R_SAT_ARRAY );

    CreateListBoxItemsL();

    }

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

// CGSSettListIdleContainer::CreateListBoxItemsL()

// 

//  

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

//

void CGSSimSecPluginContainer::CreateListBoxItemsL()

    {

    TBool wcdmaSupported(FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ));

    TBool upinSupported(FeatureManager::FeatureSupported( KFeatureIdUpin ));

    if(wcdmaSupported || upinSupported)

      {

        if( iUpinCodeSupported && !iUpinCodeRejected )

            {

            MakeCodeInUseItemL();

            }

        if( iUpinCodeActive )

            {

            MakeUpinRequestItemL();

            MakeCodeItemL( EGSSettIdUpinCode );

            }

        else

            {

            MakePinRequestItemL();

            MakeCodeItemL( EGSSettIdPinCode );

            }

       }

    else //not wcdma or upin

        {   

            MakePinRequestItemL();

            MakeCodeItemL( EGSSettIdPinCode );

        }

    MakeCodeItemL( EGSSettIdPin2Code );

    MakeAutolockItemL();

#ifdef RD_REMOTELOCK

    MakeRemoteLockItemL();

#endif // RD_REMOTELOCK

    MakeCodeItemL( EGSSettIdSecurityCode );

    MakeSimChangeItemL();

		if(!FeatureManager::FeatureSupported( KFeatureIdFfNoCugSupport ))

    	{ 

    		#ifdef _DEBUG

    		RDebug::Print( _L( "(GS)CGSSettListSimSecurityContainer::CreateListBoxItemsL() CUG supported!" ) );

    		#endif // DEBUG

    		MakeClosedUserGroupItemL();

    	}

    else

    {

    #ifdef _DEBUG

    RDebug::Print( _L( "(GS)CGSSettListSimSecurityContainer::CreateListBoxItemsL() CUG Not supported!" ) );

    #endif // DEBUG

    }

    TInt support = iModel->ConfirmSatOperationsSupport();

    if ( support == 1 ) // Confirmation allowed.

        {

        MakeSatOperationsItemL();

        }

    }

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

// CGSSettListIdleContainer::UpdateListBoxL( TInt aFeatureId )

// 

//  

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

//

void CGSSimSecPluginContainer::UpdateListBoxL( TInt aFeatureId )

    {

    TBool wcdmaSupported(FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ));

    TBool upinSupported(FeatureManager::FeatureSupported( KFeatureIdUpin ));

    switch( aFeatureId )

        {

        case EGSSettIdCodeInUse:

            if(wcdmaSupported || upinSupported)

              {

                  RecreatePinItemsL();

              }

            break;

        case EGSSettIdUpinRequest:

            if(wcdmaSupported || upinSupported)

              {

                  MakeUpinRequestItemL();

              }

            break;

        case EGSSettIdUpinCode:

            if(wcdmaSupported || upinSupported)

              {

                  MakeCodeItemL( EGSSettIdUpinCode );

              }

            break;

        case EGSSettIdPinRequest:

            MakePinRequestItemL();

            break;

        case EGSSettIdPinCode:

            MakeCodeItemL( EGSSettIdPinCode );

            break;

        case EGSSettIdPin2Code:

            MakeCodeItemL( EGSSettIdPin2Code );

            break;

        case EGSSettIdAutolock:

            MakeAutolockItemL();

            break;

        case EGSSettIdSecurityCode:

            MakeCodeItemL( EGSSettIdSecurityCode );

            break;

        case EGSSettIdSimChange:

            MakeSimChangeItemL();

            break;

    #ifdef RD_REMOTELOCK

        case EGSSettIdRemoteLock:

            MakeRemoteLockItemL();

            break;

    #endif // RD_REMOTELOCK    

        case EGSSettIdClosedUserGroup:

        		if(!FeatureManager::FeatureSupported( KFeatureIdFfNoCugSupport ))

    				{ 

            	MakeClosedUserGroupItemL();

            }

            break;

        case EGSSettIdSatOperations:

            MakeSatOperationsItemL();

            break;

        default:

            return;

        }

    iListBox->HandleItemAdditionL();

    }

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

// CGSSimSecPluginContainer::MakeCodeItemL()

// 

//  

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

//

void CGSSimSecPluginContainer::MakeCodeItemL( const TInt aItemType )

    {

    HBufC* dynamicText = HBufC::NewLC( KGSBufSize128 );

    TPtr ptrBuffer ( dynamicText->Des() );

    TBool wcdmaSupported(FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ));

    TBool upinSupported(FeatureManager::FeatureSupported( KFeatureIdUpin ));

    if(wcdmaSupported || upinSupported)

      {

        iUpinCodeSupported = iSecurity->IsUpinSupportedL();

        iUpinCodeActive = iSecurity->IsUpinActive(); 

        iUpinCodeRejected = iSecurity->IsUpinBlocked();

      }

    else

      {

        iUpinCodeSupported = EFalse;

        iUpinCodeActive = EFalse; 

        iUpinCodeRejected = EFalse;

      }

    switch ( aItemType )

        {

        case EGSSettIdUpinCode:

            if( iUpinCodeSupported && !iUpinCodeRejected && iUpinCodeActive )

                {

                ptrBuffer =  CodeItem;

                iListboxItemArray->SetDynamicTextL( EGSSettIdUpinCode, ptrBuffer );

                iListboxItemArray->SetItemVisibilityL( EGSSettIdUpinCode,

                                   CGSListBoxItemTextArray::EVisible );

                }

            else

                {

                iListboxItemArray->SetItemVisibilityL( EGSSettIdUpinCode,

                                   CGSListBoxItemTextArray::EInvisible );

                }

            break;

        case EGSSettIdPin2Code:

            ptrBuffer =  CodeItem;

            iListboxItemArray->SetDynamicTextL( EGSSettIdPin2Code, ptrBuffer );

            iListboxItemArray->SetItemVisibilityL( EGSSettIdPin2Code, 

                               CGSListBoxItemTextArray::EVisible );

            break;

        case EGSSettIdSecurityCode:

            ptrBuffer =  SecurityCodeItem;

            iListboxItemArray->SetDynamicTextL( EGSSettIdSecurityCode, 

                                                ptrBuffer );

        if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ))

        {

            {                                                      

            // Check the code change policy from the SCP server.

            TInt allowChange = 1;

            RSCPClient scpClient;

            TInt ret = scpClient.Connect();

            if ( ret == KErrNone )

                {                                

                TBuf<KSCPMaxIntLength> policyBuf;

                policyBuf.Zero();

                if ( scpClient.GetParamValue( ESCPCodeChangePolicy, policyBuf ) == KErrNone )

                    {

                    TLex lex( policyBuf );

                    lex.Val( allowChange );

                    #if defined(_DEBUG)

                        RDebug::Print(_L("(GS)CGSSettListSimSecurityContainer::\

                            MakeCodeInUseItemL(): Policy retrieved: %d"), allowChange );

                    #endif //DEBUG                    

                    }

                else

                    {

                    #if defined(_DEBUG)

                       RDebug::Print(_L("(GS)CGSSettListSimSecurityContainer::\

                            MakeCodeInUseItemL(): ERROR: Failed to retrieve the policy value") );

                    #endif //DEBUG                                                      

                    }

                scpClient.Close();

                }

            else

                {

                #if defined(_DEBUG)

                    RDebug::Print(_L("(GS)CGSSettListSimSecurityContainer::MakeCodeInUseItemL(): \

                        ERROR: Failed to connect to SCP") );

                #endif //DEBUG                                  

                }

            if ( allowChange == 1 )

                {            

                #if defined(_DEBUG)

                    RDebug::Print(_L("(GS)CGSSettListSimSecurityContainer::MakeCodeInUseItemL(): \

                        Code change allowed"));

                #endif //DEBUG                                        

                iListboxItemArray->SetItemVisibilityL( EGSSettIdSecurityCode, 

		        CGSListBoxItemTextArray::EVisible );		        				

                }

            else

                {

                #if defined(_DEBUG)

                    RDebug::Print(_L("(GS)CGSSettListSimSecurityContainer::MakeCodeInUseItemL():\

                        Code change disallowed"));

                #endif //DEBUG

                iListboxItemArray->SetItemVisibilityL( EGSSettIdSecurityCode, 

    		        CGSListBoxItemTextArray::EInvisible );

                }

            }

      }  

      else

      {      

            iListboxItemArray->SetItemVisibilityL( EGSSettIdSecurityCode, 

                               CGSListBoxItemTextArray::EVisible );

	}

            break;

        case EGSSettIdPinCode:

        default:

            if( !iUpinCodeSupported || iUpinCodeRejected || !iUpinCodeActive )

                {

                ptrBuffer =  CodeItem;

                iListboxItemArray->SetDynamicTextL( EGSSettIdPinCode, 

                                                    ptrBuffer );

                iListboxItemArray->SetItemVisibilityL( EGSSettIdPinCode, 

                                   CGSListBoxItemTextArray::EVisible );

                }

            else

                {

                iListboxItemArray->SetItemVisibilityL( EGSSettIdPinCode, 

                                   CGSListBoxItemTextArray::EInvisible );

                }

            break;

        }

    CleanupStack::PopAndDestroy( dynamicText );

    }

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

// CGSSimSecPluginContainer::MakeAutolockItemL()

// 

//  

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

//

void CGSSimSecPluginContainer::MakeAutolockItemL()

    {

    HBufC* dynamicText = HBufC::NewLC( KGSBufSize128 );

    TPtr ptrBuffer ( dynamicText->Des() );

    TInt period = iModel->AutoLockPeriod();

    switch ( period )

        {

        case 0:

            ptrBuffer = ( *iAutoLockItems )[ 0 ];

            break;

        case 1:

            {

            TBuf<KGSBufSize128> tempString;

            StringLoader::Format( tempString, 

                                ( ( *iAutoLockItems )[1] ),

                                  -1, // no index in the key string

                                  period );

            ptrBuffer = tempString;

            }

            break;

        default:

            {

            TBuf<KGSBufSize128> tempString;

            StringLoader::Format( tempString, 

                                ( ( *iAutoLockItems )[2] ),

                                  -1, // no index in the key string

                                  period );

            ptrBuffer = tempString;

            }

            break;