/*

* Copyright (c) 2007 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 <apgtask.h>        //TApaTask

#include <apgcli.h>         //RApaLsSession

#include "aiscuttargetshutter.h"

#include "aiscutdefs.h"

#include "debug.h"

#include <AknSgcc.h>

const TUid KMenuUID3 = { 0x101F4CD2 }; 

const TInt KTaskExistsDelay = 1500000; //1.5 second

const TInt KTaskNotExistsDelay = 500000; //0.5 second

const TInt KMaxNumberOfTries = 3;

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

CAiScutTargetShutter::CAiScutTargetShutter(CCoeEnv* aEnv, TUid aAppUid)

    : CActive(CActive::EPriorityLow)

    , iEnv(aEnv)

    , iAppUid(aAppUid)

{

    CActiveScheduler::Add(this);

}

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

//

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

//

CAiScutTargetShutter::~CAiScutTargetShutter()

{

    if (iPeriodic)

    {

        iPeriodic->Cancel();

        delete iPeriodic;

    }

    iWsSession.Close();

    Cancel();

}

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

//

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

//

void CAiScutTargetShutter::ConstructL(TBool aIsRunning, TBool aIsDialog)

{

    iIsRunning = aIsRunning;

    iIsDialog = aIsDialog;

    iTaskExists = EFalse;

    iTaskKilled = EFalse;

    iCounter = 0;

    iPeriodic = CPeriodic::NewL(CActive::EPriorityLow);

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

}

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

//

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

//

CAiScutTargetShutter* CAiScutTargetShutter::NewL(CCoeEnv* aEnv, TUid aAppUid, TBool aIsRunning, TBool aIsDialog)

{

    CAiScutTargetShutter* self = new (ELeave) CAiScutTargetShutter(aEnv, aAppUid);

    CleanupStack::PushL(self);

    self->ConstructL(aIsRunning, aIsDialog);

    CleanupStack::Pop(self);

    return self;

}

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

//

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

//

void CAiScutTargetShutter::StartL()

{

	__PRINT( __DBG_FORMAT( "XAI: CAiScutTargetShutter::Start() app uid=0x%x"), iAppUid.iUid);

    TApaTaskList taskList(iWsSession);

    TApaTask idleTask(taskList.FindApp(KScutActiveIdleUid));

    if ( idleTask.Exists() && iIsRunning)

    {

        if ( iIsDialog )

            {

            TKeyEvent keyEvent;

            keyEvent.iCode = EKeyEscape;

            keyEvent.iModifiers = 0;

            keyEvent.iRepeats = 0;

            iEnv->SimulateKeyEventL(keyEvent, EEventKey);            

            }

        //idleTask.BringToForeground();

        CAknSgcClient::MoveApp(idleTask.WgId(), ESgcMoveAppToForeground);

        iTaskExists = ETrue;               

		__PRINTS( "XAI:   exists and running");

    }

    else

    {

        TKeyEvent keyEvent;

        keyEvent.iCode = EKeyEscape;

        keyEvent.iModifiers = 0;

        keyEvent.iRepeats = 0;

        iEnv->SimulateKeyEventL(keyEvent, EEventKey);

        // bring active idle to foreground

        TApaTask idleTask(taskList.FindApp(KScutActiveIdleUid));

        if (idleTask.Exists())

        {

			__PRINTS("XAI:   idle to foreground");

            //idleTask.BringToForeground();

            CAknSgcClient::MoveApp(idleTask.WgId(), ESgcMoveAppToForeground);

        }

        TApaTask task(taskList.FindApp(iAppUid));

		if (task.Exists())

        {

			//task.SendToBackground();

			CAknSgcClient::MoveApp(task.WgId(), ESgcMoveAppToBackground);

        }

    }

	if( !iPeriodic->IsActive() )

	{

	    if (iTaskExists)

    	{

            iPeriodic->Start(KTaskExistsDelay, KTaskExistsDelay,

                TCallBack(TaskExistsCallback, this));

    	}

    	else

	    {

            iPeriodic->Start(KTaskNotExistsDelay, KTaskNotExistsDelay,

                TCallBack(TaskNotExistsCallback, this));

    	}

	}

}

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

// From CActive

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

//

void CAiScutTargetShutter::DoCancel()

{

    if (iPeriodic)

    {

        iPeriodic->Cancel();

    }

}

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

// From CActive.

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

//

void CAiScutTargetShutter::RunL()

{

	__PRINT( __DBG_FORMAT( "XAI: CAiScutTargetShutter::RunL() app uid=0x%x"), iAppUid.iUid);	

	TUid menuUid = KMenuUID3;

    TApaTaskList taskList(iWsSession);

    TApaTask task(taskList.FindApp(iAppUid));

    if (iTaskExists)

    {

        RWindowGroup windowGroup = iEnv->RootWin();

        if (windowGroup.OrdinalPosition() != 0)

        {

            TApaTask idleTask(taskList.FindApp(KScutActiveIdleUid));

            if (idleTask.Exists())

            {

			__PRINTS( "XAI:   idle to foreground");

                //idleTask.BringToForeground();

                CAknSgcClient::MoveApp(idleTask.WgId(), ESgcMoveAppToForeground);

            }

        }

        iPeriodic->Cancel();

    }

    else

    {

        if (iCounter >= KMaxNumberOfTries || iTaskKilled)

        {

            iPeriodic->Cancel();

        }

        else if (task.Exists() && iAppUid != menuUid)        

        {

			__PRINTS("XAI:   shutdown task");

			//task.SendToBackground();

			CAknSgcClient::MoveApp(task.WgId(), ESgcMoveAppToBackground);

            task.SendSystemEvent(EApaSystemEventShutdown);

            iTaskKilled = ETrue;

        }

        else

        {

            iCounter++;

        }

    }

}

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

// From CActive

// Handles an error situation.

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

//

TInt CAiScutTargetShutter::RunError(TInt aError)

{

    return aError;

}

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

//

//

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

//

void CAiScutTargetShutter::Run()

{

    SetActive();

    TRequestStatus *status = &iStatus;

    User::RequestComplete(status, KErrNone);

}

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

//

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

//

TInt CAiScutTargetShutter::TaskExistsCallback(TAny* aPtr)

{

    CAiScutTargetShutter* self = static_cast<CAiScutTargetShutter*>(aPtr);

    if (self)

    {

        self->Run();

    }

    return KErrNone;

}

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

//

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

//

TInt CAiScutTargetShutter::TaskNotExistsCallback(TAny* aPtr)

{

    CAiScutTargetShutter* self = static_cast<CAiScutTargetShutter*>(aPtr);

    if (self)

    {

        self->Run();

    }

    return KErrNone;

}

// End of File.