/*------------------------------------------------------------------

 -

 * Software Name : UserEmulator

 * Version       : v4.2.1309

 * 

 * Copyright (c) 2009 France Telecom. All rights reserved.

 * This software is distributed under the License 

 * "Eclipse Public License - v 1.0" the text of which is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * France Telecom 

 *

 * Contributors:

 *------------------------------------------------------------------

 -

 * File Name: ThreadNotifier.cpp

 * 

 * Created: 13/08/2009

 * Author(s): Marcell Kiss, Reshma Sandeep Das

 *   

 * Description:

 * Active object implementation for capturing panics

 *------------------------------------------------------------------

 -

 *

 */

//System Includes

#include <icl\ImageData.h>

#include <icl\ImageCodecData.h>

#include <coemain.h>

#include <PathInfo.h>

#include <bautils.h>

#include <apgwgnam.h>

// User Includes

#include "ThreadNotifier.h"

//Constants

_LIT(KTHREADPANICMSG, "THREAD-NOTIFIER");

_LIT(KKill,"Kill");

_LIT(KTerminate,"Terminate");

_LIT(KPanic,"Panic");

_LIT(KPending,"Pending");

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

// CThreadNotifier::NewL

// Creates the instance of class and returns it.

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

//

CThreadNotifier* CThreadNotifier::NewL(MPanicObserver& aObserver, CLogger& aLogger,

                                        CSettings& aSettings, CEikonEnv* aEikonEnv)

{

	CThreadNotifier* self=CThreadNotifier::NewLC(aObserver,aLogger,aSettings,aEikonEnv);

	CleanupStack::Pop(); // self;

	return self;

}

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

// CThreadNotifier::NewLC

// Creates the instance of class and pushes it to the CleanupStack and return

// it.

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

//

CThreadNotifier* CThreadNotifier::NewLC(MPanicObserver& aObserver, CLogger& aLogger,

                                            CSettings& aSettings, CEikonEnv* aEikonEnv)

{

	CThreadNotifier* self = new (ELeave)CThreadNotifier(aObserver,aLogger,aSettings,aEikonEnv);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

}

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

// CThreadNotifier::CThreadNotifier

// Calls base classes constructor with priority value. Add class to the 

// active sheduler.

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

//

CThreadNotifier::CThreadNotifier(MPanicObserver& aObserver, CLogger& aLogger, CSettings& aSettings,

                                                                               CEikonEnv* aEikonEnv)

    : CActive(CActive::EPriorityStandard), iThreadHandle(0),

      iObserver(aObserver), iLogger(aLogger), iSettings(aSettings), iEEnv(aEikonEnv)   

{

    CActiveScheduler::Add(this);

}

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

// CThreadNotifier::ConstructL

// Construction of parser and buffer allocations

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

//

void CThreadNotifier::ConstructL()

{

    User::LeaveIfError(iUndertaker.Create());

}

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

// CThreadNotifier::~CThreadNotifier

// Cancels any outstanding requests and deletes members.

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

//

CThreadNotifier::~CThreadNotifier()

{

    Cancel();

}

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

// CThreadNotifier::IssueRequest

// Function to issues a request for notification of the death of a thread.

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

// 

void CThreadNotifier::IssueRequest()

{

    __ASSERT_ALWAYS(!IsActive(), User::Panic(KTHREADPANICMSG, 0));

    iUndertaker.Logon(iStatus, iThreadHandle);

    SetActive();

}

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

// CThreadNotifier::RunL

// From CActive. Handles the state changes and notifing the observer.

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

//

void CThreadNotifier::RunL()

{

    if (iStatus == KErrDied)

    {

        RThread thread;

        thread.SetHandle(iThreadHandle);

        CleanupClosePushL(thread);

        TExitCategoryName categ = thread.ExitCategory();

		TBuf<KBuffer1024> buf;

		_LIT(KPanicFormat, "*PANIC* Thread %S (%d) died (ExitType:%S, Reason:%S-%d)\n");

		ExitType(thread.ExitType());

		if(thread.ExitType() != 0)

		{

		    iObserver.PanicOccured();

			buf.Format(KPanicFormat, &thread.Name(), (int)thread.Id(), &iExitType,&categ,thread.ExitReason());

			iLogger.WriteLogL(buf,EFalse);

			//Capture a screenshot

			CApaWindowGroupName* gn = CApaWindowGroupName::NewLC(iEEnv->WsSession(), iEEnv->WsSession().GetFocusWindowGroup());

			TUid id = gn->AppUid().Null(); 

			CleanupStack::PopAndDestroy(gn);

			CImageCapture* imageCapture = CImageCapture::NewL(iSettings,*this,iEEnv);

			imageCapture->CaptureL(thread.Name(),KN,id);

		}								    

        thread.Close();

        CleanupStack::PopAndDestroy();//thread

        IssueRequest();

    }   

}

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

// CThreadNotifier::PerformNextAction

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

//

void CThreadNotifier::PerformNextAction(TInt aInterval)

{

    iObserver.RestartRandomTests();

}

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

// CThreadNotifier::ExitType

//  Function that indicates the exit type of the thread

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

//

void CThreadNotifier::ExitType(TInt aExitType)

{

	switch(aExitType)

	{

		case EExitKill:

			iExitType.Copy(KKill);

			break;

		case EExitTerminate:

			iExitType.Copy(KTerminate);

			break;

		case EExitPanic:

			iExitType.Copy(KPanic);

			break;

		case EExitPending:

			iExitType.Copy(KPending);

			break;

	}

}

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

// CThreadNotifier::DoCancel

// From CActive. Cancels any outstanding request according the engine state.

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

//

void CThreadNotifier::DoCancel()

{

    TInt res = iUndertaker.LogonCancel();

    if(res!=-2)

    	iUndertaker.Close();

}