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

 *

 */

	// boolean value that is set to false, when heap type is not symbian OS

	// Rheap

	// Strings

	private final static String LAUNCHER_READY = "<MEMSPY_LAUNCHER_READY>";

	private final static String MEMSPY_LAUNCHER_VERSION_PREFIX = "<MEMSPY_LAUNCHER_DATAVERSION=";// e.g.

	// <MEMSPY_LAUNCHER_VERSION=1>

	private final static String END_TAG = ">";

	private final static String LAUNCHER_COLON = "::";

	private final static String LAUNCHER_THREAD_ID = "Thread Id";

	private final static String LAUNCHER_TYPE = "Type:";

	private final static String LAUNCHER_SYMBIAN_OS_RHEAP = "Symbian OS RHeap";

	private final static String LAUNCHER_SYMBIAN_OS_RHYBRIDHEAP = "Symbian OS RHybridHeap";

	private final static String LAUNCHER_HEAP_DUMP_START = "<MEMSPY_HEAP_DATA";

	private final static String LAUNCHER_HEAP_DUMP_END = "</MEMSPY_HEAP_DATA";

	// Heap info's will act as start point for new Head dump, when Head Dumps

	// are received during SWMT logging

	// E.g. following Heap info is received:

	// HeapData - mc_isiserver::Main - HEAP INFO FOR THREAD 'mc_isiserver::Main'

	private final static String LAUNCHER_HEAP_INFO_FOR_THREAD = "HEAP INFO FOR THREAD";

	private final static String LAUNCHER_HEAPDATA = "HeapData -";

	private final static String LAUNCHER_ERROR = "<MEMSPY_LAUNCHER_ERROR>";

	private final static String DUMPED_TC_TRACES = "* Dumped Traces";

	private final static String MEMSPY_PROGRESS = "<MEMSPY_PROGRESS>";

	 * <code>SYSTEM WIDE MEMORY TRACKER<code> tag

	public final static String LAUNCHER_SWMT_LOG_START = "<SYSTEM WIDE MEMORY TRACKER>";

	private final static String LAUNCHER_SWMT_LOG_END = "</SYSTEM WIDE MEMORY TRACKER>";

	private final static String LAUNCHER_SWMTDATA = "[SMT ";

	private final static String LAUNCHER_CATEGORY_NOT_SUPPORTED = "<MEMSPY_LAUNCHER_CATEGORY_NOT_SUPPORTED>";

	private ThreadInfo swmtHeadDumpThreadInfo;

	 * 

	 * @param engine

	 *            engine that uses handler

	public TraceCoreDataHandler(TraceCoreEngine engine) {

	 * Method that is called when trace logging is started.

	 * 

	 * @param fName

	 *            Name of the file, where needed information is printed.

	 * @param fileOpen

	 *            boolean value that is true when file needs to be opened.

		DbgUtility

				.println(

						DbgUtility.PRIORITY_OPERATION,

						"TraceCoreDataHandler.startLogging/fName=" + fName + ", fileOpen=" + fileOpen); //$NON-NLS-1$ //$NON-NLS-2$

		if (fileOpen) {

				plainOutput = new PrintWriter(new FileWriter(fName));

			} catch (IOException e) {

		DbgUtility.println(DbgUtility.PRIORITY_OPERATION,

				"TraceCoreDataHandler.stopLogging"); //$NON-NLS-1$				

		if (this.fileOpen) {

		if (swmtHeadDumpOutput != null) {

	private void startSWMTHeadDumpLogging() {

			if (!path.exists()) {

			if (swmtHeadDumpThreadInfo != null) {

				swmtHeadDumpOutput = new PrintWriter(new FileWriter(

						swmtHeadDumpThreadInfo.getThreadFilePath()));

		} catch (IOException e) {

		}

	 * Processes trace data that is received. This method is called every time

	 * trace data is received when logging is on.

	 * 

	 * @param traceLineStr

	 *            trace data line

				if (isMemSpyRelatedLine(traceLineStr)) {

					lineCount++;

				if (lineCount > 10) {

				if (traceLineStr.contains(LAUNCHER_ERROR)) {

					handleLauncherErrorLine(traceLineStr);

				else if (traceLineStr.contains(DUMPED_TC_TRACES)) {

				// If line contains confirmation that Launcher is ready to

				// receive new command

				else if (traceLineStr.contains(LAUNCHER_READY)) {

				} else if (traceLineStr

						.contains(MEMSPY_LAUNCHER_VERSION_PREFIX)) {

				// If launcher sends an progress message, restarting error timer

				// so the timer wont reset progress

				// this is done because of long taking progress was causing time

				// outs.

				else if (traceLineStr.contains(MEMSPY_PROGRESS)) {

				else if (engine.getFirstTask() == TraceCoreEngine.MEMSPY_GET_HEAP_DUMP) {

				else if (engine.getFirstTask() == TraceCoreEngine.MEMSPY_SWMT_UPDATE

						|| engine.getFirstTask() == TraceCoreEngine.MEMSPY_SWMT_RESET) {

					handleSWMTLine(traceLineStr);

				}

				else if (engine.getFirstTask() == TraceCoreEngine.MEMSPY_THREAD_INFO) {

				else if (engine.getFirstTask() == TraceCoreEngine.MEMSPY_SET_CATEGORIES_LOW) {

				else if (engine.getFirstTask() == TraceCoreEngine.MEMSPY_SET_CATEGORIES_HIGH) {

				else if (engine.getFirstTask() == TraceCoreEngine.MEMSPY_THREAD_LIST) {

	 * 

	 * @param str

	 *            line sting

	 * @return <code>true</code> if MemSpy related data, otherwise

	 *         <code>false</code>.

		DbgUtility

				.println(DbgUtility.PRIORITY_LOOP,

						"TraceCoreDataHandler.processData/MEMSPY_LAUNCHER_VERSION_PREFIX"); //$NON-NLS-1$

		DbgUtility.println(DbgUtility.PRIORITY_OPERATION,

				"TraceCoreDataHandler.processData/LAUNCHER_READY"); //$NON-NLS-1$

		DbgUtility.println(DbgUtility.PRIORITY_OPERATION,

				"TraceCoreDataHandler.processData/DUMPED_TC_TRACES"); //$NON-NLS-1$

		DbgUtility.println(DbgUtility.PRIORITY_OPERATION,

				"TraceCoreDataHandler.processData/LAUNCHER_ERROR"); //$NON-NLS-1$

		if (str.contains("'")) {

			str = str.substring(str.indexOf("'") + 1);

			if (str.contains("'")) {

				String error = str.substring(0, str.indexOf("'"));

		} else {

			// If no error code present, then parsing custom error message and

			// sending information to console

			if (splitArr.length == 2) {

			engine.launcherError(LauncherErrorType.GENERAL_LAUNCHER_ERROR,

					additionalErrorInfo);

		if (str.contains(LAUNCHER_COLON)) {

		// Save threadID into latest ThreadInfo-object and add info into thread

		// list

		if (str.contains(LAUNCHER_THREAD_ID)) {

			if (lastWasName) {

				String threadID = str.substring(str.indexOf(LAUNCHER_THREAD_ID)

						+ LAUNCHER_THREAD_ID.length());

				threadInfo.setThreadID(threadID);

				threadArray.add(threadInfo);

				DbgUtility

						.println(

								DbgUtility.PRIORITY_OPERATION,

								"TraceCoreDataHandler.processData/LAUNCHER_THREAD_ID/id=" + threadInfo.getThreadID() + ", name=" + threadInfo.getThreadName()); //$NON-NLS-1$ //$NON-NLS-2$

		DbgUtility

				.println(

						DbgUtility.PRIORITY_OPERATION,

						"TraceCoreDataHandler.processData/MEMSPY_SET_CATEGORIES_HIGH:  " + str); //$NON-NLS-1$

		DbgUtility

				.println(

						DbgUtility.PRIORITY_OPERATION,

						"TraceCoreDataHandler.processData/MEMSPY_SET_CATEGORIES_LOW:  " + str); //$NON-NLS-1$

		if (str.contains(LAUNCHER_CATEGORY_NOT_SUPPORTED)) {

			// LAUNCHER_CATEGORY_NOT_SUPPORTED error

		if (str.contains(LAUNCHER_TYPE)) {

			if (str.contains(LAUNCHER_SYMBIAN_OS_RHEAP)

					|| str.contains(LAUNCHER_SYMBIAN_OS_RHYBRIDHEAP)) {

				DbgUtility.println(DbgUtility.PRIORITY_OPERATION,

						"TraceCoreDataHandler.processData/MEMSPY_THREAD_INFO"); //$NON-NLS-1$

		if (str.contains(LAUNCHER_SWMT_LOG_START)) {

			DbgUtility.println(DbgUtility.PRIORITY_OPERATION,

					"TraceCoreDataHandler.processData/LAUNCHER_SWMT_LOG_START"); //$NON-NLS-1$

			engine.restartErrorTimer(); // Resetting error time instantly when

			// getting start event of the logging

		if (this.writeFile && str.contains(LAUNCHER_SWMTDATA)) {

			this.writeLine(str);

		if (this.writeFile

				&& (str.contains(LAUNCHER_HEAPDATA)

						|| str.contains(LAUNCHER_HEAP_DUMP_START) || str

						.contains(LAUNCHER_HEAP_DUMP_END))) {

		}

		if (str.contains(LAUNCHER_SWMT_LOG_END)) {

			DbgUtility.println(DbgUtility.PRIORITY_OPERATION,

					"TraceCoreDataHandler.processData/LAUNCHER_SWMT_LOG_END"); //$NON-NLS-1$

			engine.restartErrorTimer(); // Resetting error time instantly when

			// getting end event of the logging

	 * 

		// If we receiving a start point of Dump..

		if (str.contains(LAUNCHER_HEAP_DUMP_START)) {

			DbgUtility.println(DbgUtility.PRIORITY_LOOP,

					"TraceCoreDataHandler.processData/Start SWMT Head Dump"); //$NON-NLS-1$

			if (threadArray == null) {

		// If we receiving a Thread name of Dump, we create a new file for dump,

		// and start dumping it

		else if (str.contains(LAUNCHER_HEAP_INFO_FOR_THREAD)) {

			DbgUtility

					.println(

							DbgUtility.PRIORITY_LOOP,

							"TraceCoreDataHandler.processData/SWMT Head Dump Thread name received: " + threadName); //$NON-NLS-1$

			// String threadName, String threadID, String threadFilePath, Date

			// date, HeapDumpType type

			String filePath = MemSpyFileOperations.getFileNameForTempHeapDump(

					swmtHeadDumpThreadInfo.getThreadName(),

					swmtHeadDumpThreadInfo.getDate());

			DbgUtility

					.println(

							DbgUtility.PRIORITY_LOOP,

							"TraceCoreDataHandler.processData/SWMT Head Dump Thread file created: " + filePath); //$NON-NLS-1$			

			// Heap info's will act as start point for new Head dump, when Head

			// Dumps are received during SWMT logging

			// E.g. following Heap info is received:

			// HeapData - mc_isiserver::Main - HEAP INFO FOR THREAD

			// 'mc_isiserver::Main'

		// If we receiving a end point of Dump...

		else if (str.contains(LAUNCHER_HEAP_DUMP_END)) {

			DbgUtility.println(DbgUtility.PRIORITY_LOOP,

					"TraceCoreDataHandler.processData/End SWMT Head Dump"); //$NON-NLS-1$

			threadArray.add(swmtHeadDumpThreadInfo);

		// Else we receiving a dump line, and writing it to the Dump file, not

		// to SWMT file

		else if (swmtHeadDumpThreadInfo != null && swmtHeadDumpOutput != null) {

		} else {

			DbgUtility

					.println(

							DbgUtility.PRIORITY_LOOP,

							"TraceCoreDataHandler.processData/LAUNCHER_HEAPDATA & MEMSPY_SWMT_UPDATE unknown line occured: "

									+ str);