/*

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

 *

*/

// INCLUDE FILES

#include "cstsfiledatamanager.h"

#include <JavaUtils.h>

#include <utf.h>

#include "cstsauthtype.h"

#include "cstspinattributes.h"

namespace java

{

namespace satsa

{

// CONSTANTS

//max size got from PKCS#15 standard, TokenInfo.label field description

const TInt KSTSWIMLabelMaxLength = 255;

const TInt KSTSWIMPathMaxLength = 6;

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

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

// CSTSFileDataManager::CSTSFileDataManager

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

// might leave.

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

//

CSTSFileDataManager::CSTSFileDataManager() :

        CActive(EPriorityNormal), iWimLabelAndPathDone(EFalse)

{

    CActiveScheduler::Add(this);

    iState = ENotReady;

}

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

// CSTSFileDataManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSTSFileDataManager::ConstructL()

{

    iWait = new(ELeave) CActiveSchedulerWait;

    iMidpProv = CWimJavaUtils::NewL();

}

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

// CSTSFileDataManager::NewL

// Two-phased constructor.

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

//

CSTSFileDataManager* CSTSFileDataManager::NewL()

{

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

// Destructor

CSTSFileDataManager::~CSTSFileDataManager()

{

    delete iMidpProv;

    delete iWait;

    delete iACFData;

    delete iACIFData;

    delete iWimPath;

    delete iWimLabel16;

}

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

// CSTSFileDataManager::InitializeL

//

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

void CSTSFileDataManager::InitializeL()

{

    iMidpProv->Initialize(iStatus);

    iState = EInitializing;

    WaitAndCheckL();

}

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

// CSTSFileDataManager::RetrieveACIFContentL

//

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

const TDesC8& CSTSFileDataManager::RetrieveACIFContentL()

{

    TInt fileSize = 0;

    iMidpProv->GetACIFSize(fileSize, iStatus);

    iState = EGettingACIFSize;

    WaitAndCheckL();

    //allocate buffer for file data

    HBufC8* tmp = HBufC8::NewL(fileSize);

    delete iACIFData;

    iACIFData = tmp;

    TPtr8 wholeData(iACIFData->Des());

    iMidpProv->RetrieveACIFContent(wholeData, iStatus);

    iState = ERetrievingACIF;

    WaitAndCheckL();

    return *iACIFData;

}

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

// CSTSFileDataManager::RetrieveACFContentL

//

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

const TDesC8& CSTSFileDataManager::RetrieveACFContentL(

    const TDesC8& aFileIdOrPath)

{

    TInt fileSize = 0;

    iMidpProv->GetACFSize(fileSize, aFileIdOrPath, iStatus);

    iState = EGettingACFSize;

    WaitAndCheckL();

    //allocate buffer for file data

    HBufC8* tmp = HBufC8::NewL(fileSize);

    delete iACFData;

    iACFData = tmp;

    TPtr8 wholeData(iACFData->Des());

    iMidpProv->RetrieveACFContent(wholeData, aFileIdOrPath, iStatus);

    iState = ERetrievingACF;

    WaitAndCheckL();

    return *iACFData;

}

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

// CSTSFileDataManager::GetAuthObjsInfoL

//

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

void CSTSFileDataManager::GetAuthObjectsL(CArrayPtr<CSTSAuthType>* aAuthTypes,

        const RArray<TInt>& aAuthIdList)

{

    TInt auhtIdCount = aAuthIdList.Count();

    if (auhtIdCount > 0)

    {

        RArray<TJavaPINParams> authObjsInfoList(auhtIdCount);

        iMidpProv->GetAuthObjsInfo(aAuthIdList, authObjsInfoList, iStatus);

        iState = EGettingAuthObjsInfo;

        WaitAndCheckL();

        //make conversion to own struct

        TInt count = authObjsInfoList.Count();

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

        {

            //creates authType and add values

            CSTSAuthType* currentObject = CSTSAuthType::NewLC();

            currentObject->SetAuthIDL(authObjsInfoList[i].iAuthId);

            currentObject->SetLabelL(authObjsInfoList[i].iPINLabel);

            CSTSPinAttributes* pinAttr = CSTSPinAttributes::NewLC(

                                             authObjsInfoList[i].iPinType,

                                             authObjsInfoList[i].iMinLength,

                                             authObjsInfoList[i].iStoredLength,

                                             authObjsInfoList[i].iMaxLength,

                                             authObjsInfoList[i].iPinReference,

                                             authObjsInfoList[i].iPadChar, authObjsInfoList[i].iFlags);

            currentObject->SetPinAttributesL(*pinAttr);

            CleanupStack::PopAndDestroy(pinAttr);

            //append authType to the parameter array (ownership transferred)

            aAuthTypes->AppendL(currentObject);

            CleanupStack::Pop(currentObject);

        }

        authObjsInfoList.Close();

    }

}

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

// CSTSFileDataManager::RetrieveWIMLabelL

//

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

const TDesC& CSTSFileDataManager::RetrieveWIMLabelL()

{

    doRetrieveWIMLabelAndPathL();

    return *iWimLabel16;

}

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

// CSTSFileDataManager::RetrieveWIMPathL

//

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

const TDesC8& CSTSFileDataManager::RetrieveWIMPathL()

{

    doRetrieveWIMLabelAndPathL();

    return *iWimPath;

}

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

// CSTSFileDataManager::WaitAndCheckL

//

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

void CSTSFileDataManager::WaitAndCheckL()

{

    SetActive();

    if (!iWait->IsStarted())

    {

        iWait->Start();

    }

    User::LeaveIfError(iError);

}

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

// CSTSFileDataManager::doRetrieveWIMLabelAndPathL

// Retrieves WIM label and path and saves values to member variables.

// Saves information that retrieve is done and does not do retrieve if it is

// already done.

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

void CSTSFileDataManager::doRetrieveWIMLabelAndPathL()

{

    if (!iWimLabelAndPathDone)

    {

        //allocate buffer for WIM label

        HBufC8* wimLabelBuf = HBufC8::NewLC(KSTSWIMLabelMaxLength);

        TPtr8 wimLabel(wimLabelBuf->Des());

        //allocate buffer for WIM path

        HBufC8* tmpPath = HBufC8::NewL(KSTSWIMPathMaxLength);

        delete iWimPath;

        iWimPath = tmpPath;

        TPtr8 wimPath(iWimPath->Des());

        iMidpProv->RetrieveWimLabelAndPath(wimLabel, wimPath, iStatus);

        iState = EGettingWimLabelAndPath;

        WaitAndCheckL();

        //convert label to TDesC format

        //allocate member buffer for WIM label

        HBufC16* tmpLabel16 = HBufC16::NewL(wimLabel.Length());

        delete iWimLabel16;

        iWimLabel16 = tmpLabel16;

        TPtr16 label16(iWimLabel16->Des());

        TInt err = CnvUtfConverter::ConvertToUnicodeFromUtf8(label16, wimLabel);

        User::LeaveIfError(err);

        CleanupStack::PopAndDestroy(wimLabelBuf);

        //save information that both has retrieved

        iWimLabelAndPathDone = ETrue;

    }

}

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

// CSTSFileDataManager::RunL

//

// (other items were commented in a header).

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

//

void CSTSFileDataManager::RunL()

{

    iError = iStatus.Int();

    iState = EReady;

    iWait->AsyncStop();

}

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

// CSTSFileDataManager::DoCancel

// Cancels all possible active actions

// (other items were commented in a header).

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

//

void CSTSFileDataManager::DoCancel()

{

    switch (iState)

    {

    case EInitializing:

    {

        iMidpProv->CancelInitialize();

        break;

    }

    case EGettingACIFSize:

    {

        iMidpProv->CancelGetACIFSize();

        break;

    }

    case ERetrievingACIF:

    {

        iMidpProv->CancelRetrieveACIFContent();

        break;

    }

    case EGettingACFSize:

    {

        iMidpProv->CancelGetACFSize();

        break;

    }

    case ERetrievingACF:

    {

        iMidpProv->CancelRetrieveACFContent();

        break;

    }

    case EGettingAuthObjsInfo:

    {

        iMidpProv->CancelGetAuthObjsInfo();

        break;

    }

    case EGettingWimLabelAndPath:

    {

        iMidpProv->CancelRetrieveWimLabelAndPath();

        break;

    }

    default:

    {

        // nothing to cancel

    }

    }

    iState = EReady;

    iError = KErrCancel;

}

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

// CSTSFileDataManager::RunError

// If leave occures in RunL,this method is called.

// (other items were commented in a header).

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

//

TInt CSTSFileDataManager::RunError(TInt /*aError*/)

{

    //must return KErrNone

    return KErrNone;

}

} // namespace satsa

} // namespace java

//  End of File