haiku.git

// CommonTestApp.cpp

#include <stdio.h>
#include <cstring>

#include <OS.h>

#include "CommonTestApp.h"

// constructor
CommonTestApp::CommonTestApp(const char *signature)
			 : BApplication(signature),
			   fQuitOnSecondTry(false),
			   fEventThread(-1),
			   fEventDelay(0),
			   fEventCount(0),
			   fEventHandler(NULL),
			   fMessageHandler(NULL),
			   fReportDestruction(false)
{
}

// constructor
CommonTestApp::CommonTestApp(const char *signature, status_t *result)
			 : BApplication(signature, result),
			   fQuitOnSecondTry(false),
			   fEventThread(-1),
			   fEventDelay(0),
			   fEventCount(0),
			   fEventHandler(NULL),
			   fMessageHandler(NULL),
			   fReportDestruction(false)
{
}

// destructor
CommonTestApp::~CommonTestApp()
{
	if (fEventThread >= 0) {
		int32 result;
		wait_for_thread(fEventThread, &result);
	}
	if (fReportDestruction)
		report("BApplication::~BApplication()\n");
	delete fEventHandler;
	delete fMessageHandler;
}

// ArgvReceived
void
CommonTestApp::ArgvReceived(int32 argc, char **argv)
{
	report("BApplication::ArgvReceived()\n");
	if (argc > 1) {
		report("args:");
		for (int32 i = 1; i < argc; i++)
			report(" %s", argv[i]);
		report("\n");
	}
}

// MessageReceived
void
CommonTestApp::MessageReceived(BMessage *message)
{
	if (fMessageHandler)
		fMessageHandler->MessageReceived(message);
	BApplication::MessageReceived(message);
}

// QuitRequested
bool
CommonTestApp::QuitRequested()
{
	report("BApplication::QuitRequested()\n");
	static bool firstTry = true;
	if (firstTry && fQuitOnSecondTry) {
		firstTry = false;
		return false;
	}
	return BApplication::QuitRequested();
}

// ReadyToRun
void
CommonTestApp::ReadyToRun()
{
	report("BApplication::ReadyToRun()\n");
}

// Run
thread_id
CommonTestApp::Run()
{
	thread_id result = BApplication::Run();
	report("BApplication::Run() done: %d\n", (result == find_thread(NULL)));
	return result;
}

// SetQuittingPolicy
void
CommonTestApp::SetQuittingPolicy(bool onSecondTry)
{
	fQuitOnSecondTry = onSecondTry;
}

// SetReportDestruction
void
CommonTestApp::SetReportDestruction(bool reportDestruction)
{
	fReportDestruction = reportDestruction;
}

// RunEventThread
status_t
CommonTestApp::RunEventThread(bigtime_t delay, int32 count,
							  EventHandler *handler)
{
	status_t error = B_OK;
	fEventDelay = delay;
	fEventCount = count;
	fEventHandler = handler;
	// spawn the thread
	fEventThread = spawn_thread(&_EventThreadEntry, "event thread",
								B_NORMAL_PRIORITY, this);
	if (fEventThread < 0)
		error = fEventThread;
	if (error == B_OK)
		error = resume_thread(fEventThread);
	// cleanup on error
	if (error != B_OK && fEventThread >= 0) {
		kill_thread(fEventThread);
		fEventThread = -1;
	}
	return error;
}

// SetMessageHandler
void
CommonTestApp::SetMessageHandler(BHandler *handler)
{
	delete fMessageHandler;
	fMessageHandler = handler;
}

// _EventThreadEntry
int32
CommonTestApp::_EventThreadEntry(void *data)
{
	int32 result = 0;
	if (CommonTestApp *app = (CommonTestApp*)data)
		result = app->_EventLoop();
	return result;
}

// _EventLoop
int32
CommonTestApp::_EventLoop()
{
	for (; fEventCount > 0; fEventCount--) {
		snooze(fEventDelay);
		if (fEventHandler)
			fEventHandler->HandleEvent(this);
	}
	return 0;
}

static const char *kAppRunnerTeamPort = "app runner team port";
static bool connectionEstablished = false;
static port_id outputPort = -1;

// init_connection
status_t
init_connection()
{
	status_t error = B_OK;
	// create a port
	outputPort = create_port(10, "common test app port");
	if (outputPort < 0)
		error = outputPort;
	// find the remote port
	port_id port = -1;
	if (error == B_OK) {
		port = find_port(kAppRunnerTeamPort);
		if (port < 0)
			error = port;
	}
	// send the port ID
	if (error == B_OK) {
		ssize_t written = write_port(port, outputPort, &be_app_messenger,
									 sizeof(BMessenger));
		if (written < 0)
			error = written;
	}
	connectionEstablished = (error == B_OK);
	return error;
}

// report
void
report(const char *format,...)
{
	va_list args;
	va_start(args, format);
	if (connectionEstablished)
		vreport(format, args);
	else
		vprintf(format, args);
	va_end(args);
}

// vreport
void
vreport(const char *format, va_list args)
{
	char buffer[10240];
	vsprintf(buffer, format, args);
	int32 length = strlen(buffer);
	write_port(outputPort, 0, buffer, length);
}