/*

* 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:  Implementation of CDevEncUiEncryptionOperator.

*

*/

// INCLUDE FILES

#include <DevEncExternalCRKeys.h>

// Class includes

#include "DevEncLog.h"

#include "DevEncUids.hrh"

#include "DevEncUiEncryptionOperator.h"

#include "DevEncUiFileManager.h"

//System includes

#include <aknmessagequerydialog.h>

#include <aknViewAppUi.h>

#include <AknWaitNoteWrapper.h>

#include <aknnotewrappers.h> // for CAknErrorNote

#include <bautils.h> // For BAFL, localized resource files

#include <centralrepository.h>

#include <coemain.h>

#include <data_caging_path_literals.hrh> // for resource files dir

#include <DevEncUi.rsg>

#include <eikenv.h>

#include <e32property.h>

#include <etelmm.h>

#include <f32file.h>

#include <gsfwviewuids.h> // For general settings view UIDs (autolock)

#include <hwrmpowerstatesdkpskeys.h> // For power state

#include <secuisecuritysettings.h> // for autolock

#include <settingsinternalcrkeys.h>

#include <StringLoader.h>

#include <utf.h> // For character conversion

#include <TerminalControl3rdPartyAPI.h>

#include <DevEncKeyUtils.h>

//User includes

#include "DevEncLog.h"

#include "DevEnc.hrh"

#include "DevEncUiCreateKeyProcess.h"

#include "DevEncDef.h"

#include "DevEncUiMemoryEntity.h"

#include "DevEncUiSecretMinMaxCodeQuery.h"

//for KMaxAutolockPeriod = 20;

#include "DevEncSession.h"

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

// CDevEncUiEncryptionOperator::~CDevEncUiEncryptionOperator

//

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

//

CDevEncUiEncryptionOperator::~CDevEncUiEncryptionOperator()

    {

    }

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

// CDevEncUiEncryptionOperator::NewL

//

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

//

CDevEncUiEncryptionOperator* CDevEncUiEncryptionOperator::NewL( CEikonEnv& aEikonEnv,

                                                                CAknViewAppUi& aAppUi,

                                                                CRepository*& aCrSettings )

    {

    CDevEncUiEncryptionOperator* self =

        CDevEncUiEncryptionOperator::NewLC( aEikonEnv,

                                            aAppUi,

                                            aCrSettings );

    CleanupStack::Pop( self );

    return self;

    }

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

// CDevEncUiEncryptionOperator::NewLC

//

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

//

CDevEncUiEncryptionOperator* CDevEncUiEncryptionOperator::NewLC( CEikonEnv& aEikonEnv,

                                                                 CAknViewAppUi& aAppUi,

                                                                 CRepository*& aCrSettings )

    {

    CDevEncUiEncryptionOperator* self =

        new ( ELeave ) CDevEncUiEncryptionOperator( aEikonEnv,

                                                    aAppUi,

                                                    aCrSettings );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CDevEncUiEncryptionOperator::CDevEncUiEncryptionOperator

//

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

//

CDevEncUiEncryptionOperator::CDevEncUiEncryptionOperator( CEikonEnv& aEikonEnv,

                                                          CAknViewAppUi& aAppUi,

                                                          CRepository*& aCrSettings )

    : iEikEnv( aEikonEnv ),

    iAppUi( aAppUi ),

    iCrSettings( aCrSettings )

    {

    }

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

// CDevEncUiEncryptionOperator::ConstructL

//

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

//

void CDevEncUiEncryptionOperator::ConstructL()

    {

    }

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

// CDevEncUiEncryptionOperator::HandlePhoneMemEncryptRequestL()

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

//

void CDevEncUiEncryptionOperator::HandlePhoneMemEncryptRequestL( CDevEncUiMemoryEntity* aMem, CDevEncUiMemoryEntity* aPrimaryMem )

    {

    // Check the battery level first

    if ( ! CheckBatteryL() )

        {

        // The battery level is too low and no charger is connected.

        // Show a note to the user.

        ErrorNoteL( R_DEVENCUI_TEXT_BATTERY_LOW );

        User::Leave( KErrNotReady );

        }

    if ( (aMem->State() == EDecrypted) || (aPrimaryMem && (aPrimaryMem->State() == EDecrypted)) )

        {

        // Encryption is off -> encrypt

        if ( PrepareEncryptionL() )

            {

            if ( aMem->State() == EDecrypted )

            	{

            	DFLOG( "Starting Mass Storage encryption" );

            	aMem->StartEncryptionL();

            	}

            if( aPrimaryMem && (aPrimaryMem->State() == EDecrypted) )

            	{

            	DFLOG( "Starting phone memory encryption" );

            	aPrimaryMem->StartEncryptionL();

                }

            }

        else

            {

            DFLOG( "Encryption cancelled" );

            }

        }

    else if ( (aMem->State() == EEncrypted) || (aPrimaryMem && (aPrimaryMem->State() == EEncrypted)) )

        {

        if ( PrepareDecryptionL() )

            {

            if ( aMem->State() == EEncrypted )

            	{

            	DFLOG( "Starting Mass Storage decryption" );

            	aMem->StartDecryptionL();

            	}

            if( aPrimaryMem && (aPrimaryMem->State() == EEncrypted) )

                {

                DFLOG( "Starting phone memory decryption" );

                aPrimaryMem->StartDecryptionL();

                }

            }

        else

            {

            DFLOG( "Decryption cancelled" );

            }

        }

    else

        {

        DFLOG2( "Phone memory busy, state = %d, no action", aMem->State() );

        }

    // Depending on the user's selection, the memory may be in the same

    // state as before or in a new state. This call will let all observers

    // know what state the memory ended up in.

    aMem->UpdateMemoryInfo();

    }

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

// CDevEncUiEncryptionOperator::PrepareEncryptionL()

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

//

TBool CDevEncUiEncryptionOperator::PrepareEncryptionL()

    {

    TBool result( EFalse );

    // Show the confirmation query about autolock

    CAknMessageQueryDialog* yesNoQuery = new ( ELeave ) CAknMessageQueryDialog;

    if ( ! yesNoQuery->ExecuteLD( R_DEVENCUI_ENCRYPT_CONFIRMATION_QUERY_DIALOG ) )

        {

        // User answered no. Do nothing

        DFLOG( "User cancelled after autolock warning. No action." );

        return result;

        }

    // Autolock must be on before encryption can be enabled.

    // Get the current autolock status and the current max autolock period

    TInt lockTime = 0;

    TBuf8<21> autoLockPeriodBuf;

    RTerminalControl terminalCtrl;

    TInt ctrlConnect = terminalCtrl.Connect();

    DFLOG2( "DEVENC: terminal control connected %d", ctrlConnect );

    RTerminalControl3rdPartySession session;

    TInt retValue = session.Open( terminalCtrl );

    DFLOG2( "DEVENC: terminal control session open %d", retValue );

    TInt err2 = session.GetDeviceLockParameter( RTerminalControl3rdPartySession::ETimeout, autoLockPeriodBuf );

    DFLOG2( "DEVENC: max value get returned value %d", err2 );

    TLex8 lexAutolock( autoLockPeriodBuf );          

    lexAutolock.Val( lockTime );

    DFLOG2( "lockTime = %d", lockTime );

    //Get current max autolock period

    TBuf8<21> oldMaxPeriodBuf;

    TInt maxperioderr = session.GetDeviceLockParameter( RTerminalControl3rdPartySession::EMaxTimeout, oldMaxPeriodBuf );

    DFLOG2( "DEVENC: max value set returned value %d", maxperioderr );

#ifndef __WINS__

    // Setting the autolock works only in target

    if ( lockTime == 0 )

        {

        // Autolock disabled. Go to the autolock settings

        DFLOG( "Autolock currently disabled, going to settings" );

        // Create the filename of the SecUi resource file

        _LIT( KFileDrive, "z:" );

        _LIT( KSecUiResourceFileName, "SecUi.rsc" );

        TFileName filename;

        filename += KFileDrive;

        filename += KDC_RESOURCE_FILES_DIR;

        filename += KSecUiResourceFileName;

        // Convert to a localized resource filename if possible

        RFs fs;

        User::LeaveIfError( fs.Connect() );

        BaflUtils::NearestLanguageFile( fs, filename );

        // Load the SecUi resource file

        TInt rfileOffset( 0 );

        TRAPD( err, rfileOffset = iEikEnv.AddResourceFileL( filename ) );

        if ( err )

            {

            DFLOG2( "Add resource file error %d", err );

            }

        User::LeaveIfError( err );

        // Set maximum autolock period

        TBuf8<21> maxPeriodBuf;

        maxPeriodBuf.AppendNum( KMaxAutolockPeriod );

        TInt err3 = session.SetDeviceLockParameter( RTerminalControl3rdPartySession::EMaxTimeout, maxPeriodBuf );

        DFLOG2( "DEVENC: max value set returned value %d", err3 );

        // Let the user set an autolock period

        CSecuritySettings* secSett = CSecuritySettings::NewL();

        CleanupStack::PushL( secSett );

        TInt newLockTime = secSett->ChangeAutoLockPeriodL( lockTime );

        CleanupStack::PopAndDestroy( secSett );

        iEikEnv.DeleteResourceFile( rfileOffset );

        if ( newLockTime == 0 )

            {

            // User cancelled or set autolock off -> do nothing

            DFLOG( "User selected not to enable autolock. No action." );

            //restore the old maximum period value

            TInt err3 = session.SetDeviceLockParameter( RTerminalControl3rdPartySession::EMaxTimeout, oldMaxPeriodBuf );

            DFLOG2( "DEVENC: max value set returned value %d", err3 );

            //the autolock period is now at KMaxAutolockPeriod( =20 ) so we have to set it as it was previously

            err3 = session.SetDeviceLockParameter( RTerminalControl3rdPartySession::ETimeout, autoLockPeriodBuf );

            DFLOG2( "DEVENC: max value set returned value %d", err3 );

            session.Close();

            terminalCtrl.Close();

            return result;

            }

        TBuf8<21> newLockTimeBuf;

        newLockTimeBuf.AppendNum( newLockTime );

        TInt setResult = session.SetDeviceLockParameter( RTerminalControl3rdPartySession::ETimeout, newLockTimeBuf );

        if ( setResult )

            {

            // TBI: Log the failure and leave with error

            DFLOG2( "ERROR: session.SetDeviceLockParameter( RTerminalControl3rdPartySession::ETimeout, .. ) returned %d", setResult );

            session.Close();

            terminalCtrl.Close();

            return result;

            }

        lockTime = newLockTime;

        }

    else

    	{    	

    	DFLOG( "Autolock already enabled. Set only the current maximum period" );

    	//By setting the max autolock period the autolock period is set to max if it was greater than that

    	TBuf8<21> maxPeriodBuf;

        maxPeriodBuf.AppendNum( KMaxAutolockPeriod );

        TInt err3 = session.SetDeviceLockParameter( RTerminalControl3rdPartySession::EMaxTimeout, maxPeriodBuf );

        DFLOG2( "DEVENC: max value set returned value %d", err3 );

        }

#endif // __WINS__

    DFLOG2( "Autolock time is %d", lockTime );

    // Autolock is now enabled, so we can proceed with the encryption

    // Warn the user about the long encryption process

    if ( MessageQueryL( R_DEVENCUI_TEXT_NOTE_ENCRYPTING ) )

        {

        result = ETrue;

        DFLOG( "Starting encryption" );

        }

    else

        {

        DFLOG( "Encryption cancelled" );

        //the encryption was cancelled. Let's set the old autolock values

        //restore the old maximum period value

        TInt err3 = session.SetDeviceLockParameter( RTerminalControl3rdPartySession::EMaxTimeout, oldMaxPeriodBuf );

        DFLOG2( "DEVENC: max value set returned value %d", err3 );

        //the autolock period is now at KMaxAutolockPeriod( =20 ) so we have to set it as it was previously

        err3 = session.SetDeviceLockParameter( RTerminalControl3rdPartySession::ETimeout, autoLockPeriodBuf );

        DFLOG2( "DEVENC: max value set returned value %d", err3 );

        }

    session.Close();

    terminalCtrl.Close();

    return result;

    }

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

// CDevEncUiEncryptionOperator::PrepareDecryptionL()

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

//

TBool CDevEncUiEncryptionOperator::PrepareDecryptionL()

    {

    // Warn the user about the long decryption process

    return MessageQueryL( R_DEVENCUI_TEXT_NOTE_PHONE_DECRYPTING );

    }

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

// CDevEncUiEncryptionOperator::MessageQueryL()

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

//

TBool CDevEncUiEncryptionOperator::MessageQueryL( TInt aResourceId,

                                                  TInt aSoftKeysId )

    {

    TBool result( EFalse );

    // Show a message query with OK and Cancel buttons and the specified text

    CAknMessageQueryDialog* query =

        new ( ELeave ) CAknMessageQueryDialog;

    query->PrepareLC( R_DEVENCUI_ENCRYPT_CONFIRMATION_QUERY_DIALOG );

    query->ButtonGroupContainer().SetCommandSetL( aSoftKeysId );

    HBufC* prompt = StringLoader::LoadLC( aResourceId, &iEikEnv );

    query->SetMessageTextL( *prompt );

    CleanupStack::PopAndDestroy( prompt );

    if ( query->RunLD() )

        {

        result = ETrue;

        }

    return result;

    }

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

// CDevEncUiEncryptionOperator::QueryDialog()

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

//

TBool CDevEncUiEncryptionOperator::QueryDialogL( TInt aResourceId,

                                                 TInt aSoftKeysId )

    {

    TBool result( EFalse );

    CAknQueryDialog* query = CAknQueryDialog::NewL();

    query->PrepareLC( R_DEVENCUI_CONFIRMATION_QUERY ); // CleanupStack OK

    HBufC* prompt = StringLoader::LoadLC( aResourceId, &iEikEnv );

    query->SetPromptL( *prompt );

    query->ButtonGroupContainer().SetCommandSetL( aSoftKeysId );

    CleanupStack::PopAndDestroy( prompt );

    if ( query->RunLD() )

        {

        result = ETrue;

        }

    return result;

    }

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

// CDevEncUiEncryptionOperator::DataQueryDialogL()

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

//

TBool CDevEncUiEncryptionOperator::DataQueryDialogL( TDes& aResult,

                                                     TInt aPromptResourceId,

                                                     TInt aMaxLength )

    {

    // The descriptor contained the prompt text for the query. The prompt

    // text can also be defined in the resource structure of the query

    HBufC* prompt = StringLoader::LoadLC( aPromptResourceId, &iEikEnv );

    // create dialog instance

    CAknTextQueryDialog* dlg =

        new( ELeave ) CAknTextQueryDialog( aResult, *prompt );

    CleanupStack::PopAndDestroy( prompt );

    // Sets the maximum length of the text editor

    dlg->SetMaxLength( aMaxLength );

    // Prepares the dialog, constructing it from the specified resource

    dlg->PrepareLC( R_DEVENCUI_DATA_QUERY );

    // Launch the dialog

    return dlg->RunLD();

    }

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

// CDevEncUiEncryptionOperator::HandleMmcEncryptRequestL()

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

//

void CDevEncUiEncryptionOperator::HandleMmcEncryptRequestL( CDevEncUiMemoryEntity* aMem,

                                                            TInt aCommand )

    {

    // Check the battery level first

    if ( ! CheckBatteryL() )

        {

        // The battery level is too low and no charger is connected.

        // Show a note to the user.

        ErrorNoteL( R_DEVENCUI_TEXT_BATTERY_LOW );

        User::Leave( KErrNotReady );

        }

    TBool proceed( EFalse );

    switch ( aCommand )

        {

        case EDevEncUiCommandEncryptWithRestoredKey:

            {

            DFLOG( "Encrypt with restored key selected" );

            proceed = LoadAndSetKeyL(); // No cleanup stack needed

            break;

            }

        case EDevEncUiCommandEncryptAndSaveKey:

            {

            DFLOG( "Encrypt and save key selected" );

            proceed = CreateAndSaveKeyL(); // No cleanup stack needed

            if( proceed )

                {

                InfoNoteL( R_DEVENCUI_TEXT_NOTE_SAVEINFO, ETrue );

                DFLOG( "Key saved succesfully" );

                }

            break;

            }

        case EDevEncUiCommandEncryptWithoutSavingKey:

            {

            DFLOG( "Encrypt without saving key selected" );

            // Create an encryption key and take it in use

            // The key will remain in the driver until the next key is set,

            // and it can not be retrieved.

            proceed = CreateKeyL(); // No cleanup stack needed

            break;

            }

        case EDevEncUiCommandEncryptWithCurrentKey:

            {

            DFLOG( "Encrypt with current key selected" );

            proceed = ETrue;

            }

        default:

            {

            DFLOG( "Invalid command" );

            break;

            }

        }

    if ( aMem->State() == EUnmounted )

        {

        if( !proceed )

        	{

            // The encryption operation was cancelled, just go back to encryption view

            DFLOG( "No Mmc present and operation was cancelled -> no encryption" );

            }

        else

        	{

        	// The encryption operation was succesfull, go back to main view

            iAppUi.ActivateLocalViewL( TUid::Uid( EDevEncUiMainViewId ) );

        	proceed = EFalse;

            DFLOG( "No Mmc present -> no encryption" );

            }

        }

    if ( aMem->State() == ECorrupted )

        {

        if( !proceed )

        	{

        	DFLOG( "Mmc probably enc with another key -> wait for remount" );

            }

        else

        	{

        	// Mmc was probably encrypted with another key. We have just set a

            // new key, so now we have to wait until the state changes and hope

            // that the card is readable. If it is, a note will be shown to the

            // user. (See UI spec 2.7)

            InfoNoteL( R_DEVENCUI_TEXT_NOTE_MEMORYCARD_ENCRYPTED, ETrue );

            iAppUi.ActivateLocalViewL( TUid::Uid( EDevEncUiMainViewId ) );