/*

* Copyright (c) 2005-2009 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 the CSecModUIModel class

*

*/

// INCLUDE FILES

#include    "SecModUI.h"

#include    "SecModUIModel.h"

#include    "SecModUIViewAccess.h"

#include    "SecModUIViewCode.h"

#include    "SecModUIViewMain.h"

#include    "SecModUIViewSignature.h"

#include    "SecModUISyncWrapper.h"

#include    "SecModUILogger.h"

#include    <SecModUI.rsg>

#include    <certmanui.rsg>

#include    <CTSecDlgs.rsg>

#include    <aknViewAppUi.h>

#include    <AknUtils.h>

#include    <data_caging_path_literals.hrh>

#include    <bautils.h>

#include    <unifiedkeystore.h>

#include    <aknlists.h>

#include    <mctauthobject.h>

#include    <aknnotewrappers.h>

#include    <StringLoader.h>

#include    <mctkeystore.h>

#include    <akntitle.h>

#include    <aknmessagequerydialog.h>

#include    <eikenv.h>

#include    <securityerr.h>

#include    <AknGlobalNote.h>

// CONSTANTS

_LIT(KResourceFile, "z:SecModUI.rsc");

_LIT(KResourceFile2, "z:CertManUI.rsc");

_LIT(KResourceFile3, "z:CTsecdlgs.rsc");

_LIT(KTab, " \t");

_LIT(KDoubleTab, "\t\t");

_LIT(KFourAsterisks,"****");

_LIT(KEnter, "\n");

_LIT(KDoubleEnter, "\n\n");

_LIT(KSecModUIPanic, "Security Module UI panic");

const TInt KMaxLengthTextDetailsBody = 750;

const TInt KMaxLengthItemValue = 100;

const TInt KWIMStoreUid ( 0x101F79D9 );

const TInt KItemLength (200);

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

GLDEF_C void Panic(TInt aPanic)

  {

  User::Panic(KSecModUIPanic, aPanic);

  }

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

#ifndef RD_GS_RENOVATION

EXPORT_C MSecModUI* MSecModUI::CreateL()

    {

    LOG_CREATE;

    LOG_ENTERFN("MSecModUI::CreateL()");

    LOG_LEAVEFN("MSecModUI::CreateL()");

    return CSecModUIModel::NewL();

    }

#endif

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

// CSecModUIModel::CSecModUIModel

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CSecModUIModel::CSecModUIModel()

    {

  LOG_WRITE( "CSecModUIModel::CSecModUIModel" );

    }

// Destructor

CSecModUIModel::~CSecModUIModel()

    {

    LOG_ENTERFN("CSecModUIModel::~CSecModUIModel");    

    delete iWrapper;

    if ( iResourceFileOffset )

        {

    iEikEnv->DeleteResourceFile( iResourceFileOffset );

        }

    if ( iResourceFileOffset2 )

        {

    iEikEnv->DeleteResourceFile( iResourceFileOffset2 );

        }

    if ( iResourceFileOffset3 )

        {

    iEikEnv->DeleteResourceFile( iResourceFileOffset3 );

        }    

    ResetAndDestroyCTObjects();

    LOG_LEAVEFN("CSecModUIModel::~CSecModUIModel");

    LOG_DELETE;

    }

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

// CSecModUIModel::ResetAndDestroyCTObjects()

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

//

void CSecModUIModel::ResetAndDestroyCTObjects()

    {

    LOG_ENTERFN("CSecModUIModel::ResetAndDestroyCTObjects()");

    ResetAndDestroyAOs();

    iAOKeyStores.Reset();

    delete iUnifiedKeyStore;

    iUnifiedKeyStore = NULL;

    iKeyStore = NULL;

    LOG_LEAVEFN("CSecModUIModel::ResetAndDestroyCTObjects()");

    }

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

// CSecModUIModel::ResetAndDestroyAOs()

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

//

void CSecModUIModel::ResetAndDestroyAOs()

    {

    LOG_ENTERFN("CSecModUIModel::ResetAndDestroyAOs()");

    if (iAOList)

        {

        iAOList->Release();

        iAOList = NULL;

        }

    if (iAOArray.Count() > 0 &&

        iAOArray[0]->Token().TokenType().Type().iUid == KTokenTypeFileKeystore)

        {

        iAOArray.Reset();

        }

    else

        {

        iAOArray.Close();

        }

    LOG_LEAVEFN("CSecModUIModel::ResetAndDestroyAOs()");

    }

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

// CSecModUIModel::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CSecModUIModel::ConstructL()

    {

    LOG_ENTERFN("CSecModUIModel::ConstructL()");

    iEikEnv = CEikonEnv::Static();

    AddResourceFileL();

#ifndef RD_GS_RENOVATION

    CSecModUIViewMain* viewMain = CSecModUIViewMain::NewLC(*this);

    ((CAknViewAppUi*)iEikEnv->EikAppUi())->AddViewL(viewMain);

    CleanupStack::Pop(viewMain);

    CSecModUIViewCode* viewCode = CSecModUIViewCode::NewLC(*this);

    ((CAknViewAppUi*)iEikEnv->EikAppUi())->AddViewL(viewCode);

    CleanupStack::Pop(viewCode);

    CSecModUIViewAccess* viewAccess = CSecModUIViewAccess::NewLC(*this);

    ((CAknViewAppUi*)iEikEnv->EikAppUi())->AddViewL(viewAccess);

    CleanupStack::Pop(viewAccess);

    CSecModUIViewSignature* viewSignature = 

        CSecModUIViewSignature::NewLC(*this);

    ((CAknViewAppUi*)iEikEnv->EikAppUi())->AddViewL(viewSignature);

    CleanupStack::Pop(viewSignature);

#endif

    InitializeKeyStoreL();

    LOG_LEAVEFN("CSecModUIModel::ConstructL()");

    }

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

// CSecModUIModel::NewL()

// Two-phased constructor.

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

//

CSecModUIModel* CSecModUIModel::NewL()

    {

    LOG_ENTERFN("CSecModUIModel::NewL()");

    CSecModUIModel* self = new( ELeave ) CSecModUIModel();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    LOG_LEAVEFN("CSecModUIModel::NewL()");

    return self;

    }

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

// CSecModUIModel::InitializeKeyStoreL()

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

//

TInt CSecModUIModel::InitializeKeyStoreL()

    {

    LOG_ENTERFN("CSecModUIModel::InitializeKeyStoreL()");

    ResetAndDestroyCTObjects();

    iUnifiedKeyStore = CUnifiedKeyStore::NewL(iEikEnv->FsSession());

    if (iWrapper == NULL)

        {

        iWrapper = CSecModUISyncWrapper::NewL();

        }

    TInt err = iWrapper->Initialize(*iUnifiedKeyStore);

    ShowErrorNoteL(err);

    if (KErrNone != err && KErrHardwareNotAvailable != err)

        {

        LOG_LEAVEFN("CSecModUIModel::InitializeKeyStoreL()");

        return err;

        }

    TInt keyStoreCount = iUnifiedKeyStore->KeyStoreCount();

    if (0 >= keyStoreCount)

        {

        LOG_LEAVEFN("CSecModUIModel::InitializeKeyStoreL()");

        return KErrNone;

        }

    RMPointerArray<CCTKeyInfo> keyInfos;

    CleanupClosePushL(keyInfos);

    TCTKeyAttributeFilter filter;

    TInt keyInfoCount = 0;

    filter.iPolicyFilter = TCTKeyAttributeFilter::EAllKeys;

    for (TInt i = 0; i < keyStoreCount; i++)

        {

        err = iWrapper->ListKeys(iUnifiedKeyStore->KeyStore(i), keyInfos, filter);

        LOG_WRITE_FORMAT( "CSecModUIModel::InitializeKeyStoreL() list err = %d ", err );

        //If list ok, append the AO, otherwise go next

        if ( err == KErrNone )

            {

             keyInfoCount = keyInfos.Count();

            for (TInt j = 0; j < keyInfoCount; j++)

                {

                // Check that keystore has at least one AO.

                if (NULL != keyInfos[j]->Protector())

                    {

                    // If keystore has AO, add it to the array.

                    User::LeaveIfError(

                        iAOKeyStores.Append(&(iUnifiedKeyStore->KeyStore(i))));

                    break;

                    }

                } 

            }

        keyInfos.Close();

        }

    CleanupStack::PopAndDestroy(&keyInfos);  //keyInfos

    LOG_LEAVEFN("CSecModUIModel::InitializeKeyStoreL()");

    return KErrNone;

    }

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

// CSecModUIModel::AddResourceFileL()

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

//

void CSecModUIModel::AddResourceFileL()

  {

  LOG_ENTERFN("CSecModUIModel::AddResourceFileL()");

    // Resource file loading

  RFs& fs = iEikEnv->FsSession();

  TFileName fileName;

  TParse parse;

  // secmodui.rsc

    parse.Set(KResourceFile, &KDC_RESOURCE_FILES_DIR, NULL);

  fileName = parse.FullName();

  BaflUtils::NearestLanguageFile( fs, fileName );

  iResourceFileOffset = iEikEnv->AddResourceFileL( fileName );

  // CertManUI.rsc

  parse.Set(KResourceFile2, &KDC_RESOURCE_FILES_DIR, NULL);

    fileName = parse.FullName();

    BaflUtils::NearestLanguageFile( fs, fileName );

    iResourceFileOffset2 = iEikEnv->AddResourceFileL( fileName );

  // CTSecDlg.rsc

  parse.Set(KResourceFile3, &KDC_RESOURCE_FILES_DIR, NULL);

    fileName = parse.FullName();

    BaflUtils::NearestLanguageFile( fs, fileName );

    iResourceFileOffset3 = iEikEnv->AddResourceFileL( fileName );

  LOG_LEAVEFN("CSecModUIModel::AddResourceFileL()");

  }

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

// CSecModUIModel::LoadTokenLabelsL(CEikTextListBox& aListBox)

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

//

void CSecModUIModel::LoadTokenLabelsL(CEikTextListBox& aListBox)

    {

    LOG_ENTERFN("CSecModUIModel::LoadTokenLabelsL()");

    TInt keyStoreCount = iAOKeyStores.Count();

    if (0 == keyStoreCount)

        {

        LOG_WRITE_FORMAT("keyStoreCount == %i",keyStoreCount);

        LOG_LEAVEFN("CSecModUIModel::LoadTokenLabelsL()");

        //disable the scrollbar if no keystore

        aListBox.ScrollBarFrame()->SetScrollBarVisibilityL(

	    CEikScrollBarFrame::EOff,CEikScrollBarFrame::EOff);

        return;

        }

    TBuf<KItemLength> item;

    TBuf<KItemLength> label;

    CDesCArray* itemArray =

        STATIC_CAST(CDesCArray*, aListBox.Model()->ItemTextArray());

    for (TInt i = 0; i < keyStoreCount; i++)

        {

        if (iAOKeyStores[i]->Token().TokenType().Type().iUid 

            == KTokenTypeFileKeystore)

            {

            AppendResourceL(label, R_QTN_KEYSTORE_LIST_TEXT_PHONE_KEYSTORE);

            }

        else 

            {                

            label = iAOKeyStores[i]->Token().Label();

            }

        item += KTab;

        item += label;

        item += KTab;

        AppendLocationL(item, iAOKeyStores[i]->Token().TokenType().Type());

        item.SetLength(item.Length() - 1); // Remove \n from the end

        itemArray->AppendL(item);

        label.Zero();

        item.Zero();

        }

    LOG_LEAVEFN("CSecModUIModel::LoadTokenLabelsL()");

    }

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

// CSecModUIModel::CheckCodeViewStringsL(MDesCArray& aItemArray)

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

//

void CSecModUIModel::CheckCodeViewStringsL(MDesCArray& aItemArray)

    {

    LOG_ENTERFN("CSecModUIModel::CheckCodeViewStringsL()");       

    InitAuthObjectsL();

    ListAuthObjectsL();

    if (0 >= iAOArray.Count())

        {

        // Handle error

        }

    else if (1 == iAOArray.Count())

        {

        // Only PIN-G exists, let's remove "signing codes" from the list

        CDesCArray* itemArray = STATIC_CAST(CDesCArray*, &aItemArray);

        itemArray->Delete(1); // signing code is in the second position

        }

    else

        {

        // Do nothing

        }

    LOG_LEAVEFN("CSecModUIModel::CheckCodeViewStringsL()");

    }

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

// CSecModUIModel::InitAuthObjectsL()

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

//

void CSecModUIModel::InitAuthObjectsL()

    {

    LOG_ENTERFN("CSecModUIModel::InitAuthObjectsL()");

    TInt err = KErrNone;

    // Symbian's file key store does not support

    // MCTAuthenticationObjectList interface, so we need to use

    // other way to get AO.

    if (iKeyStore->Token().TokenType().Type().iUid == KTokenTypeFileKeystore)

        {

        if (iAOArray.Count()==0)

            {

            RMPointerArray<CCTKeyInfo> keyInfos;

            CleanupClosePushL(keyInfos);

            TCTKeyAttributeFilter filter;

            TInt keyInfoCount = 0;

            filter.iPolicyFilter = TCTKeyAttributeFilter::EAllKeys;

            err = iWrapper->ListKeys(*iKeyStore, keyInfos, filter);

            ShowErrorNoteL(err);

            User::LeaveIfError(err);

            keyInfoCount = keyInfos.Count();

            for (TInt j = 0; j < keyInfoCount; j++)

                {

                // Check that keystore has at least one AO.

                if (NULL != keyInfos[j]->Protector())

                    {

                    // If keystore has AO, add it to the array.

                    User::LeaveIfError(iAOArray.Append(keyInfos[j]->Protector()));

                    break;

                    }

                }

            CleanupStack::PopAndDestroy(&keyInfos);  //keyInfos

            }

        }

    else

        {

        if (NULL == iAOList)

            {

            MCTTokenInterface* tokenInterface = NULL;

            err = iWrapper->GetAuthObjectInterface(

                iKeyStore->Token(), tokenInterface);

            if ( KErrNone != err || NULL == tokenInterface )

                {

                ShowErrorNoteL(err);

                LOG_LEAVEFN("CSecModUIModel::InitAuthObjectsL()");

                User::Leave(err);

                }

            iAOList = (MCTAuthenticationObjectList*)tokenInterface;

            }

        }

    LOG_LEAVEFN("CSecModUIModel::InitAuthObjectsL()");

    }

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

// CSecModUIModel::ListAuthObjectsL()

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

//

void CSecModUIModel::ListAuthObjectsL()

    {

    LOG_ENTERFN("CSecModUIModel::ListAuthObjectsL()");

    if (0 >= iAOArray.Count())

        {

        __ASSERT_ALWAYS(iAOList, Panic(EPanicNullPointer));

        TInt err = iWrapper->ListAuthObjects(*iAOList, iAOArray);

        if (err)

            {

            ShowErrorNoteL(err);

            User::Leave(err);

            }

        }

    LOG_LEAVEFN("CSecModUIModel::ListAuthObjectsL()");

    }

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

// CSecModUIModel::OpenTokenL(TInt aTokenIndex)

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

//

void CSecModUIModel::OpenTokenL(TInt aTokenIndex)

    {

    LOG_ENTERFN("CSecModUIModel::OpenTokenL()");

    ResetAndDestroyAOs();

    iKeyStore = iAOKeyStores[aTokenIndex];

    ((CAknViewAppUi*)iAvkonAppUi)->ActivateLocalViewL(KSecModUIViewCodeId);

    LOG_LEAVEFN("CSecModUIModel::OpenTokenL()");

    }

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

// CSecModUIModel::OpenAuthObjViewL(TInt aIndex)

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

//

void CSecModUIModel::OpenAuthObjViewL(TInt aIndex)

    {

    LOG_ENTERFN("CSecModUIModel::OpenAuthObjViewL()");

    if (KPinGSettIndex==aIndex)

        {

        ((CAknViewAppUi*)iAvkonAppUi)->ActivateLocalViewL(KSecModUIViewAccessId);

        }

    else if (KPinNrSettIndex==aIndex)

        {

        ((CAknViewAppUi*)iAvkonAppUi)->

            ActivateLocalViewL(KSecModUIViewSignatureId);

        }

    else

        {

        }

    LOG_LEAVEFN("CSecModUIModel::OpenAuthObjViewL()");

    }

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

// CSecModUIModel::CloseAuthObjL(TInt aIndex)

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

//

void CSecModUIModel::CloseAuthObjL(TInt aIndex)

    {

    LOG_ENTERFN("CSecModUIModel::CloseAuthObjL()");

    if (PinOpen(aIndex))

        {

        __ASSERT_ALWAYS(aIndex < iAOArray.Count(), Panic(EPanicIndexOutOfRange));

        TInt err = iWrapper->CloseAuthObject(*(iAOArray[aIndex]));

        if (err)

            {

            ShowErrorNoteL(err);

            User::Leave(err);

            }

        }

    LOG_LEAVEFN("CSecModUIModel::CloseAuthObjL()");

    }

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

// CSecModUIModel::ViewSecModDetailsL(TInt aTokenIndex)

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

//

void CSecModUIModel::ViewSecModDetailsL(TInt aTokenIndex)

    {

    LOG_ENTERFN("CSecModUIModel::ViewSecModDetailsL(TInt aTokenIndex)");

    iKeyStore = iAOKeyStores[aTokenIndex];

    InitAuthObjectsL();

    ListAuthObjectsL();

    ViewOpenedSecModDetailsL();

    iKeyStore = NULL; // not owned

    if (iAOList)

        {

        iAOList->Release();