/*
* 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: 
*
*/

#ifndef LAUNCHERENGINE_H
#define LAUNCHERENGINE_H

#include <e32base.h>
#include <apgcli.h>
#include <w32std.h>
#include <e32std.h>
#include <e32hal.h>

#include "launcherparserobserver.h"

// CONSTANTS
// None

// MACROS
// None

// DATA TYPES
// None

// FUNCTION PROTOTYPES
// None

// FORWARD DECLARATIONS
class CEikonEnv;
class CAppThreadChecker;
class CAppRunningChecker;
class CLauncherXMLParser;
class CLauncherDLLParser;


// INFERFACE FOR COMMUNICATION WITH UI

class MLauncherUI
{
public:
    /**
     * Method for writing text to output window.
     * @param aText A text to be written.
     * @return None.
     */
    virtual void PrintText(const TDesC& aText) = 0;

    /**
     * Shows info message with text
     * @param aText An text to be shown in message.
     * @return None.
     */
    virtual void ShowInfoMessage(const TDesC& aText) = 0;
    
    /**
     * Shows error message with error text
     * @param aText An error text to be shown in message.
     * @return None.
     */
    virtual void ShowErrorMessage(const TDesC& aText) = 0;
    
    /**
     * Shows progress bar with text
     * @param aText A text to be shown at top of the progress bar.
     * @param aMinimum A minimum progress bar value.
     * @param aMaximum A maximum progress bar value.
     * @return None.
     */
    virtual void ShowProgressBar(const TDesC& aText, TInt aMinimum, TInt aMaximum ) = 0;

    /**
     * Sets progress bar value
     * @param aValue A value between min and max value of the progress bar range
     * @return None.
     */
    virtual void SetProgressBarValue(TInt aValue) = 0;

    /**
     * Hides progress bar
     * @return None.
     */
    virtual void HideProgressBar() = 0;

    /**
     * Shows wait dialog with text
     * @param aText A text to be shown at top of the wait bar.
     * @return None.
     */
    virtual void ShowWaitDialog(const TDesC& aText) = 0;

    /**
     * Hides wait dialog
     * @return None.
     */
    virtual void HideWaitDialog() = 0;
    
    /**
     * Changes focus to output view
     * @return None.
     */
    virtual void ChangeFocusToOutputView() = 0;
    
};

// CLASS DECLARATION

class CLauncherEngine: public CActive, public MLauncherParserObserver
{

public:
    static CLauncherEngine* NewL(MLauncherUI *aLauncherUI);
    ~CLauncherEngine();
    CDesCArray* ListOfAllAppsL();
    void StartAppLaunchingL(const CArrayFix<TInt>* aSelectedApps, TBool aAutoClose);
    void CheckIfAppIsRunningL();
    void CheckWhyThreadDiedL();
    void StopLaunchingL();
    TBool LogFileExists();
    TBool BCLogFileExists();
    
    TInt DeleteLogFile();
    TInt DeleteBCLogFile();
    
    void AnalyseDLLsL( const TDesC& aFileName );
    
    void ElementParsedL(const CLauncherDLLElement& aDllElement);
    void DocumentParsedL(TInt aErrorCode);
    void ParsingProgressedL(TInt aBytes);
    TInt ReadLineFromFileL(RFile& aFile, TDes& aReadBuf);
    
    const TDesC& RequiredDllsFilePath() const { return iRequiredDllsFilePath; };
    
    void CancelBCAnalysis();
    
private:
    CLauncherEngine();
    void ConstructL(MLauncherUI *aLauncherUI);
    
    void RunL();
    void DoCancel();
        
    TInt FindFiles(const TDesC& aFileName, const TDesC& aPath);
    void IssueLaunch();
    void WriteInitialStuffToTheLogL(const TDesC& aOwnData, RFile& aFile);
    void CheckForMoreAppsL();
    void LaunchApplicationL();
    void DoLaunchApplicationL();
    CDesCArray* DependencyCheckForE32ImageL();

    /**
     * Performs binary compatibility analysis based on reference data given
     * in XML-file.
     */
    void DoBCAnalysisL();
    
    /**
     * Compares given DLL list to system DLLs
     */
    void DoCompareDLLListsL();
    
private:

    MLauncherUI *iLauncherUI;
    
    RTimer          iTimer;
    CEikonEnv*      iEnv;
    RApaLsSession   iLs;
    RWsSession      iWs;
    HBufC8*         iLogWriteBuf;    
    RFile           iLogFile;
    RFile           iBCLogFile;  
    TFileName       iLogFilePath;
    TFileName       iBCLogFilePath;
    TFileName       iSystemDllsFilePath;
    TFileName       iRequiredDllsFilePath;        
        
    CDesCArray*     iAppsArray;
    CDesCArray*     iAllAppsArray;
    CDesCArray*     iSystemDllArray;
//  CDesCArray*     iRequiredDllArray;

    TBool           iLaunchingIsActive;
    TBool           iDLLAnalysisIsActive;
    TBool           iSkipHiddenAndEmbedOnly;
    TBool           iAutoClose;
    TInt            iAppLaunchCounter;
    TInt            iFailedCases;
    TInt            iOkCases;
    TInt            iSkippedCases;
    TInt            iTotalNumberOfCases;

    TUid            iCurrentAppUid;
    TThreadId       iCurrentAppThreadId;
    TBuf<128>       iCurrentAppNameAndExt;
    RThread         iCurrentAppThread;
//
    CAppThreadChecker*          iAppThreadChecker;
    CAppRunningChecker*         iAppRunningChecker;

    CLauncherXMLParser*     iXMLParser;
    CLauncherDLLParser*     iDLLParser;
    CLauncherDLLElement*    iDLLElement;
    
    TInt                iFoundBCIssues;
    HBufC*              iBCIssuesBigBuffer;

        
public:
    inline TBool SkipHiddenAndEmbedOnly()              { return iSkipHiddenAndEmbedOnly; };
    inline void SetSkipHiddenAndEmbedOnly(TBool aSkip) { iSkipHiddenAndEmbedOnly = aSkip; };
    inline const TDesC& LogFilePath() { return iLogFilePath; }
    inline const TDesC& BCLogFilePath() { return iBCLogFilePath; }
    inline const TDesC& SystemDllsFilePath() { return iSystemDllsFilePath; }
};



class CAppRunningChecker : public CActive
    {
public:
    static CAppRunningChecker* NewL(CLauncherEngine* aLauncherEngine);
    ~CAppRunningChecker();

    void StartTesting();

private:
    CAppRunningChecker();
    void ConstructL(CLauncherEngine* aLauncherEngine);

    void RunL();
    void DoCancel();

private:
    RTimer iTimer;
    CEikonEnv* iEnv;
    CLauncherEngine* iLauncherEngine;
    };

class CAppThreadChecker : public CActive
    {
public:
    static CAppThreadChecker* NewL(CLauncherEngine* aLauncherEngine);
    ~CAppThreadChecker();

    void ActivateChecking();
    void CheckIfAppIsRunningL();

private:
    CAppThreadChecker();
    void ConstructL(CLauncherEngine* aLauncherEngine);

    void RunL();
    void DoCancel();

private:
    CEikonEnv* iEnv;
    CLauncherEngine* iLauncherEngine;
    };


#endif //LAUNCHERENGINE_H