haiku/headers/private/bluetooth/PortListener.h

/*
 * Copyright 2009 Oliver Ruiz Dorantes, oliver.ruiz.dorantes_at_gmail.com
 * All rights reserved. Distributed under the terms of the MIT License.
 */
#ifndef PORTLISTENER_H_
#define PORTLISTENER_H_

#include <OS.h>

template <
	typename TYPE,
	ssize_t MAX_MESSAGE_SIZE = 256,
	size_t MAX_MESSAGE_DEEP	= 16,
	uint32 PRIORITY	= B_URGENT_DISPLAY_PRIORITY>
class PortListener {
public:
	typedef status_t (*port_listener_func)(TYPE*, int32, size_t);

	PortListener(const char* name, port_listener_func handler)
	{
		fInformation.func = handler;
		fInformation.port = &fPort;

		fPortName = strdup(name);

		fThreadName = (char*)malloc(strlen(name) + strlen(" thread") + 1);
		fThreadName = strcpy(fThreadName, fPortName);
		fThreadName = strcat(fThreadName, " thread");

		InitCheck();
	}


	~PortListener()
	{
		status_t status;

		close_port(fPort);
		// Closing the port	should provoke the thread to finish
		wait_for_thread(fThread, &status);

		free(fThreadName);
		free(fPortName);
	}


	status_t Trigger(int32 code)
	{
			return write_port(fPort, code, NULL, 0);
	}


	status_t Trigger(int32 code, TYPE* buffer, size_t size)
	{
		if (buffer == NULL)
			return B_ERROR;

		return write_port(fPort, code, buffer, size);
	}


	status_t InitCheck()
	{
		// Create Port
		fPort = find_port(fPortName);
		if (fPort == B_NAME_NOT_FOUND) {
			fPort = create_port(MAX_MESSAGE_DEEP, fPortName);
		}

		if (fPort < B_OK)
			return fPort;

		#ifdef KERNEL_LAND
		// if this is the case you better stay with kernel
		set_port_owner(fPort, B_SYSTEM_TEAM);
		#endif

		// Create Thread
		fThread = find_thread(fThreadName);
		if (fThread < B_OK) {
#ifdef KERNEL_LAND
			fThread = spawn_kernel_thread((thread_func)&PortListener<TYPE,
				MAX_MESSAGE_SIZE, MAX_MESSAGE_DEEP, PRIORITY>::threadFunction,
				fThreadName, PRIORITY, &fInformation);
#else
			fThread = spawn_thread((thread_func)&PortListener<TYPE,
				MAX_MESSAGE_SIZE, MAX_MESSAGE_DEEP, PRIORITY>::threadFunction,
				fThreadName, PRIORITY, &fInformation);
#endif
		}

		if (fThread < B_OK)
			return fThread;

		return B_OK;
	}


	status_t Launch()
	{
		status_t check = InitCheck();

		if (check < B_OK)
			return check;

		return resume_thread(fThread);
	}


	status_t Stop()
	{
		status_t status;

		close_port(fPort);
		// Closing the port	should provoke the thread to finish
		wait_for_thread(fThread, &status);

		return status;
	}


private:

	struct PortListenerInfo {
		port_id* port;
		port_listener_func func;
	} fInformation;

	port_id fPort;
	thread_id fThread;
	char* fThreadName;
	char* fPortName;

	static int32 threadFunction(void* data)
	{
		ssize_t	ssizePort;
		ssize_t	ssizeRead;
		status_t status = B_OK;
		int32 code;

		port_id* port = ((struct PortListenerInfo*)data)->port;
		port_listener_func handler = ((struct PortListenerInfo*)data)->func;


		TYPE* buffer = (TYPE*)malloc(MAX_MESSAGE_SIZE);

		while ((ssizePort = port_buffer_size(*port)) != B_BAD_PORT_ID) {

			if (ssizePort <= 0) {
				snooze(500 * 1000);
				continue;
			}

			if (ssizePort >	MAX_MESSAGE_SIZE) {
				snooze(500 * 1000);
				continue;
			}

			ssizeRead = read_port(*port, &code, (void*)buffer, ssizePort);

			if (ssizeRead != ssizePort)
				continue;

			status = handler(buffer, code,	ssizePort);

			if (status != B_OK)
				break;

		}

		#ifdef DEBUG_PORTLISTENER
		#ifdef KERNEL_LAND
		dprintf("Error in PortListener handler=%s port=%s\n", strerror(status),
			strerror(ssizePort));
		#else
		printf("Error in PortListener handler=%s port=%s\n", strerror(status),
			strerror(ssizePort));
		#endif
		#endif

		free(buffer);

		if (ssizePort == B_BAD_PORT_ID) // the port disappeared
			return ssizePort;

		return status;
	}

}; // PortListener

#endif // PORTLISTENER_H_