//
// Copyright 2005 The Android Open Source Project
//
// Display runtime log output.
//
// For compilers that support precompilation, include "wx/wx.h".
#include "wx/wxprec.h"
// Otherwise, include all standard headers
#ifndef WX_PRECOMP
# include "wx/wx.h"
#endif
#include "wx/image.h" // needed for Windows build
#include "wx/dcbuffer.h"
#include "LogWindow.h"
#include "LogMessage.h"
#include "LogPrefsDialog.h"
#include "MyApp.h"
#include "Preferences.h"
#include "Resource.h"
#include "UserEventMessage.h"
#include <errno.h>
static int android_snprintfBuffer(char** pBuf, int bufLen, const char* format, ...);
static int android_vsnprintfBuffer(char** pBuf, int bufLen, const char* format, va_list args);
using namespace android;
#if 0 // experiment -- works on Win32, but not with GTK
class MyTextCtrl : public wxTextCtrl {
public:
MyTextCtrl(wxWindow* parent, wxWindowID id, const wxString& value,
const wxPoint& pos, const wxSize& size, int style = 0)
: wxTextCtrl(parent, id, value, pos, size, style)
{
printf("***************** MyTextCtrl!\n");
}
void OnScroll(wxScrollWinEvent& event);
void OnScrollBottom(wxScrollWinEvent& event);
private:
DECLARE_EVENT_TABLE()
};
BEGIN_EVENT_TABLE(MyTextCtrl, wxTextCtrl)
EVT_SCROLLWIN(MyTextCtrl::OnScroll)
EVT_SCROLLWIN_BOTTOM(MyTextCtrl::OnScrollBottom)
END_EVENT_TABLE()
void MyTextCtrl::OnScroll(wxScrollWinEvent& event)
{
printf("OnScroll!\n");
}
void MyTextCtrl::OnScrollBottom(wxScrollWinEvent& event)
{
printf("OnScrollBottom!\n");
}
#endif
BEGIN_EVENT_TABLE(LogWindow, wxDialog)
EVT_CLOSE(LogWindow::OnClose)
EVT_MOVE(LogWindow::OnMove)
EVT_COMBOBOX(IDC_LOG_LEVEL, LogWindow::OnLogLevel)
EVT_BUTTON(IDC_LOG_CLEAR, LogWindow::OnLogClear)
EVT_BUTTON(IDC_LOG_PAUSE, LogWindow::OnLogPause)
EVT_BUTTON(IDC_LOG_PREFS, LogWindow::OnLogPrefs)
END_EVENT_TABLE()
/*
* Information about log levels.
*
* Each entry here corresponds to an entry in the combo box. The first
* letter of each name should be unique.
*/
static const struct {
wxString name;
android_LogPriority priority;
} gLogLevels[] = {
{ wxT("Verbose"), ANDROID_LOG_VERBOSE },
{ wxT("Debug"), ANDROID_LOG_DEBUG },
{ wxT("Info"), ANDROID_LOG_INFO },
{ wxT("Warn"), ANDROID_LOG_WARN },
{ wxT("Error"), ANDROID_LOG_ERROR }
};
/*
* Create a new LogWindow. This should be a child of the main frame.
*/
LogWindow::LogWindow(wxWindow* parent)
: wxDialog(parent, wxID_ANY, wxT("Log Output"), wxDefaultPosition,
wxDefaultSize,
wxCAPTION | wxSYSTEM_MENU | wxCLOSE_BOX | wxRESIZE_BORDER),
mDisplayArray(NULL), mMaxDisplayMsgs(0), mPaused(false),
mMinPriority(ANDROID_LOG_VERBOSE),
mHeaderFormat(LogPrefsDialog::kHFFull),
mSingleLine(false), mExtraSpacing(0), mPointSize(10), mUseColor(true),
mFontMonospace(true), mWriteFile(false), mTruncateOld(true), mLogFp(NULL),
mNewlyShown(false), mLastPosition(wxDefaultPosition), mVisible(false)
{
ConstructControls();
Preferences* pPrefs = ((MyApp*)wxTheApp)->GetPrefs();
int poolSize = 10240; // 10MB
pPrefs->GetInt("log-pool-size-kbytes", &poolSize);
assert(poolSize > 0);
mPool.Resize(poolSize * 1024);
mMaxDisplayMsgs = 1000;
pPrefs->GetInt("log-display-msg-count", &mMaxDisplayMsgs);
assert(mMaxDisplayMsgs > 0);
mDisplayArray = new LogMessage*[mMaxDisplayMsgs];
memset(mDisplayArray, 0, sizeof(LogMessage*) * mMaxDisplayMsgs);
mTopPtr = -1;
mNextPtr = 0;
int tmpInt = (int) mHeaderFormat;
pPrefs->GetInt("log-header-format", &tmpInt);
mHeaderFormat = (LogPrefsDialog::HeaderFormat) tmpInt;
pPrefs->GetBool("log-single-line", &mSingleLine);
pPrefs->GetInt("log-extra-spacing", &mExtraSpacing);
pPrefs->GetInt("log-point-size", &mPointSize);
pPrefs->GetBool("log-use-color", &mUseColor);
pPrefs->SetBool("log-font-monospace", &mFontMonospace);
SetTextStyle();
mFileName = wxT("/tmp/android-log.txt");
pPrefs->GetBool("log-write-file", &mWriteFile);
pPrefs->GetString("log-filename", /*ref*/mFileName);
pPrefs->GetBool("log-truncate-old", &mTruncateOld);
PrepareLogFile();
}
/*
* Destroy everything we own.
*/
LogWindow::~LogWindow(void)
{
ClearDisplay();
delete[] mDisplayArray;
if (mLogFp != NULL)
fclose(mLogFp);
}
/*
* Set the text style, based on our preferences.
*/
void LogWindow::SetTextStyle(void)
{
wxTextCtrl* pTextCtrl;
pTextCtrl = (wxTextCtrl*) FindWindow(IDC_LOG_TEXT);
wxTextAttr style;
style = pTextCtrl->GetDefaultStyle();
if (mFontMonospace) {
wxFont font(mPointSize, wxFONTFAMILY_MODERN, wxFONTSTYLE_NORMAL,
wxFONTWEIGHT_NORMAL);
style.SetFont(font);
} else {
wxFont font(mPointSize, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL,
wxFONTWEIGHT_NORMAL);
style.SetFont(font);
}
pTextCtrl->SetDefaultStyle(style);
}
/*
* Set up the goodies in the window.
*
* Also initializes mMinPriority.
*/
void LogWindow::ConstructControls(void)
{
Preferences* pPrefs = ((MyApp*)wxTheApp)->GetPrefs();
wxPanel* base = new wxPanel(this, wxID_ANY);
wxBoxSizer* masterSizer = new wxBoxSizer(wxVERTICAL);
wxBoxSizer* indentSizer = new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer* configPrioritySizer = new wxBoxSizer(wxHORIZONTAL);
wxGridSizer* configSizer = new wxGridSizer(4, 1);
/*
* Configure log level combo box.
*/
wxComboBox* logLevel;
int defaultLogLevel = 1;
pPrefs->GetInt("log-display-level", &defaultLogLevel);
logLevel = new wxComboBox(base, IDC_LOG_LEVEL, wxT(""),
wxDefaultPosition, wxDefaultSize, 0, NULL,
wxCB_READONLY /*| wxSUNKEN_BORDER*/);
for (int i = 0; i < NELEM(gLogLevels); i++) {
logLevel->Append(gLogLevels[i].name);
logLevel->SetClientData(i, (void*) gLogLevels[i].priority);
}
logLevel->SetSelection(defaultLogLevel);
mMinPriority = gLogLevels[defaultLogLevel].priority;
/*
* Set up stuff at the bottom, starting with the options
* at the bottom left.
*/
configPrioritySizer->Add(new wxStaticText(base, wxID_ANY, wxT("Log level:"),
wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT),
0, wxALIGN_CENTER_VERTICAL);
configPrioritySizer->AddSpacer(kInterSpacing);
configPrioritySizer->Add(logLevel);
wxButton* clear = new wxButton(base, IDC_LOG_CLEAR, wxT("&Clear"),
wxDefaultPosition, wxDefaultSize, 0);
wxButton* pause = new wxButton(base, IDC_LOG_PAUSE, wxT("&Pause"),
wxDefaultPosition, wxDefaultSize, 0);
wxButton* prefs = new wxButton(base, IDC_LOG_PREFS, wxT("C&onfigure"),
wxDefaultPosition, wxDefaultSize, 0);
configSizer->Add(configPrioritySizer, 0, wxALIGN_LEFT);
configSizer->Add(clear, 0, wxALIGN_CENTER);
configSizer->Add(pause, 0, wxALIGN_CENTER);
configSizer->Add(prefs, 0, wxALIGN_RIGHT);
/*
* Create text ctrl.
*/
wxTextCtrl* pTextCtrl;
pTextCtrl = new wxTextCtrl(base, IDC_LOG_TEXT, wxT(""),
wxDefaultPosition, wxDefaultSize,
wxTE_MULTILINE | wxTE_READONLY | wxTE_RICH2 | wxTE_NOHIDESEL |
wxHSCROLL);
/*
* Add components to master sizer.
*/
masterSizer->AddSpacer(kEdgeSpacing);
masterSizer->Add(pTextCtrl, 1, wxEXPAND);
masterSizer->AddSpacer(kInterSpacing);
masterSizer->Add(configSizer, 0, wxEXPAND);
masterSizer->AddSpacer(kEdgeSpacing);
/*
* Indent from sides.
*/
indentSizer->AddSpacer(kEdgeSpacing);
indentSizer->Add(masterSizer, 1, wxEXPAND);
indentSizer->AddSpacer(kEdgeSpacing);
base->SetSizer(indentSizer);
indentSizer->Fit(this); // shrink-to-fit
indentSizer->SetSizeHints(this); // define minimum size
}
/*
* In some cases, this means the user has clicked on our "close" button.
* We don't really even want one, but both WinXP and KDE put one on our
* window whether we want it or not. So, we make it work as a "hide"
* button instead.
*
* This also gets called when the app is shutting down, and we do want
* to destroy ourselves then, saving various information about our state.
*/
void LogWindow::OnClose(wxCloseEvent& event)
{
/* just hide the window, unless we're shutting down */
if (event.CanVeto()) {
event.Veto();
Show(false);
return;
}
/*
* Save some preferences.
*/
SaveWindowPrefs();
/* if we can't veto the Close(), destroy ourselves */
Destroy();
}
/*
* Save all of our preferences to the config file.
*/
void LogWindow::SaveWindowPrefs(void)
{
Preferences* pPrefs = ((MyApp*)wxTheApp)->GetPrefs();
/*
* Save shown/hidden state.
*/
pPrefs->SetBool("window-log-show", IsShown());
/*
* Limits and formatting prefs.
*/
pPrefs->SetInt("log-display-msg-count", mMaxDisplayMsgs);
pPrefs->SetInt("log-pool-size-kbytes", mPool.GetMaxSize() / 1024);
pPrefs->SetInt("log-header-format", mHeaderFormat);
pPrefs->SetBool("log-single-line", mSingleLine);
pPrefs->SetInt("log-extra-spacing", mExtraSpacing);
pPrefs->SetInt("log-point-size", mPointSize);
pPrefs->SetBool("log-use-color", mUseColor);
pPrefs->SetBool("log-font-monospace", mFontMonospace);
pPrefs->SetBool("log-write-file", mWriteFile);
pPrefs->SetString("log-filename", mFileName.ToAscii());
pPrefs->SetBool("log-truncate-old", mTruncateOld);
/*
* Save window size and position.
*/
wxPoint posn;
wxSize size;
assert(pPrefs != NULL);
posn = GetPosition();
size = GetSize();
pPrefs->SetInt("window-log-x", posn.x);
pPrefs->SetInt("window-log-y", posn.y);
pPrefs->SetInt("window-log-width", size.GetWidth());
pPrefs->SetInt("window-log-height", size.GetHeight());
/*
* Save current setting of debug level combo box.
*/
wxComboBox* pCombo;
int selection;
pCombo = (wxComboBox*) FindWindow(IDC_LOG_LEVEL);
selection = pCombo->GetSelection();
pPrefs->SetInt("log-display-level", selection);
}
/*
* Return the desired position and size.
*/
/*static*/ wxRect LogWindow::GetPrefWindowRect(void)
{
Preferences* pPrefs = ((MyApp*)wxTheApp)->GetPrefs();
int x, y, width, height;
assert(pPrefs != NULL);
x = y = 10;
width = 500;
height = 200;
/* these don't modify the arg if the pref doesn't exist */
pPrefs->GetInt("window-log-x", &x);
pPrefs->GetInt("window-log-y", &y);
pPrefs->GetInt("window-log-width", &width);
pPrefs->GetInt("window-log-height", &height);
return wxRect(x, y, width, height);
}
/*
* Under Linux+GTK, the first time you show the window, it appears where
* it's supposed to. If you then hide it and show it again, it gets
* moved on top of the parent window. After that, you can reposition it
* and it remembers its position across hide/show.
*
* To counter this annoyance, we save the position when we hide, and
* reset the position after a show. The "newly shown" flag ensures that
* we only reposition the window as the result of a Show(true) call.
*
* Sometimes, something helpful will shift the window over if it's
* partially straddling a seam between two monitors. I don't see an easy
* way to block this, and I'm not sure I want to anyway.
*/
void LogWindow::OnMove(wxMoveEvent& event)
{
wxPoint point;
point = event.GetPosition();
//printf("Sim: log window is at (%d,%d) (new=%d)\n", point.x, point.y,
// mNewlyShown);
if (mNewlyShown) {
if (mLastPosition == wxDefaultPosition) {
//printf("Sim: no last position established\n");
} else {
Move(mLastPosition);
}
mNewlyShown = false;
}
}
/*
* Set the "newly shown" flag.
*/
bool LogWindow::Show(bool show)
{
if (show) {
mNewlyShown = true;
Redisplay();
} else {
mLastPosition = GetPosition();
}
mVisible = show;
return wxDialog::Show(show);
}
/*
* User has adjusted the log level. Update the display appropriately.
*
* This is a wxEVT_COMMAND_COMBOBOX_SELECTED event.
*/
void LogWindow::OnLogLevel(wxCommandEvent& event)
{
int selection;
android_LogPriority priority;
selection = event.GetInt();
wxComboBox* pCombo = (wxComboBox*) FindWindow(IDC_LOG_LEVEL);
priority = (android_LogPriority) (long)pCombo->GetClientData(event.GetInt());
printf("Sim: log level selected: %d (%s)\n", (int) priority,
(const char*) gLogLevels[selection].name.ToAscii());
mMinPriority = priority;
Redisplay();
}
/*
* Clear out the log.
*/
void LogWindow::OnLogClear(wxCommandEvent& event)
{
ClearDisplay();
mPool.Clear();
}
/*
* Handle the pause/resume button.
*
* If we're un-pausing, we need to get caught up.
*/
void LogWindow::OnLogPause(wxCommandEvent& event)
{
mPaused = !mPaused;
wxButton* pButton = (wxButton*) FindWindow(IDC_LOG_PAUSE);
if (mPaused) {
pButton->SetLabel(wxT("&Resume"));
mPool.SetBookmark();
} else {
pButton->SetLabel(wxT("&Pause"));
LogMessage* pMsg = mPool.GetBookmark();
if (pMsg == NULL) {
/* bookmarked item fell out of pool */
printf("--- bookmark was lost, redisplaying\n");
Redisplay();
} else {
/*
* The bookmark points to the last item added to the display.
* We want to chase its "prev" pointer to walk toward the head
* of the list, adding items from oldest to newest.
*/
pMsg = pMsg->GetPrev();
while (pMsg != NULL) {
if (FilterMatches(pMsg))
AddToDisplay(pMsg);
pMsg = pMsg->GetPrev();
}
}
}
}
/*
* Open log preferences dialog.
*/
void LogWindow::OnLogPrefs(wxCommandEvent& event)
{
LogPrefsDialog dialog(this);
/*
* Set up the dialog.
*/
dialog.mHeaderFormat = mHeaderFormat;
dialog.mSingleLine = mSingleLine;
dialog.mExtraSpacing = mExtraSpacing;
dialog.mPointSize = mPointSize;
dialog.mUseColor = mUseColor;
dialog.mFontMonospace = mFontMonospace;
dialog.mDisplayMax = mMaxDisplayMsgs;
dialog.mPoolSizeKB = mPool.GetMaxSize() / 1024;
dialog.mWriteFile = mWriteFile;
dialog.mFileName = mFileName;
dialog.mTruncateOld = mTruncateOld;
/*
* Show it. If they hit "OK", copy the updated values out, and
* re-display the log output.
*/
if (dialog.ShowModal() == wxID_OK) {
/* discard old display arra */
ClearDisplay();
delete[] mDisplayArray;
mHeaderFormat = dialog.mHeaderFormat;
mSingleLine = dialog.mSingleLine;
mExtraSpacing = dialog.mExtraSpacing;
mPointSize = dialog.mPointSize;
mUseColor = dialog.mUseColor;
mFontMonospace = dialog.mFontMonospace;
assert(dialog.mDisplayMax > 0);
assert(dialog.mPoolSizeKB > 0);
mMaxDisplayMsgs = dialog.mDisplayMax;
mPool.Resize(dialog.mPoolSizeKB * 1024);
mWriteFile = dialog.mWriteFile;
if (mLogFp != NULL && mFileName != dialog.mFileName) {
printf("--- log file name changed, closing\n");
fclose(mLogFp);
mLogFp = NULL;
}
mFileName = dialog.mFileName;
mTruncateOld = dialog.mTruncateOld;
mDisplayArray = new LogMessage*[mMaxDisplayMsgs];
memset(mDisplayArray, 0, sizeof(LogMessage*) * mMaxDisplayMsgs);
Redisplay();
PrepareLogFile();
}
}
/*
* Handle a log message "user event". This should only be called in
* the main UI thread.
*
* We take ownership of "*pLogMessage".
*/
void LogWindow::AddLogMessage(LogMessage* pLogMessage)
{
mPool.Add(pLogMessage);
if (!mPaused && mVisible && FilterMatches(pLogMessage)) {
/*
* Thought: keep a reference to the previous message. If it
* matches in most fields (all except timestamp?), hold it and
* increment a counter. If we get a message that doesn't match,
* or a timer elapses, synthesize a "previous message repeated N
* times" string.
*/
AddToDisplay(pLogMessage);
}
// release the initial ref caused by allocation
pLogMessage->Release();
if (mLogFp != NULL)
LogToFile(pLogMessage);
}
/*
* Clear out the display, releasing any log messages held in the display
* array.
*/
void LogWindow::ClearDisplay(void)
{
wxTextCtrl* pTextCtrl;
pTextCtrl = (wxTextCtrl*) FindWindow(IDC_LOG_TEXT);
pTextCtrl->Clear();
/*
* Just run through the entire array.
*/
for (int i = 0; i < mMaxDisplayMsgs; i++) {
if (mDisplayArray[i] != NULL) {
mDisplayArray[i]->Release();
mDisplayArray[i] = NULL;
}
}
mTopPtr = -1;
mNextPtr = 0;
}
/*
* Clear the current display and regenerate it from the log pool. We need
* to do this whenever we change filters or log message formatting.
*/
void LogWindow::Redisplay(void)
{
/*
* Freeze output rendering so it doesn't flash during update. Doesn't
* seem to help for GTK, and it leaves garbage on the screen in WinXP,
* so I'm leaving it commented out.
*/
//wxTextCtrl* pText = (wxTextCtrl*) FindWindow(IDC_LOG_TEXT);
//pText->Freeze();
//printf("--- redisplay\n");
ClearDisplay();
/*
* Set up the default wxWidgets text style stuff.
*/
SetTextStyle();
/*
* Here's the plan:
* - Start at the head of the pool (where the most recently added
* items are).
* - Check to see if the current item passes our filter. If it does,
* increment the "found count".
* - Continue in this manner until we run out of pool or have
* sufficient items to fill the screen.
* - Starting from the current position, walk back toward the head,
* adding the items that meet the current filter criteria.
*
* Don't forget that the log pool could be empty.
*/
LogMessage* pMsg = mPool.GetHead();
if (pMsg != NULL) {
int foundCount = 0;
// note this stops before it runs off the end
while (pMsg->GetNext() != NULL && foundCount < mMaxDisplayMsgs) {
if (FilterMatches(pMsg))
foundCount++;
pMsg = pMsg->GetNext();
}
while (pMsg != NULL) {
if (FilterMatches(pMsg))
AddToDisplay(pMsg);
pMsg = pMsg->GetPrev();
}
}
//pText->Thaw();
}
/*
* Returns "true" if the currently specified filters would allow this
* message to be shown.
*/
bool LogWindow::FilterMatches(const LogMessage* pLogMessage)
{
if (pLogMessage->GetPriority() >= mMinPriority)
return true;
else
return false;
}
/*
* Realloc the array of pointers, and remove anything from the display
* that should no longer be there.
*/
void LogWindow::SetMaxDisplayMsgs(int max)
{
Preferences* pPrefs = ((MyApp*)wxTheApp)->GetPrefs();
pPrefs->SetInt("log-display-msg-count", max);
}
/*
* Add the message to the display array and to the screen.
*/
void LogWindow::AddToDisplay(LogMessage* pLogMessage)
{
wxTextCtrl* pTextCtrl;
pTextCtrl = (wxTextCtrl*) FindWindow(IDC_LOG_TEXT);
if (mNextPtr == mTopPtr) {
/*
* The display array is full.
*
* We need to eliminate the topmost entry. This requires removing
* it from the array and removing the text from the wxTextCtrl.
*/
pTextCtrl->Remove(0, mDisplayArray[mTopPtr]->GetTextCtrlLen());
mDisplayArray[mTopPtr]->Release();
mTopPtr = (mTopPtr + 1) % mMaxDisplayMsgs;
}
/*
* Add formatted text to the text ctrl. Track how much actual space
* is required. The space may be different on Win32 (CRLF-based) vs.
* GTK (LF-based), so we need to measure it, not compute it from the
* text string.
*/
long lastBefore, lastAfter;
//long insertBefore;
//insertBefore = pTextCtrl->GetInsertionPoint();
lastBefore = pTextCtrl->GetLastPosition();
FormatMessage(pLogMessage, pTextCtrl);
lastAfter = pTextCtrl->GetLastPosition();
pLogMessage->SetTextCtrlLen(lastAfter - lastBefore);
/*
* If we restore the old insertion point, we will be glued to where
* we were. This is okay until we start deleting text from the top,
* at which point we need to adjust it to retain our position.
*
* If we set the insertion point to the bottom, we effectively
* implement "scroll to bottom on output".
*
* If we don't set it at all, we get slightly strange behavior out
* of GTK, which seems to be par for the course here.
*/
//pTextCtrl->SetInsertionPoint(insertBefore); // restore insertion pt
pTextCtrl->SetInsertionPoint(lastAfter);
/* add it to array, claim ownership */
mDisplayArray[mNextPtr] = pLogMessage;
pLogMessage->Acquire();
/* adjust pointers */
if (mTopPtr < 0) // first time only
mTopPtr = 0;
mNextPtr = (mNextPtr + 1) % mMaxDisplayMsgs;
}
/*
* Return a human-readable string for the priority level. Always returns
* a valid string.
*/
static const wxCharBuffer GetPriorityString(android_LogPriority priority)
{
int idx;
idx = (int) priority - (int) ANDROID_LOG_VERBOSE;
if (idx < 0 || idx >= NELEM(gLogLevels))
return "?unknown?";
return gLogLevels[idx].name.ToAscii();
}
/*
* Format a message and write it to the text control.
*/
void LogWindow::FormatMessage(const LogMessage* pLogMessage,
wxTextCtrl* pTextCtrl)
{
#if defined(HAVE_LOCALTIME_R)
struct tm tmBuf;
#endif
struct tm* ptm;
char timeBuf[32];
char msgBuf[256];
int msgLen = 0;
char* outBuf;
char priChar;
LogPrefsDialog::HeaderFormat headerFmt;
headerFmt = mHeaderFormat;
if (pLogMessage->GetInternal())
headerFmt = LogPrefsDialog::kHFInternal;
priChar = ((const char*)GetPriorityString(pLogMessage->GetPriority()))[0];
/*
* Get the current date/time in pretty form
*
* It's often useful when examining a log with "less" to jump to
* a specific point in the file by searching for the date/time stamp.
* For this reason it's very annoying to have regexp meta characters
* in the time stamp. Don't use forward slashes, parenthesis,
* brackets, asterisks, or other special chars here.
*/
time_t when = pLogMessage->GetWhen();
const char* fmt = NULL;
#if defined(HAVE_LOCALTIME_R)
ptm = localtime_r(&when, &tmBuf);
#else
ptm = localtime(&when);
#endif
switch (headerFmt) {
case LogPrefsDialog::kHFFull:
case LogPrefsDialog::kHFInternal:
fmt = "%m-%d %H:%M:%S";
break;
case LogPrefsDialog::kHFBrief:
case LogPrefsDialog::kHFMinimal:
fmt = "%H:%M:%S";
break;
default:
break;
}
if (fmt != NULL)
strftime(timeBuf, sizeof(timeBuf), fmt, ptm);
else
strcpy(timeBuf, "-");
const int kMaxExtraNewlines = 2;
char hdrNewline[2];
char finalNewlines[kMaxExtraNewlines+1 +1];
if (mSingleLine)
hdrNewline[0] = ' ';
else
hdrNewline[0] = '\n';
hdrNewline[1] = '\0';
assert(mExtraSpacing <= kMaxExtraNewlines);
int i;
for (i = 0; i < mExtraSpacing+1; i++)
finalNewlines[i] = '\n';
finalNewlines[i] = '\0';
wxTextAttr msgColor;
switch (pLogMessage->GetPriority()) {
case ANDROID_LOG_WARN:
msgColor.SetTextColour(*wxBLUE);
break;
case ANDROID_LOG_ERROR:
msgColor.SetTextColour(*wxRED);
break;
case ANDROID_LOG_VERBOSE:
case ANDROID_LOG_DEBUG:
case ANDROID_LOG_INFO:
default:
msgColor.SetTextColour(*wxBLACK);
break;
}
if (pLogMessage->GetInternal())
msgColor.SetTextColour(*wxGREEN);
/*
* Construct a buffer containing the log header.
*/
bool splitHeader = true;
outBuf = msgBuf;
switch (headerFmt) {
case LogPrefsDialog::kHFFull:
splitHeader = true;
msgLen = android_snprintfBuffer(&outBuf, sizeof(msgBuf),
"[ %s %5d %c/%-6.6s]%s",
timeBuf, pLogMessage->GetPid(), priChar,
pLogMessage->GetTag(), hdrNewline);
break;
case LogPrefsDialog::kHFBrief:
splitHeader = true;
msgLen = android_snprintfBuffer(&outBuf, sizeof(msgBuf),
"[%s %5d]%s",
timeBuf, pLogMessage->GetPid(), hdrNewline);
break;
case LogPrefsDialog::kHFMinimal:
splitHeader = false;
msgLen = android_snprintfBuffer(&outBuf, sizeof(msgBuf),
"%s %5d- %s",
timeBuf, pLogMessage->GetPid(), pLogMessage->GetMsg());
break;
case LogPrefsDialog::kHFInternal:
splitHeader = false;
msgLen = android_snprintfBuffer(&outBuf, sizeof(msgBuf),
"[%s] %s", timeBuf, pLogMessage->GetMsg());
break;
default:
fprintf(stderr, "Sim: unexpected header format %d\n", headerFmt);
assert(false);
break;
}
if (msgLen < 0) {
fprintf(stderr, "WHOOPS\n");
assert(outBuf == msgBuf);
return;
}
if (splitHeader) {
if (mUseColor)
pTextCtrl->SetDefaultStyle(wxTextAttr(*wxLIGHT_GREY));
pTextCtrl->AppendText(wxString::FromAscii(outBuf));
if (mUseColor)
pTextCtrl->SetDefaultStyle(msgColor);
pTextCtrl->AppendText(wxString::FromAscii(pLogMessage->GetMsg()));
if (mUseColor)
pTextCtrl->SetDefaultStyle(*wxBLACK);
pTextCtrl->AppendText(wxString::FromAscii(finalNewlines));
} else {
if (mUseColor)
pTextCtrl->SetDefaultStyle(msgColor);
pTextCtrl->AppendText(wxString::FromAscii(outBuf));
if (mUseColor)
pTextCtrl->SetDefaultStyle(*wxBLACK);
pTextCtrl->AppendText(wxString::FromAscii(finalNewlines));
}
/* if we allocated storage for this message, free it */
if (outBuf != msgBuf)
free(outBuf);
}
/*
* Write the message to the log file.
*
* We can't just do this in FormatMessage(), because that re-writes all
* messages on the display whenever the output format or filter changes.
*
* Use a one-log-per-line format here to make "grep" useful.
*/
void LogWindow::LogToFile(const LogMessage* pLogMessage)
{
#if defined(HAVE_LOCALTIME_R)
struct tm tmBuf;
#endif
struct tm* ptm;
char timeBuf[32];
char msgBuf[256];
int msgLen;
char* outBuf;
char priChar;
assert(mLogFp != NULL);
time_t when = pLogMessage->GetWhen();
#if defined(HAVE_LOCALTIME_R)
ptm = localtime_r(&when, &tmBuf);
#else
ptm = localtime(&when);
#endif
strftime(timeBuf, sizeof(timeBuf), "%m-%d %H:%M:%S", ptm);
priChar = ((const char*)GetPriorityString(pLogMessage->GetPriority()))[0];
outBuf = msgBuf;
if (pLogMessage->GetInternal()) {
msgLen = android_snprintfBuffer(&outBuf, sizeof(msgBuf),
"[%s %5d *] %s\n",
timeBuf, pLogMessage->GetPid(), pLogMessage->GetMsg());
} else {
msgLen = android_snprintfBuffer(&outBuf, sizeof(msgBuf),
"[%s %5d %c] %s)\n",
timeBuf, pLogMessage->GetPid(), priChar,
pLogMessage->GetMsg());
}
if (fwrite(outBuf, msgLen, 1, mLogFp) != 1)
fprintf(stderr, "Sim: WARNING: partial log write\n");
fflush(mLogFp);
/* if we allocated storage for this message, free it */
if (outBuf != msgBuf)
free(outBuf);
}
/*
* Get the modification date of a file.
*/
static bool GetFileModDate(const char* fileName, time_t* pModWhen)
{
struct stat sb;
if (stat(fileName, &sb) < 0)
return false;
*pModWhen = sb.st_mtime;
return true;
}
/*
* Open or close the log file as appropriate.
*/
void LogWindow::PrepareLogFile(void)
{
const int kLogFileMaxAge = 8 * 60 * 60; // 8 hours
if (!mWriteFile && mLogFp != NULL) {
printf("Sim: closing log file\n");
fclose(mLogFp);
mLogFp = NULL;
} else if (mWriteFile && mLogFp == NULL) {
printf("Sim: opening log file '%s'\n", (const char*)mFileName.ToAscii());
time_t now, modWhen = 0;
const char* openFlags;
now = time(NULL);
if (!mTruncateOld ||
(GetFileModDate(mFileName.ToAscii(), &modWhen) &&
modWhen + kLogFileMaxAge > now))
{
if (modWhen != 0) {
printf("--- log file is %.3f hours old, appending\n",
(now - modWhen) / 3600.0);
}
openFlags = "a"; // open for append (text mode)
} else {
if (modWhen != 0) {
printf("--- log file is %.3f hours old, truncating\n",
(now - modWhen) / 3600.0);
}
openFlags = "w"; // open for writing, truncate (text mode)
}
mLogFp = fopen(mFileName.ToAscii(), openFlags);
if (mLogFp == NULL) {
fprintf(stderr, "Sim: failed opening log file '%s': %s\n",
(const char*) mFileName.ToAscii(), strerror(errno));
} else {
fprintf(mLogFp, "\n\n");
fflush(mLogFp);
}
}
}
/*
* Add a new log message.
*
* This function can be called from any thread. It makes a copy of the
* stuff in "*pBundle" and sends it to the main UI thread.
*/
/*static*/ void LogWindow::PostLogMsg(const android_LogBundle* pBundle)
{
LogMessage* pNewMessage = LogMessage::Create(pBundle);
SendToWindow(pNewMessage);
}
/*
* Post a simple string to the log.
*/
/*static*/ void LogWindow::PostLogMsg(const char* msg)
{
LogMessage* pNewMessage = LogMessage::Create(msg);
SendToWindow(pNewMessage);
}
/*
* Post a simple wxString to the log.
*/
/*static*/ void LogWindow::PostLogMsg(const wxString& msg)
{
LogMessage* pNewMessage = LogMessage::Create(msg.ToAscii());
SendToWindow(pNewMessage);
}
/*
* Send a log message to the log window.
*/
/*static*/ void LogWindow::SendToWindow(LogMessage* pMessage)
{
if (pMessage != NULL) {
wxWindow* pMainFrame = ((MyApp*)wxTheApp)->GetMainFrame();
UserEventMessage* pUem = new UserEventMessage;
pUem->CreateLogMessage(pMessage);
UserEvent uev(0, (void*) pUem);
pMainFrame->AddPendingEvent(uev);
} else {
fprintf(stderr, "Sim: failed to add new log message\n");
}
}
/*
* This is a sanity check. We need to stop somewhere to avoid trashing
* the system on bad input.
*/
#define kMaxLen 65536
#define VSNPRINTF vsnprintf // used to worry about _vsnprintf
/*
* Print a formatted message into a buffer. Pass in a buffer to try to use.
*
* If the buffer isn't big enough to hold the message, allocate storage
* with malloc() and return that instead. The caller is responsible for
* freeing the storage.
*
* Returns the length of the string, or -1 if the printf call failed.
*/
static int android_vsnprintfBuffer(char** pBuf, int bufLen, const char* format, va_list args)
{
int charsOut;
char* localBuf = NULL;
assert(pBuf != NULL && *pBuf != NULL);
assert(bufLen > 0);
assert(format != NULL);
while (1) {
/*
* In some versions of libc, vsnprintf only returns 0 or -1, where
* -1 indicates the the buffer wasn't big enough. In glibc 2.1
* and later, it returns the actual size needed.
*
* MinGW is just returning -1, so we have to retry there.
*/
char* newBuf;
charsOut = VSNPRINTF(*pBuf, bufLen, format, args);
if (charsOut >= 0 && charsOut < bufLen)
break;
//fprintf(stderr, "EXCEED: %d vs %d\n", charsOut, bufLen);
if (charsOut < 0) {
/* exact size not known, double previous size */
bufLen *= 2;
if (bufLen > kMaxLen)
goto fail;
} else {
/* exact size known, just use that */
bufLen = charsOut + 1;
}
//fprintf(stderr, "RETRY at %d\n", bufLen);
newBuf = (char*) realloc(localBuf, bufLen);
if (newBuf == NULL)
goto fail;
*pBuf = localBuf = newBuf;
}
// On platforms where snprintf() doesn't return the number of
// characters output, we would need to call strlen() here.
return charsOut;
fail:
if (localBuf != NULL) {
free(localBuf);
*pBuf = NULL;
}
return -1;
}
/*
* Variable-arg form of the above.
*/
static int android_snprintfBuffer(char** pBuf, int bufLen, const char* format, ...)
{
va_list args;
int result;
va_start(args, format);
result = android_vsnprintfBuffer(pBuf, bufLen, format, args);
va_end(args);
return result;
}