/*

* Copyright (c) 2010 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 <coemain.h>

#include <eikenv.h>

#include <pathinfo.h> 

#include <apgtask.h>

#include <bautils.h>

#include "launchertraces.h"

#include "e32image.h"

#include "launcherxmlparser.h"

#include "launcherdllparser.h"

#include "launcherengine.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");

_LIT(KNewLine, "\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(MLauncherUI *aLauncherUI)

    {

    CLauncherEngine* self = new(ELeave) CLauncherEngine;

    CleanupStack::PushL(self);

    self->ConstructL(aLauncherUI);

    CleanupStack::Pop();

    return self;

    }

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

CLauncherEngine::CLauncherEngine() : CActive(EActivePriorityIpcEventsHigh)

    {

    }

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

template <typename T>

void AppendLogBufferL(const TDesC& aText, T*& aBuf, TInt aIncreaseStep = KLauncherLogBufferSize)

    {

    if( aBuf == 0 )

        {

        aBuf = T::NewL(aIncreaseStep);

        }

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

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

        {

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

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

        }

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

    }

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

void CLauncherEngine::ConstructL(MLauncherUI *aLauncherUI)

    {

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

    User::LeaveIfNull( aLauncherUI );

    iLauncherUI = aLauncherUI;

    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::DoCancel()

    {

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

    if( iXMLParser )

        {

        iXMLParser->Cancel();

        }

    iTimer.Cancel();

    }

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

void CLauncherEngine::RunL()

    {

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

    TInt err = iStatus.Int();

    User::LeaveIfError(err);

    // 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)  

        {

        iLauncherUI->PrintText(iCurrentAppNameAndExt);

        iLauncherUI->PrintText(_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

                #else

                    // ELF binaries

                    CDesCArray* missingDllArray = NULL;

                    TRAPD(err, missingDllArray = DependencyCheckForE32ImageL());

                    // some error happened while processing the E32 image

                    if (err != KErrNone)

                        {

                        iLauncherUI->PrintText(iCurrentAppNameAndExt);

                        iLauncherUI->PrintText(_L(": unable to read import table!\n"));

                        iLogWriteBuf->Des().Append(_L("[Unable to read import table!] "));

                        }

                    // print missing dependencies

                    else if (err==KErrNone && missingDllArray)

                        {

                        if (missingDllArray->MdcaCount() > 0)

                            {

                            iLauncherUI->PrintText(iCurrentAppNameAndExt);

                            iLauncherUI->PrintText(_L(": missing dependencies: "));

                            iLogWriteBuf->Des().Append(_L("[Missing dependencies: "));

                            for (TInt k=0; k<missingDllArray->MdcaCount(); k++)

                                {

                                iLauncherUI->PrintText(missingDllArray->MdcaPoint(k));

                                iLauncherUI->PrintText(_L(" "));

                                iLogWriteBuf->Des().Append(missingDllArray->MdcaPoint(k));

                                iLogWriteBuf->Des().Append(_L(" "));

                                }

                            iLauncherUI->PrintText(_L("\n"));

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

                            }

                        }

                    if (missingDllArray)

                        delete missingDllArray;

                #endif

                }  // if '['

            }  // if 'Z'

        // check if the app is already running

        TApaTaskList taskList(iWs);

        TApaTask thisTask = taskList.FindApp(iCurrentAppUid);

        if (thisTask.Exists())

            {

            iLogWriteBuf->Des().Append(_L(" [OK: App already running]"));

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

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

            iOkCases++;

            CheckForMoreAppsL();

            }

        else

            {

            // check the program's capabilities

            TApaAppCapabilityBuf buf;

            iLs.GetAppCapability(buf, iCurrentAppUid);

            TApaAppCapability cap = buf();

            // if it's embeddable only, don't launch if setting is enabled

            if (cap.iEmbeddability == TApaAppCapability::EEmbeddableOnly && SkipHiddenAndEmbedOnly())  

                {

                iLauncherUI->PrintText(iCurrentAppNameAndExt);

                iLauncherUI->PrintText(_L(": SKIPPED: embeddable only\n"));

                iLogWriteBuf->Des().Append(_L("[SKIPPED: embeddable only] "));

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

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

                iSkippedCases++;

                CheckForMoreAppsL();

                }

            // if it's hidden, don't launch if setting is enabled

            else if (cap.iAppIsHidden && SkipHiddenAndEmbedOnly())  

                {

                iLauncherUI->PrintText(iCurrentAppNameAndExt);

                iLauncherUI->PrintText(_L(": SKIPPED: hidden\n"));

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

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

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

                iSkippedCases++;

                CheckForMoreAppsL();

                }

            // otherwise do the normal launch test

            else

                {

                LaunchApplicationL();

                }

            } //if (thisTask.Exists())

        } //if (iAppsArray->MdcaPoint(iAppLaunchCounter).FindF

    }

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

CDesCArray* CLauncherEngine::ListOfAllAppsL()

    {

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

    // 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();

    return iAllAppsArray;

    }

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

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;

    }

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

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");

        iLauncherUI->ShowErrorMessage(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...");

            iLauncherUI->ShowErrorMessage(message);

            }

        // 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);

            }