haiku.git

/*
 * Copyright 2007-2009 Oliver Ruiz Dorantes, oliver.ruiz.dorantes_at_gmail.com
 * Copyright 2008 Mika Lindqvist, monni1995_at_gmail.com
 * All rights reserved. Distributed under the terms of the MIT License.
 */

#include "LocalDeviceHandler.h"


LocalDeviceHandler::LocalDeviceHandler(HCIDelegate* hd)
{
	fHCIDelegate = hd;
	fProperties = new BMessage();
}


LocalDeviceHandler::~LocalDeviceHandler()
{
	delete fHCIDelegate;
	delete fProperties;
}


hci_id
LocalDeviceHandler::GetID()
{
	return fHCIDelegate->Id();
}


status_t
LocalDeviceHandler::Launch(void)
{
	return fHCIDelegate->Launch();
}


bool
LocalDeviceHandler::Available()
{

	return true;
}


void
LocalDeviceHandler::Acquire(void)
{

}


bool
LocalDeviceHandler::IsPropertyAvailable(const char* property)
{
	type_code typeFound;
	int32 countFound;

	return (fProperties->GetInfo(property, &typeFound, &countFound) == B_OK );
}


void
LocalDeviceHandler::AddWantedEvent(BMessage* msg)
{
	fEventsWanted.Lock();
	// TODO: review why it is needed to replicate the msg
//	printf("Adding request... %p\n", msg);
	fEventsWanted.AddMessage(msg);
	fEventsWanted.Unlock();
}


void
LocalDeviceHandler::ClearWantedEvent(BMessage* msg)
{
	fEventsWanted.Lock();
	fEventsWanted.RemoveMessage(msg);
	fEventsWanted.Unlock();
}


void
LocalDeviceHandler::ClearWantedEvent(BMessage* msg, uint16 event, uint16 opcode)
{
	// Remove the whole petition from queue
	fEventsWanted.Lock();

	int16 eventFound;
	int16 opcodeFound;
	int32 eventIndex = 0;

	// for each Event
	while (msg->FindInt16("eventExpected", eventIndex, &eventFound) == B_OK) {

		printf("%s:Event expected %d@%" B_PRId32 "...\n", __FUNCTION__, event,
			eventIndex);

		if (eventFound == event) {

			printf("%s:Event matches@%" B_PRId32 "\n", __FUNCTION__, eventIndex);
			// there is an opcode specified
			if (opcode != 0) {

				// The opcode matches
				if ((msg->FindInt16("opcodeExpected", eventIndex, &opcodeFound) == B_OK)
					&& ((uint16)opcodeFound == opcode)) {

					// this should remove only the entry
					printf("Removed event %#x and opcode %d from request %p\n",
						event, opcode, msg);
					(void)msg->RemoveData("eventExpected", eventIndex);
					(void)msg->RemoveData("opcodeExpected", eventIndex);
					goto finish;
				}

			} else {
				// Event matches so far
				printf("Removed event %d from message %p\n", event, msg);
				(void)msg->RemoveData("eventExpected", eventIndex);
				goto finish;
			}

		}
		eventIndex++;
	}
	printf("%s:Nothing Found/Removed\n", __FUNCTION__);

finish:
	fEventsWanted.Unlock();

}


BMessage*
LocalDeviceHandler::FindPetition(uint16 event, uint16 opcode, int32* indexFound)
{
	//debug data
	int16 eventFound;
	int16 opcodeFound;
	int32 eventIndex;

	fEventsWanted.Lock();
	// for each Petition
	for (int32 index = 0 ; index < fEventsWanted.CountMessages() ; index++) {
		BMessage* msg = fEventsWanted.FindMessage(index);
//		printf("%s:Petition %ld ... of %ld msg #%p\n", __FUNCTION__, index,
//			fEventsWanted.CountMessages(), msg);
//		msg->PrintToStream();
		eventIndex = 0;

		// for each Event
		while (msg->FindInt16("eventExpected", eventIndex, &eventFound) == B_OK ) {
			if (eventFound == event) {

//				printf("%s:Event %d found@%ld...", __FUNCTION__, event, eventIndex);
				// there is an opcode specified..
				if (msg->FindInt16("opcodeExpected", eventIndex, &opcodeFound)
					== B_OK) {
					// ensure the opcode
					if ((uint16)opcodeFound != opcode) {
//						printf("%s:opcode does not match %d\n",
//							__FUNCTION__, opcode);
						eventIndex++;
						continue;
					}
//					printf("Opcode matches %d\n", opcode);
				} else {
//					printf("No opcode specified\n");
				}

				fEventsWanted.Unlock();
				if (indexFound != NULL)
					*indexFound = eventIndex;
				return msg;
			}
			eventIndex++;
		}
	}
//	printf("%s:Event %d not found\n", __FUNCTION__, event);

	fEventsWanted.Unlock();
	return NULL;

}