FCL/sftools/ana/dynaanaapps: comparison crashanalysis/crashanalyser/com.nokia.s60tools.crashanalyser/src/com/nokia/s60tools/crashanalyser/files/SummaryFile.java

equal deleted inserted replaced

-:431bbaccaec8
+:615035072f7e
 import java.io.*;
 import javax.xml.parsers.*;
 import org.eclipse.jface.resource.ImageDescriptor;
 import org.eclipse.ui.*;
 import org.w3c.dom.*;
+import com.nokia.s60tools.crashanalyser.containers.OstTrace;
 import com.nokia.s60tools.crashanalyser.containers.RegisterDetails;
 import com.nokia.s60tools.crashanalyser.containers.CodeSegment;
 import com.nokia.s60tools.crashanalyser.containers.Message;
 import com.nokia.s60tools.crashanalyser.containers.EventLog;
 import com.nokia.s60tools.crashanalyser.containers.Process;
 * A summary file is a crash file which has not been fully decoded.
 * A summary file has been decoded without symbol information and it therefore
 * does not contain stack information. A summary file is a base class for CrashFile.
 *
 */
-public class SummaryFile extends CrashAnalyserFile implements IEditorInput {
+public class SummaryFile extends CrashAnalyserFile implements IEditorInput, Cloneable {
+	public enum ContentType {CRASH, REGMSG, REPORT};
 	// XML tags
 	public static final String TAG_SYMBOL_SET = "symbol_set";
 	public static final String TAG_SYMBOL = "symbol";
 	public static final String TAG_SOURCE = "source";
 	public static final String TAG_ID = "id";
 	public static final String TAG_STACK_ENTRY = "stack_entry";
 	public static final String TAG_CODESEG = "codeseg";
 	public static final String TAG_REGISTER_SET = "register_set";
 	public static final String TAG_SEG_EVENT_LOG = "seg_event_log";
+	public static final String TAG_SEG_TRACES = "seg_traces";
 	public static final String TAG_MESSAGE = "message";
 	public static final String TAG_VI_ENTRY = "vi_entry";
 	public static final String TAG_SOURCE_INFO = "source_info";
 	public static final String TAG_TYPE = "type";
 	public static final String TAG_SEGMENT = "segment";
 	protected Map<Integer, Message> messages = null;
 	protected Map<Integer, Stack> stacks = null;
 	protected Map<Integer, RegisterSet> registerSets = null;
 	protected List<RegisterDetails> registerDetails = null;
 	protected EventLog eventLog = null;
+	protected OstTrace ostTrace = null;
 	protected Summary crashSummary = null;
 	protected String sourceFileType = "";
 	protected String sourceFileName = "";
 	protected String sourceFilePath = "";
 	/**
 	 * Constructor
 	 * @param filePath file path to this crash file
 	 * @param library error library
 	 */
 	protected SummaryFile(String filePath, ErrorLibrary library) {
 		super(filePath, library);
 	}
 	/**
+	 * Constructor
+	 * @param filePath file path to this crash file
+	 * @param library error library
+	 */
+	protected SummaryFile(String filePath, ErrorLibrary library, Thread thread) {
+		super(filePath, library);
+		threadInfo = thread;
+	}
+	public Object clone() {
+		SummaryFile newSummaryFile = null;
+		try {
+			// Just shallow copy (i.e. no need to read information from file)
+			newSummaryFile = (SummaryFile) super.clone();
+		} catch (CloneNotSupportedException ex) {
+			// ignore
+		}
+		return newSummaryFile;
+	}
+	/**
 	 * Returns the file type of this crash file.
 	 * @return "Decoded File"
 	 */
 	public String getFileType() {
 		return "Partially Decoded File";
 		return sourceFileName;
 	}
 	public String getSourceFilePath() {
 		return sourceFilePath;
+	}
+	public void setThread(Thread thread) {
+		threadInfo = thread;
+		panicCategory = threadInfo.getExitCategory();
+		panicCode = threadInfo.getExitReason();
+		threadName = threadInfo.getFullName();
 	}
 	public List<Stack> getStandAloneStacks() {
 		if (stacks != null && !stacks.isEmpty()) {
 			return new ArrayList<Stack>(stacks.values());
 		}
 		return false;
 	}
 	/**
+	 * Returns the content type of the file.
+	 * @return Returns crash/registration/report. If not found returns crash.
+	 */
+	public ContentType getContentType() {
+		List<Message> msgs = getMessages();
+		if (msgs != null && !msgs.isEmpty()) {
+			for (int i = 0; i < msgs.size(); i++) {
+				if (Message.MessageTypes.MESSAGE.equals(msgs.get(i).getMessageType()) &&
+						msgs.get(i).getTitle().equals("MobileCrash content type")) {
+					if(msgs.get(i).getMessage().equals("registration"))
+						return ContentType.REGMSG;
+					else if (msgs.get(i).getMessage().equals("report"))
+						return ContentType.REPORT;
+				}
+			}
+		}
+		// Returns crash by default.
+		return ContentType.CRASH;
+	}
+	/**
 	 * Returns all messages
 	 * @return all messages
 	 */
 	public List<Message> getMessages() {
 		List<Message> msgs = new ArrayList<Message>();
 		file.doRead();
 		return file;
 	}
 	/**
+	 * Reads crash file
+	 * @param folder where xml file is
+	 * @param library error library
+	 * @param thread thread
+	 * @return read crash file or null
+	 */
+	public static SummaryFile read(String folder, ErrorLibrary library, Thread thread) {
+		String summaryFile = findFile(folder,"xml");
+		// summary file doesn't exist
+		if (summaryFile == null)
+			return null;
+		SummaryFile file = new SummaryFile(summaryFile, library, thread);
+		file.doRead();
+		return file;
+	}
+		/**
 	 * Writes crash file into text or html file
 	 * @param filePathWithoutFileName file path where file is to be written to
 	 * @param html if false a .txt file is created. if true a .html file is created
 	 */
 	public void writeTo(String filePathWithoutFileName, boolean html) {
 							writeLine(out, "Stack Pointer", thread.getStackPointer());
 							writeLine(out, "Link Register", thread.getLinkRegister());
 							writeLine(out, "Program Counter", thread.getProgramCounter());
 							panicDescription = thread.getPanicDescription();
 						}
+					} else if (threadInfo != null) {
+						Process threadProcess = getProcessByThread(threadInfo.getId());
+						if (threadProcess != null)
+							writeLine(out, "Process", threadProcess.getName());
+						writeLine(out, "Thread", threadInfo.getFullName());
+						writeLine(out, "Stack Pointer", threadInfo.getStackPointer());
+						writeLine(out, "Link Register", threadInfo.getLinkRegister());
+						writeLine(out, "Program Counter", threadInfo.getProgramCounter());
+						panicDescription = threadInfo.getPanicDescription();
 					}
 					// write crash summary to file
 					if (crashSummary != null) {
 						crashSummary.writeTo(out);
 					// write event log to file
 					if (eventLog != null)
 						eventLog.writeTo(out);
+					// write OST trace to file
+					if (ostTrace != null)
+						ostTrace.writeTo(out);
 					// write process data to file
 					if (process != null) {
 						process.writeTo(out, Process.StackItems.ALL, html);
 						out.newLine();
 					}
 			nl = docEle.getElementsByTagName(TAG_SEG_EVENT_LOG);
 			if (nl != null && nl.getLength() > 0) {
 				eventLog = EventLog.read((Element)nl.item(0));
 			}
+			// read OST traces
+			nl = docEle.getElementsByTagName(TAG_SEG_TRACES);
+			if (nl != null && nl.getLength() > 0) {
+				ostTrace = OstTrace.read((Element)nl.item(0));
+			}
 			// read messages from xml
 			nl = docEle.getElementsByTagName(TAG_MESSAGE);
 			if (nl != null && nl.getLength() > 0) {
 				for (int i = 0; i < nl.getLength(); i++) {
 					Element el = (Element)nl.item(i);
 			if (!"".equals(crashSummary.getCrashDate()) && !"".equals(crashSummary.getCrashTime()))
 				time = crashSummary.getCrashDate() + " " + crashSummary.getCrashTime();
 			// set panic data
 			Process process = getCrashedProcess();
+			processCount = getProcessCount();
 			if (process != null) {
 				Thread firstThread = process.getFirstThread();
 				if (firstThread != null) {
 					panicCategory = firstThread.getExitCategory();
 					panicCode = firstThread.getExitReason();
 					threadName = firstThread.getFullName();
 				}
+			} else if (threadInfo != null) {
+				panicCategory = threadInfo.getExitCategory();
+				panicCode = threadInfo.getExitReason();
+				threadName = threadInfo.getFullName();
 			}
 			formatDescription();
 		}catch(Exception e) {
 			e.printStackTrace();
 	}
 	/**
 	 * Formats a description for this crash.
 	 */
-	void formatDescription() {
+	public void formatDescription() {
 		Thread thread = null;
+		if (threadInfo != null) {
+			thread = threadInfo;
+		}
 		// get the first thread of the first process
-		if (processes != null && !processes.isEmpty()) {
+		else if (processes != null && !processes.isEmpty()) {
-			Process[] processesArray = processes.values().toArray(new Process[processes.values().size()]);
+			thread = getCrashedThread();
-			Process process = processesArray[0];
+		}
-			thread = process.getFirstThread();
-		}
+		if (thread != null) {
+			description = HtmlFormatter.formatCrashFileDescription(crashSummary, getMessages(), thread);
-		description = HtmlFormatter.formatCrashFileDescription(crashSummary, getMessages(), thread);
+			shortDescription = HtmlFormatter.formatCrashFileDescription(crashSummary, null, thread);
-		shortDescription = HtmlFormatter.formatCrashFileDescription(crashSummary, null, thread);
+		}
 	}
 	public Summary getSummary() {
 		return crashSummary;
 	}
 	 * Get crashed process
 	 *
 	 * @return first process or null
 	 */
 	public Process getCrashedProcess() {
+		if (threadInfo != null) {
+			return null;
+		}
 		Process crashedProcess = null;
 		if (processes != null && !processes.isEmpty()) {
 			Process[] processesArray = processes.values().toArray(new Process[processes.values().size()]);
 			for (Process process : processesArray) {
 				for (Thread thread : process.getThreads()) {
 			}
 		}
 		return crashedProcess;
 	}
+	/**
+	 * Get crashed process
+	 *
+	 * @return first crashed thread
+	 */
+	public Thread getCrashedThread() {
+		if (threadInfo != null) {
+			return null;
+		}
+		Thread crashedThread = null;
+		if (processes != null && !processes.isEmpty()) {
+			Process[] processesArray = processes.values().toArray(new Process[processes.values().size()]);
+			for (Process process : processesArray) {
+				for (Thread thread : process.getThreads()) {
+					String exitType = thread.getExitType();
+					if (exitType.equalsIgnoreCase("Panic") || exitType.equalsIgnoreCase("Exception")) {
+						crashedThread = thread;
+						break;
+					}
+				}
+			}
+		}
+		return crashedThread;
+	}
+	/**
+	 * Get process by thread id
+	 *
+	 * @return Found process or null
+	 */
+	public Process getProcessByThread(int threadId) {
+		Process threadProcess = null;
+		if (processes != null && !processes.isEmpty()) {
+			Process[] processesArray = processes.values().toArray(new Process[processes.values().size()]);
+			for (Process process : processesArray) {
+				for (Thread thread : process.getThreads()) {
+					//String exitType = thread.getExitType();
+					if (thread.getId() == threadId) {
+						threadProcess = process;
+						break;
+					}
+				}
+			}
+		}
+		return threadProcess;
+	}
+	/**
+	 * Get process count
+	 *
+	 * @return the number of processes or -1 if not available
+	 */
+	public int getProcessCount()
+	{
+		if (processes == null) {
+			processCount = -1;
+		}
+		else {
+			processCount = processes.size();
+		}
+		return processCount;
+	}
+	/**
+	 * Get process count
+	 *
+	 * @return the number of threads or -1 if not available
+	 */
+	public int getTotalThreadCount()
+	{
+		totalThreadCount = 0;
+		if (processes == null) {
+			return  -1;
+		}
+		for(Process process : processes.values()) {
+			totalThreadCount += process.getThreads().size();
+		}
+		return totalThreadCount;
+	}
+	/**
+	 * Returns all threads
+	 *
+	 * @return all threads in all processes
+	 */
+	public List<Thread> getThreads() {
+		List<Thread> allThreads = new ArrayList<Thread>();
+		for(Process process : processes.values()) {
+			allThreads.addAll(process.getThreads());
+		}
+		return allThreads;
+	}
 	public EventLog getEventLog() {
 		return eventLog;
 	}
+	public OstTrace getOstTrace() {
+		return ostTrace;
+	}
 	public List<RegisterDetails> getRegisterDetails() {
 		return registerDetails;
 	}
 	public boolean exists() {

changeset 4	615035072f7e
parent 0	5ad7ad99af01
child 16	72f198be1c1d