/*

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

*

*/

#include <aknnotewrappers.h>

#include <avkon.hrh>

#include <coeutils.h> 

#include <eikprogi.h>

#include "launcherdllparser.h"

#include "launcherxmlparser.h"

#include <CMessageData.h>

#include <e32std.h>

#include <w32std.h>

#include <apgtask.h>

#include <bautils.h>

#include <s32file.h>

#include <pathinfo.h> 

#include <e32cmn.h>

_LIT(KLogFileName, "LauncherLog.txt");

_LIT(KBCLogFileName, "LauncherBCLog.txt");

_LIT(KSystemDllsFileName, "SystemDlls.txt");

_LIT(KRequiredDllsFileName, "RequiredDlls.xml");

_LIT(KDotXML,".xml");

_LIT(KDotLauncherXML,".launcherxml");

_LIT(KFileSeparator, "\t");

_LIT(KFileNewLine, "\r\n");

const TInt KMaxAppsArraySize=250;

const TInt KMaxDllArraySize=5000;

const TInt KLauncherLogBufferSize = 4096;

// After this many issues, issues are buffered and printed 

// in the end of analysis

const TInt KBigBufferUsageThreshold=10;

// Buffer allocation unit

const TInt KBigBufferAllocBytes=1024;

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

CLauncherEngine* CLauncherEngine::NewL(CLauncherAppUi* aAppUi)

    {

    CLauncherEngine* self = new(ELeave) CLauncherEngine;

    CleanupStack::PushL(self);

    self->ConstructL(aAppUi);

    CleanupStack::Pop();

    return self;

    }

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

CLauncherEngine::CLauncherEngine() : CActive(EActivePriorityIpcEventsHigh)

    {

    }

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

template <typename T>

void AppendLogBufferL(const T& aText, HBufC8*& aBuf)

    {

    if( aBuf == 0 )

        {

        aBuf = HBufC8::NewL(KLauncherLogBufferSize);

        }

    TInt currentMaxLength = aBuf->Des().MaxLength();

    if( aBuf->Des().Length() + aText.Length() > currentMaxLength )

        {

        TInt increaseSize = Max(aText.Length(), KLauncherLogBufferSize);                

        aBuf = aBuf->ReAllocL(aBuf->Des().MaxLength() + increaseSize );

        }

    aBuf->Des().Append(aText);        

    }

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

void CLauncherEngine::ConstructL(CLauncherAppUi* aAppUi)

    {

    LOGSTRING("Launcher: CLauncherEngine::ConstructL");

    iAppUi = aAppUi;

    iEnv = CEikonEnv::Static();

    iLaunchingIsActive = EFalse;

    iDLLAnalysisIsActive = EFalse;

    iSkipHiddenAndEmbedOnly = ETrue;

    User::LeaveIfError(iTimer.CreateLocal());

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

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

    iAppThreadChecker = CAppThreadChecker::NewL(this);

    iAppRunningChecker = CAppRunningChecker::NewL(this);

    iAllAppsArray = new(ELeave) CDesCArrayFlat(KMaxAppsArraySize);

    iAppsArray = new(ELeave) CDesCArrayFlat(KMaxAppsArraySize);

    iSystemDllArray = new(ELeave) CDesCArrayFlat(KMaxDllArraySize);

    iLogWriteBuf = HBufC8::NewL(KLauncherLogBufferSize);

    iLogFilePath = PathInfo::PhoneMemoryRootPath();

    iLogFilePath.Append( KLogFileName );

    iBCLogFilePath = PathInfo::PhoneMemoryRootPath();

    iBCLogFilePath.Append( KBCLogFileName );

    iSystemDllsFilePath = PathInfo::PhoneMemoryRootPath();

    iSystemDllsFilePath.Append( KSystemDllsFileName );

    iRequiredDllsFilePath = PathInfo::PhoneMemoryRootPath();

    iRequiredDllsFilePath.Append( KRequiredDllsFileName );

    iDLLParser = CLauncherDLLParser::NewL();

    CActiveScheduler::Add(this);

    }

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

CLauncherEngine::~CLauncherEngine()

    {

    LOGSTRING("Launcher: CLauncherEngine::~CLauncherEngine");

    Cancel();

    // close the log

    iLogFile.Close();

    iBCLogFile.Close();

    if (iLogWriteBuf)

        delete iLogWriteBuf;

    if (iAppRunningChecker)

        delete iAppRunningChecker;

    if (iAppThreadChecker)

        delete iAppThreadChecker;

    if (iSystemDllArray)

        {

        iSystemDllArray->Reset();

        delete iSystemDllArray;

        }

    if (iAppsArray)

        {

        iAppsArray->Reset();

        delete iAppsArray;

        }

    if (iAllAppsArray)

        {

        iAllAppsArray->Reset();

        delete iAllAppsArray;

        }

    delete iXMLParser;

    delete iDLLParser;

    delete iDLLElement;

    delete iBCIssuesBigBuffer;            

    iWs.Close();

    iLs.Close();

    iTimer.Close();

    }

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

void CLauncherEngine::SetContainerApps(CLauncherContainerApps* aContainerApps)

    {

    iContainerApps = aContainerApps;

    }

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

void CLauncherEngine::SetContainerOutput(CLauncherContainerOutput* aContainerOutput)

    {

    iContainerOutput = aContainerOutput;

    }

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

TInt CLauncherEngine::FindFilesRecursiveL(const TDesC& aFileName, const TDesC& aPath)

    {

    TInt err = KErrNone;

    CDirScan* scan = CDirScan::NewLC(iEnv->FsSession());

    scan->SetScanDataL(aPath, KEntryAttDir, ESortNone);

    CDir* dirEntries = NULL;

    for(;;)

        {

        TRAP(err, scan->NextL(dirEntries));

        if (!dirEntries  || (err!=KErrNone))

            break;

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

            {

            TFileName path(scan->FullPath());

            path.Append((*dirEntries)[i].iName);

            path.Append(_L("\\"));

            FindFiles(aFileName, path);

            }

        delete(dirEntries);

        }

    CleanupStack::PopAndDestroy(scan);

    return err;

    }

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

TInt CLauncherEngine::FindFiles(const TDesC& aFileName, const TDesC& aPath)

    {

    TFindFile fileFinder(iEnv->FsSession());

    CDir* fileList; 

    TInt err = fileFinder.FindWildByDir(aFileName, aPath, fileList);

    while (err == KErrNone)

        {

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

            {

            TParse fullentry;

            fullentry.Set((*fileList)[i].iName, &fileFinder.File(), NULL);

            TRAP(err, iSystemDllArray->AppendL(fullentry.NameAndExt())); 

            }

        delete fileList;

        err = fileFinder.FindWild(fileList);

        }

    return err;

    }

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

CDesCArray* CLauncherEngine::ListOfAllAppsL()

    {

    LOGSTRING("Launcher: CLauncherEngine::ListOfAllAppsL");

    // show wait dialog

    CAknGlobalNote* waitDialog = CAknGlobalNote::NewLC();

    waitDialog->SetSoftkeys(R_AVKON_SOFTKEYS_EMPTY);

    TInt dialogId = waitDialog->ShowNoteL(EAknGlobalWaitNote, _L("Initializing"));

    // find all DLLs from the system

    iSystemDllArray->Reset();

    TRAP_IGNORE( FindFiles(_L("*.dll"), _L("\\sys\\bin\\")) );

    // write the list of DLLs to a file

    RFile dllFile;

    if (dllFile.Replace(iEnv->FsSession(), iSystemDllsFilePath, EFileWrite) == KErrNone)

        {

        TBuf8<KMaxFileName> dllName;

        for (TInt i=0; i<iSystemDllArray->MdcaCount(); i++)

            {

            dllName.Copy( iSystemDllArray->MdcaPoint(i) );

            dllName.Append( KFileNewLine );

            dllFile.Write( dllName );

            }

        dllFile.Close();

        }

    // reset the apps list

    iAllAppsArray->Reset();

    // search all apps

    TApaAppInfo appInfo;

    iLs.GetAllApps();

    while (iLs.GetNextApp(appInfo) == KErrNone)

        {

        iAllAppsArray->AppendL(appInfo.iFullName);

        }

    // remove launcher.app / launcher.exe from the list

    for (TInt i=0; i<iAllAppsArray->MdcaCount(); i++)

        {

        if (iAllAppsArray->MdcaPoint(i).FindF(_L("\\Launcher.")) != KErrNotFound)

            {

            iAllAppsArray->Delete(i);

            iAllAppsArray->Compress();

            break;

            }

        }

    // sort the elements

    iAllAppsArray->Sort();

    // remove the wait dialog

    waitDialog->CancelNoteL(dialogId);

    CleanupStack::PopAndDestroy(); //waitDialog;

    return iAllAppsArray;

    }

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

void CLauncherEngine::StartAppLaunchingL(const CArrayFix<TInt>* aSelectedApps, TBool aAutoClose)

    {

    LOGSTRING("Launcher: CLauncherEngine::StartAppLaunchingL");

    // check that we have something to launch

    if (aSelectedApps->Count() <= 0)

        {

        _LIT(message, "Nothing selected");

        CAknErrorNote* errorNote = new(ELeave) CAknErrorNote;

        errorNote->ExecuteLD(message);

        }

    else

        {

        // update the list of applications to be tested

        iAppsArray->Reset();

        TInt ref(0);

        TKeyArrayFix key(0, ECmpTUint16);

        TInt index(0);

        for (TInt i=0; i<iAllAppsArray->MdcaCount(); i++)

            {

            ref = i;

            // if the application is selected, append it to the apps array

            if (aSelectedApps->Find(ref, key, index) == 0)  

                {

                iAppsArray->AppendL(iAllAppsArray->MdcaPoint(i));

                }

            }

        // to make sure that our algorithm works correctly

        if (iAppsArray->MdcaCount() != aSelectedApps->Count())

            {

            _LIT(message, "Something went wrong...");

            CAknErrorNote* errorNote = new(ELeave) CAknErrorNote;

            errorNote->ExecuteLD(message);

            return;

            }

        // init

        Cancel();

        iLaunchingIsActive = ETrue;

        iAutoClose = aAutoClose;

        iAppLaunchCounter = 0;

        iFailedCases = 0;

        iOkCases = 0;

        iSkippedCases = 0;

        iTotalNumberOfCases = iAppsArray->MdcaCount();

        iCurrentAppUid = KNullUid;

        // open the log file for writing

        if (iLogFile.Open(iEnv->FsSession(), iLogFilePath, EFileWrite) != KErrNone)

            {

            iEnv->FsSession().MkDirAll(iLogFilePath);

            iLogFile.Replace(iEnv->FsSession(), iLogFilePath, EFileWrite);

            }

        else

            {

            // file opens correctly, seek to the end

            TInt fileSize=0;

            iLogFile.Size(fileSize);

            iLogFile.Seek(ESeekCurrent, fileSize);

            }

        ChangeFocusToOutputView();

        iContainerOutput->PrintTextL(_L("New test started.\n"));

        // start the first launch!

        IssueLaunch();

        }

    }

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

void CLauncherEngine::IssueLaunch()

    {

    LOGSTRING("Launcher: CLauncherEngine::IssueLaunch");

    __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("Timing error?"), 100));

    // this should keep the backlight on

    User::ResetInactivityTime();

    // some delay

    iTimer.After(iStatus, 1000000);    

    SetActive();

    }

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

void CLauncherEngine::RunL()

    {

    LOGSTRING("Launcher: CLauncherEngine::RunL");  

    TInt err = iStatus.Int();

    User::LeaveIfError(err);

    if( iDLLAnalysisIsActive )

        {

        if( iWaitDialog == 0)

            {

            TEntry entry;

            User::LeaveIfError(iEnv->FsSession().Entry(iRequiredDllsFilePath, entry));

            TInt fileSize = entry.iSize;

            // init progress bar

            iWaitDialog = new(ELeave) CAknProgressDialog((reinterpret_cast<CEikDialog**>(&iWaitDialog)), ETrue);

            iWaitDialog->SetCallback(this);

            iWaitDialog->PrepareLC(R_GENERAL_PROGRESS_NOTE);

            iWaitDialog->SetCurrentLabelL( EAknCtNote, _L("Analysing DLLs"));

            iProgressInfo = iWaitDialog->GetProgressInfoL();

            iProgressInfo->SetFinalValue( fileSize );

            iWaitDialog->RunLD();

            iWaitDialog->MakeVisible( ETrue );

            }

        iBCLogFile.Write(iLogWriteBuf->Des());

        iLogWriteBuf->Des().Zero();

        return;

        }

    else

        {

        // write full app path to the log file

        WriteInitialStuffToTheLogL(iAppsArray->MdcaPoint(iAppLaunchCounter), iLogFile);

        // get the uid of the current app

        iCurrentAppUid = KNullUid;

        TApaAppInfo appInfo;

        iLs.GetAllApps();

        while (iLs.GetNextApp(appInfo) == KErrNone)

            {

            if (appInfo.iFullName.CompareF( iAppsArray->MdcaPoint(iAppLaunchCounter) ) == 0)

                {

                iCurrentAppUid = appInfo.iUid;

                break;

                }

            }

        if (iCurrentAppUid == KNullUid)

            {        

            iLogWriteBuf->Des().Append(_L("[WARN: App has no UID] "));

            }

        // parse the filename

        TParse nameParser;

        nameParser.SetNoWild(iAppsArray->MdcaPoint(iAppLaunchCounter), NULL, NULL);

        iCurrentAppNameAndExt.Copy(nameParser.Drive());

        iCurrentAppNameAndExt.Append(nameParser.NameAndExt());

        // do not try to launch these apps

        if (iAppsArray->MdcaPoint(iAppLaunchCounter).FindF(_L("\\Launcher.")) != KErrNotFound

            || iAppsArray->MdcaPoint(iAppLaunchCounter).FindF(_L("\\Phone.")) != KErrNotFound

            || iAppsArray->MdcaPoint(iAppLaunchCounter).FindF(_L("\\Startup.")) != KErrNotFound  

            || iAppsArray->MdcaPoint(iAppLaunchCounter).FindF(_L("\\SplashScreen.")) != KErrNotFound  

            || iAppsArray->MdcaPoint(iAppLaunchCounter).FindF(_L("\\eshell.")) != KErrNotFound)  

            {

            iContainerOutput->PrintTextL(iCurrentAppNameAndExt);

            iContainerOutput->PrintTextL(_L(": SKIPPED automatically\n"));

            iLogWriteBuf->Des().Append(_L("[SKIPPED automatically] "));

            iLogWriteBuf->Des().Append(KFileNewLine);

            iLogFile.Write(iLogWriteBuf->Des());

            iSkippedCases++;

            CheckForMoreAppsL();

            }

        else

            {

            // dependency check not needed if the app is in the ROM/ROFS, because they'll be checked automatically

            // when the rom image is built

            if (iCurrentAppNameAndExt[0] != 'Z' && iCurrentAppNameAndExt[0] != 'z')

                {

                if (iCurrentAppNameAndExt[2] == '[')  // this is quite likely a Java application, no dependency test needed 

                    {

                    iLogWriteBuf->Des().Append(_L("[Dependency check not done] "));

                    }

                else

                    {  // otherwise check depencies

                    #ifdef __WINS__

                        // emulator not supported