/*

* 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:  MidletPackageInfo Factory implementation

*

*/

#include <caf/caf.h>                         // ContentAccess::CContent

#include "appmngr2midletpckginfofactory.h"   // CAppMngr2MidletPakageInfoFactory

#include "appmngr2midletpackageinfo.h"       // CAppMngr2MidletPackageInfo

#include "appmngr2recognizedfile.h"          // CAppMngr2RecognizedFile

#include "appmngr2midletresourcehandler.h" // CAppMngr2MidletResourceHandler

#include "logger.h"                          // LOG

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

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

// CAppMngr2MidletPackageInfo::NewL()

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

//

CAppMngr2MidletPckgInfoFactory* CAppMngr2MidletPckgInfoFactory::NewL(

    CAppMngr2Runtime& aRuntime, RFs& aFs, CAppMngr2MidletResourceHandler& aResourceHandler)

{

    LOG(EJavaAppMngrPlugin, EInfo, "+ CAppMngr2MidletPckgInfoFactory::NewL ");

    CAppMngr2MidletPckgInfoFactory* self

    = new(ELeave) CAppMngr2MidletPckgInfoFactory(aRuntime, aFs, aResourceHandler);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    LOG(EJavaAppMngrPlugin, EInfo, "- CAppMngr2MidletPckgInfoFactory::NewL ");

    return self;

}

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

// CAppMngr2MidletPckgInfoFactory::~CAppMngr2MidletPckgInfoFactory()

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

//

CAppMngr2MidletPckgInfoFactory::~CAppMngr2MidletPckgInfoFactory()

{

    LOG(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::~CAppMngr2MidletPckgInfoFactory ");

    Cancel();

    delete iMatcher;

    iMatcher = NULL;

}

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

// CAppMngr2MidletPckgInfoFactory::GetInstallationFilesL()

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

//

void CAppMngr2MidletPckgInfoFactory::GetInstallationFilesL(

    RPointerArray<CAppMngr2PackageInfo>& aPackageInfos,

    const RPointerArray<CAppMngr2RecognizedFile>& aFileList,

    TRequestStatus& aStatus)

{

    LOG(EJavaAppMngrPlugin, EInfo, "+ CAppMngr2MidletPckgInfoFactory::GetInstallationFilesL ");

    if (IsActive())

    {

        User::Leave(KErrInUse);

    }

    iCounter = 0;

    iState = ENextPckg;

    iPackageInfos = &aPackageInfos;

    iFileList = &aFileList;

    iExtStatus = &aStatus;

    *iExtStatus = KRequestPending;

    LOG(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::GetInstallationFilesL:SetActive()");

    SetActive();

    CompleteRequest(iStatus, KErrNone);

    LOG(EJavaAppMngrPlugin, EInfo, "- CAppMngr2MidletPckgInfoFactory::GetInstallationFilesL ");

}

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

// CAppMngr2MidletPckgInfoFactory::RunL()

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

//

void CAppMngr2MidletPckgInfoFactory::RunL()

{

    LOG1(EJavaAppMngrPlugin, EInfo, "+ CAppMngr2MidletPckgInfoFactory::RunL, iState: %d ", iState);

    CAppMngr2PackageInfo* packageInfo = NULL;

    switch (iState)

    {

    case ENextPckg :

    {

        if (iCounter < iFileList->Count())

        {

            LOG1(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::RunL:ENextPckg: iCounter = %d", iCounter);

            // skip processing if this files was already matched

            TBool found(EFalse);

            CAppMngr2RecognizedFile* recognized = (*iFileList)[iCounter]; // not owned

            for (TInt i(0); i < iPackageInfos->Count(); i++)

            {

                CAppMngr2MidletPackageInfo* package

                = static_cast<CAppMngr2MidletPackageInfo*>((*iPackageInfos)[i]); // not owned

                if ((recognized->FileName() == package->JadFileName())

                        || (recognized->FileName() == package->JarFileName()))

                {

                    found = ETrue;

                    break;

                }

            }

            if (found)

            {

                // Continue with next file

                iCounter++;

                iState = ENextPckg;

                CompleteRequest(iStatus, KErrNone);

            }

            else

            {

                // Get installation file

                // Counter must be incremented before leave

                TInt index = iCounter;

                iCounter++;

                GetInstallationFileL((*iFileList)[index]->FileName(),

                                     (*iFileList)[index]->DataType());

                // GetInstallationFileL() changes iState

            }

            LOG(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::RunL:ENextPckg:SetActive()");

            SetActive();

        }

        else

        {

            // File name list has been processed

            // Let's complete GetInstallationFilesL

            User::RequestComplete(iExtStatus, KErrNone);

        }

        break;

    }

    case EMatchedJar :

    {

        if (iJadFile.Length() == 0)

        {

            // Standalone JAR

            iJadFile = KNullDesC;

        }

        iState = EAppendPckg; // Next state

        LOG(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::RunL:EMatchedJar:SetActive()");

        SetActive();

        CompleteRequest(iStatus, KErrNone);

        break;

    }

    case EMatchedJad :

    {

        if (iJarFile.Length() == 0)

        {

            // Standalone JAD

            iJarFile = KNullDesC;

        }

        iState = EAppendPckg; // Next state

        LOG(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::RunL:EMatchedJad:SetActive()");

        SetActive();

        CompleteRequest(iStatus, KErrNone);

        break;

    }

    case EAppendPckg :

    {

        packageInfo = CAppMngr2MidletPackageInfo::NewL(

                          iRuntime, iJadFile, iJarFile, iFs, iResourceHandler);

        CleanupStack::PushL(packageInfo);

        iPackageInfos->AppendL(packageInfo);

        CleanupStack::Pop(packageInfo);

        iState = ENextPckg; // Next state

        LOG(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::RunL:EAppendPckg:SetActive()");

        SetActive();

        CompleteRequest(iStatus, KErrNone);

        break;

    }

    default :

    {

        LOG1(EJavaAppMngrPlugin, EInfo, " Incorrect state, iCounter = %d", iCounter);

        User::RequestComplete(iExtStatus, KErrGeneral);

        break;

    }

    }

    LOG(EJavaAppMngrPlugin, EInfo, "- CAppMngr2MidletPckgInfoFactory::RunL ");

}

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

// CAppMngr2MidletPckgInfoFactory::DoCancel()

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

//

void CAppMngr2MidletPckgInfoFactory::DoCancel()

{

    LOG(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::DoCancel ");

    CancelMatching();

    if (iExtStatus->Int() == KRequestPending)

    {

        User::RequestComplete(iExtStatus, KErrCancel);

    }

}

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

// CAppMngr2MidletPckgInfoFactory::RunError()

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

//

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

{

    LOG(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::RunError ");

    // Creation of pckg info fails continue with next one

    iState = ENextPckg; // Next state

    LOG(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::RunError:SetActive()");

    SetActive();

    CompleteRequest(iStatus, KErrGeneral);

    return KErrNone;

}

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

// CAppMngr2MidletPckgInfoFactory::GetInstallationFileL()

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

//

void CAppMngr2MidletPckgInfoFactory

::GetInstallationFileL(const TDesC& aFileName, const TDataType& aDataType)

{

    LOG(EJavaAppMngrPlugin, EInfo, "+ CAppMngr2MidletPckgInfoFactory::GetInstallationFileL ");

    TInt err(KErrNone);

    iJadFile.Zero();

    iJarFile.Zero();

    // Check MIME type

    TPtrC8 mimePtr8(aDataType.Des8());

    if (mimePtr8 == SwiUI::KJarMIMEType)

    {

        // JAR

        iJarFile = aFileName;

        // Matching JAR's JAD. MatchL is internally asynchronous

        TRAP(err, MatchL(iJarFile, SwiUI::KJarMIMEType, iJadFile, iStatus));

        if (err != KErrNone)

        {

            // Corrupted JAR, allow to create standalone package

            CancelMatching();

            iState = EAppendPckg; // Next state

            CompleteRequest(iStatus, KErrNone);

        }

        iState = EMatchedJar; // Next state

    }

    else if (mimePtr8 == SwiUI::KJadMIMEType)

    {

        // JAD

        iJadFile = aFileName;

        // Matching JAD's JAR. MatchL is internally asynchronous

        TRAP(err, MatchL(iJadFile, SwiUI::KJadMIMEType, iJarFile, iStatus));

        if (err != KErrNone)

        {

            // Corrupted JAD, allow to create standalone package

            CancelMatching();

            iState = EAppendPckg; // Next state

            CompleteRequest(iStatus, KErrNone);

        }

        iState = EMatchedJad; // Next state

    }

    else

    {

        // File name is not recognized

        User::Leave(KErrGeneral);

    }

    LOG(EJavaAppMngrPlugin, EInfo, "- CAppMngr2MidletPckgInfoFactory::GetInstallationFileL ");

}

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

// CAppMngr2MidletPckgInfoFactory::CAppMngr2MidletPckgInfoFactory()

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

//

CAppMngr2MidletPckgInfoFactory

::CAppMngr2MidletPckgInfoFactory(CAppMngr2Runtime& aRuntime, RFs& aFs, CAppMngr2MidletResourceHandler& aResourceHandler) :

        CActive(CActive::EPriorityStandard), iFs(aFs), iRuntime(aRuntime), iResourceHandler(aResourceHandler)

{

    LOG(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::CAppMngr2MidletPckgInfoFactory ");

    CActiveScheduler::Add(this);

}

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

// CAppMngr2MidletPckgInfoFactory::ConstructL()

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

//

void CAppMngr2MidletPckgInfoFactory::ConstructL()

{

    LOG(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::ConstructL ");

}

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

// CAppMngr2MidletPckgInfoFactory::CompleteRequest()

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

//

void CAppMngr2MidletPckgInfoFactory::CompleteRequest(TRequestStatus& aRequestStatus,

        TInt aStatus)

{

    LOG(EJavaAppMngrPlugin, EInfo, "CAppMngr2MidletPckgInfoFactory::CompleteRequest ");

    TRequestStatus* status = &aRequestStatus;

    User::RequestComplete(status, aStatus);

}

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

// CAppMngr2MidletPckgInfoFactory::MatchL()

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

//

void CAppMngr2MidletPckgInfoFactory::MatchL(const TDesC& aMatchingFileName,

        const TDesC8& aMatchingMimeType,

        TDes& aMatchedFileName,

        TRequestStatus &aStatus)

{

    LOG(EJavaAppMngrPlugin, EInfo, " + CAppMngr2MidletPckgInfoFactory::MatchL ");

    TParse parser;

    User::LeaveIfError(parser.Set(aMatchingFileName, NULL, NULL));

    if (!iMatcher)

    {

        iMatcher = CJcfJadJarMatcher::NewL(this, iFs);

    }

    if (aMatchingMimeType == SwiUI::KJarMIMEType)

    {

        iMatcher->MatchJadL(

            aMatchingFileName, parser.DriveAndPath(), &aMatchedFileName);

    }

    else if (aMatchingMimeType == SwiUI::KJadMIMEType)

    {

        iMatcher->MatchJarL(

            aMatchingFileName, parser.DriveAndPath(), &aMatchedFileName);

    }

    else

    {

        User::Leave(KErrGeneral);

    }

    aStatus = KRequestPending;

    LOG(EJavaAppMngrPlugin, EInfo, " - CAppMngr2MidletPckgInfoFactory::MatchL ");

}

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

// CAppMngr2MidletPckgInfoFactory::CancelMathing()

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

//

void CAppMngr2MidletPckgInfoFactory::CancelMatching()

{

    LOG(EJavaAppMngrPlugin, EInfo, " + CAppMngr2MidletPckgInfoFactory::CancelMatching ");

    delete iMatcher;

    iMatcher = NULL;

    LOG(EJavaAppMngrPlugin, EInfo, " - CAppMngr2MidletPckgInfoFactory::CancelMatching ");

}

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

// CAppMngr2MidletPckgInfoFactory::Update()

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

//

void CAppMngr2MidletPckgInfoFactory::Update(TInt aArg1)

{

    LOG(EJavaAppMngrPlugin, EInfo, " CAppMngr2MidletPckgInfoFactory::UpdateL ");

    CompleteRequest(iStatus, aArg1);

}