/*

* 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 FILES

#include <apmrec.h>

#include <ecom/implementationproxy.h>

#include <e32debug.h>

#include <startupdomainpskeys.h>

#include "toolsstarterautolaunch.h"

#include "logging.h"

#define KPSDelay 500000

// CONSTANTS

const static TUint KToolsStarterAutoLaunchImplUid = 0x200170B9;

const static TUid KToolsStarterAutoLaunchUid = {0x200170B8};

_LIT(KToolsStarterServerExe, "toolsstarterserver.exe");

const TUid KToolsStarterServerExeUid = {0x200170B5};

_LIT( KToolsStarterMatchPattern, "toolsstarterserver**" );

const TImplementationProxy ImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY( KToolsStarterAutoLaunchImplUid,

    		CToolsStarterAutoLaunch::CreateRecognizerL )

    };

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

EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )

    {

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

    }

CApaDataRecognizerType* CToolsStarterAutoLaunch::CreateRecognizerL()

    {

	LOG_MSG("CToolsStarterAutoLaunch::CreateRecognizerL");

	CApaDataRecognizerType* recognizer = new (ELeave) CToolsStarterAutoLaunch();

	CToolsStarterAutoLaunch::CreateAutoStartThreadL();

    return recognizer;

    }

CToolsStarterAutoLaunch::CToolsStarterAutoLaunch() :

    CApaDataRecognizerType( KToolsStarterAutoLaunchUid, CApaDataRecognizerType::ENormal )

    {

    iCountDataTypes = 1;

    }

TUint CToolsStarterAutoLaunch::PreferredBufSize()

    {

    return 0;

    }

TDataType CToolsStarterAutoLaunch::SupportedDataTypeL( TInt /*aIndex*/ ) const

    {

    return TDataType();

    }

void CToolsStarterAutoLaunch::DoRecognizeL( const TDesC& /*aName*/, const TDesC8& /*aBuffer*/ )

    {

    }

void CToolsStarterAutoLaunch::CreateAutoStartThreadL()

    {

    LOG_MSG("CToolsStarterAutoLaunch::CreateAutoStartThread");

    //create a new thread for starting our application

    RThread startAppThread;

    User::LeaveIfError( startAppThread.Create(

        _L( "ToolsStarterAutoLaunch" ),

        CToolsStarterAutoLaunch::StartAppThreadFunction,

        KDefaultStackSize,

        KMinHeapSize,

        KMinHeapSize,

        NULL,

        EOwnerThread ) );

    startAppThread.SetPriority( EPriorityNormal );

    startAppThread.Resume();

    startAppThread.Close();

    }

TInt CToolsStarterAutoLaunch::StartAppThreadFunction( TAny* /*aParam*/ )

    {

    LOG_MSG("CToolsStarterAutoLaunch::StartAppThreadFunction");

     // create a trap cleanup and active scheduler

    CTrapCleanup* pC = CTrapCleanup::New();

    //CActiveScheduler* pS = new CActiveScheduler;

    //CActiveScheduler::Install(pS);

    if (pC==NULL)// || pS==NULL)

        LOG_MSG("Failed to create the trapcleanup and active scheduler");

            // create a server starter instance

    CToolsStarterLauncher* serverStarter = NULL;

    TRAPD(err, serverStarter = CToolsStarterLauncher::NewL());

    if (err == KErrNone)

    	{

	    // wait for UI to be up

	   // serverStarter->WaitForUiServices();

		// now start the toolsstarter server

		serverStarter->StartServer();

		delete serverStarter;	    

	   	}    

  	delete pC;

  	//delete pS;

    return KErrNone;

    }

CToolsStarterLauncher* CToolsStarterLauncher::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CToolsStarterLauncher::CToolsStarterLauncher()

    {

    }

CToolsStarterLauncher::~CToolsStarterLauncher()

    {

    }

void CToolsStarterLauncher::ConstructL()

    {

    }

void CToolsStarterLauncher::StartServer()

    {

    LOG_MSG("CToolsStarterLauncher::StartServer");

    // check if toolsstarter is already running

    TFullName processName;

    TFindProcess finder( KToolsStarterMatchPattern );

    TInt err = finder.Next( processName );

    if ( err == KErrNone )

        {

        LOG_MSG("KToolsStarterMatchPattern server already running");

        return;

        }

    // otherwise create a new process

    RProcess pr;

    err = pr.Create(KToolsStarterServerExe, TPtr(NULL, 0), TUidType(KNullUid, KNullUid, KToolsStarterServerExeUid));

    if ( err == KErrNone )

        {

        LOG_MSG("CToolsStarterLauncher::StartServer process created");

        pr.Resume();

        pr.Close();

        }

    else

        {

        LOG_MSG2("CToolsStarterLauncher::StartServer Could not create process %d", err);

        }

    }

void CToolsStarterLauncher::WaitForUiServices()

    {

    LOG_MSG("ToolsStarter Launcher: WaitForUiServices");

    RProperty property;

    TInt err = KErrNotReady;

    while ( err != KErrNone )

        {

        User::After(KPSDelay); // Wait for the startup to define the key

        err = property.Attach(KPSUidStartup, KPSGlobalSystemState);

        LOG_MSG2("ToolsStarter Launcher: WaitForUiServices attach err %d \n", err);

        }

    // Wait for the correct startup state

    TRequestStatus status;

    property.Subscribe(status);

    TInt state = 0;

    err = property.Get(state);

    LOG_MSG3("ToolsStarter Launcher: WaitForUiServices state %d err %d \n", state, err);

    while ( err == KErrNone &&

            !( state == ESwStateCriticalPhaseOK ||

               state == ESwStateNormalRfOn ||

               state == ESwStateNormalRfOff ||

               state == ESwStateNormalBTSap ) )

        {

        state = 0; // Reset previous value

        User::WaitForRequest(status);

        err = status.Int();

        if ( err == KErrNone )

            {

            property.Subscribe( status );

            err = property.Get( state );

            }

        LOG_MSG3("ToolsStarter Launcher: WaitForUiServices state changed %d err %d", state, err);

        }

    property.Cancel();

    property.Close();

    LOG_MSG("ToolsStarter Launcher: WaitForUiServices end");

    }