haiku.git

#include <Application.h>
#include <Autolock.h>
#include <String.h>

#include <Directory.h>
#include <Entry.h>
#include <FindDirectory.h>
#include <Path.h>
#include <NodeMonitor.h>


#include <image.h>
#include <stdio.h>
#include <string.h>

#include "DeviceManager.h"
#include "LocalDeviceImpl.h"

#include "Debug.h"
#include "BluetoothServer.h"

#include <bluetoothserver_p.h>


void
DeviceManager::MessageReceived(BMessage* msg)
{
	if (msg->what == B_NODE_MONITOR) {
		int32 opcode;
		if (msg->FindInt32("opcode", &opcode) == B_OK) {
			switch (opcode)	{
				case B_ENTRY_CREATED:
				case B_ENTRY_MOVED:
				{
					entry_ref ref;
					const char *name;
					BDirectory dir;

					TRACE_BT("Something new in the bus ... ");

					if ((msg->FindInt32("device", &ref.device)!=B_OK)
						|| (msg->FindInt64("directory", &ref.directory)!=B_OK)
						|| (msg->FindString("name",	&name) != B_OK))
						return;

					TRACE_BT("DeviceManager: -> %s\n", name);

					ref.set_name(name);

					// Check if	the	entry is a File	or a directory
					if (dir.SetTo(&ref) == B_OK) {
						printf("%s: Entry %s is taken as a dir\n", __FUNCTION__, name);
					    node_ref nref;
					    dir.GetNodeRef(&nref);
						AddDirectory(&nref);

					} else {
						printf("%s: Entry %s is taken as a file\n", __FUNCTION__, name);
                        AddDevice(&ref);
					}
				}
				break;
				case B_ENTRY_REMOVED:
				{
					TRACE_BT("Something removed from the bus ...\n");

				}
				break;
				case B_STAT_CHANGED:
				case B_ATTR_CHANGED:
				case B_DEVICE_MOUNTED:
				case B_DEVICE_UNMOUNTED:
				default:
					BLooper::MessageReceived(msg);
				break;
			}
		}
	}
}


status_t
DeviceManager::AddDirectory(node_ref *nref)
{
	BDirectory directory(nref);
	status_t status	= directory.InitCheck();
	if (status != B_OK)	{
		TRACE_BT("AddDirectory::Initcheck Failed\n");
		return status;
	}

	status = watch_node(nref, B_WATCH_DIRECTORY, this);
	if (status != B_OK)	{
		TRACE_BT("AddDirectory::watch_node	Failed\n");
		return status;
	}

//	BPath path(*nref);
//	BString	str(path.Path());
//
//	TRACE_BT("DeviceManager: Exploring entries in %s\n", str.String());

	entry_ref ref;
	status_t error;
	while ((error =	directory.GetNextRef(&ref))	== B_OK) {
		// its suposed to be devices ...
		AddDevice(&ref);
	}

	TRACE_BT("DeviceManager: Finished exploring entries(%s)\n", strerror(error));

	return (error == B_OK || error == B_ENTRY_NOT_FOUND)?B_OK:error;
}


status_t
DeviceManager::RemoveDirectory(node_ref* nref)
{
	BDirectory directory(nref);
	status_t status	= directory.InitCheck();
	if (status != B_OK)
		return status;

	status = watch_node(nref, B_STOP_WATCHING, this);
	if (status != B_OK)
		return status;

	BEntry entry;
	while (directory.GetNextEntry(&entry, true)	== B_OK) {
		entry_ref ref;
		entry.GetRef(&ref);
		BMessage msg(B_NODE_MONITOR);
		msg.AddInt32("opcode", B_ENTRY_REMOVED);
		msg.AddInt32("device", nref->device);
		msg.AddInt64("directory", nref->node);
		msg.AddString("name", ref.name);
		//addon->fDevice->Control(NULL,	NULL, msg.what,	&msg);
	}

	return B_OK;
}


status_t
DeviceManager::AddDevice(entry_ref* ref)
{
	BPath path(ref);
	BString* str = new BString(path.Path());

	BMessage* msg =	new	BMessage(BT_MSG_ADD_DEVICE);
	msg->AddInt32("opcode",	B_ENTRY_CREATED);
	msg->AddInt32("device",	ref->device);
	msg->AddInt64("directory", ref->directory);

	msg->AddString("name", *str	);

	TRACE_BT("DeviceManager: Device %s registered\n", path.Path());
	return be_app_messenger.SendMessage(msg);
}


DeviceManager::DeviceManager() :
	fLock("device manager")
{

}


DeviceManager::~DeviceManager()
{

}


void
DeviceManager::LoadState()
{
	if (!Lock())
		return;
	Run();
	Unlock();
}


void
DeviceManager::SaveState()
{

}


status_t
DeviceManager::StartMonitoringDevice(const char	*device)
{

	status_t err;
	node_ref nref;
	BDirectory directory;
	BPath path("/dev");

	/* Build the path */
	if ((err = path.Append(device))	!= B_OK) {
		printf("DeviceManager::StartMonitoringDevice BPath::Append() error %s: %s\n", path.Path(), strerror(err));
		return err;
	}

	/* Check the path */
	if ((err = directory.SetTo(path.Path())) !=	B_OK) {
		/* Entry not there ... */
		if (err	!= B_ENTRY_NOT_FOUND) {	// something else we cannot	handle
			printf("DeviceManager::StartMonitoringDevice SetTo error %s: %s\n",	path.Path(), strerror(err));
			return err;
		}
		/* Create it */
		if ((err = create_directory(path.Path(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) != B_OK
			|| (err	= directory.SetTo(path.Path()))	!= B_OK) {
			printf("DeviceManager::StartMonitoringDevice CreateDirectory error %s: %s\n", path.Path(), strerror(err));
			return err;
		}
	}

	// get noderef
	if ((err = directory.GetNodeRef(&nref))	!= B_OK) {
		printf("DeviceManager::StartMonitoringDevice GetNodeRef	error %s: %s\n", path.Path(), strerror(err));
		return err;
	}

	// start monitoring	the	root
	status_t error = watch_node(&nref, B_WATCH_DIRECTORY, this);
	if (error != B_OK)
		return error;

	TRACE_BT("DeviceManager: %s	path being monitored\n", path.Path());

	// We are monitoring the root we may have already directories inside
	// to be monitored
	entry_ref driverRef;
	while ((error =	directory.GetNextRef(&driverRef)) == B_OK) {

		// its suposed to be directories that needs	to be monitored...
		BNode driverNode(&driverRef);
		node_ref driverNRef;
		driverNode.GetNodeRef(&driverNRef);
		AddDirectory(&driverNRef);
	}

    TRACE_BT("DeviceManager: Finished exploring entries(%s)\n", strerror(error));

#if	0
	HCIDelegate	*tmphd = NULL;
	int32 i	= 0;

	// TODO!! ask the server if	this needs to be monitored

	while ((tmphd =	(HCIDelegate *)fDelegatesList.ItemAt(i++)) !=NULL) {

		/* Find	out	the	reference*/
		node_ref *dnref	= (node_ref	*)tmphd->fMonitoredRefs	;
		if (*dnref == nref)	{
			printf("StartMonitoringDevice already monitored\n");
			alreadyMonitored = true;
			break;
		}

	}
#endif

	return B_OK;
}


status_t
DeviceManager::StopMonitoringDevice(const char *device)
{
	status_t err;
	node_ref nref;
	BDirectory directory;
	BPath path("/dev");
	if (((err =	path.Append(device)) !=	B_OK)
		|| ((err = directory.SetTo(path.Path())) !=	B_OK)
		|| ((err = directory.GetNodeRef(&nref))	!= B_OK))
		return err;

	// test	if still monitored
/*
	bool stillMonitored	= false;
	int32 i	= 0;
	while ((tmpaddon = (_BDeviceAddOn_ *)fDeviceAddons.ItemAt(i++))	!=NULL)	{
		if (addon == tmpaddon)
			continue;

		int32 j=0;
		node_ref *dnref	= NULL;
		while ((dnref =	(node_ref *)tmpaddon->fMonitoredRefs.ItemAt(j++)) != NULL) {
			if (*dnref == nref)	{
				stillMonitored = true;
				break;
			}
		}
		if (stillMonitored)
			break;
	}

	// remove from list
	node_ref *dnref	= NULL;
	int32 j=0;
	while ((dnref =	(node_ref *)addon->fMonitoredRefs.ItemAt(j)) !=	NULL) {
		if (*dnref == nref)	{
			addon->fMonitoredRefs.RemoveItem(j);
			delete dnref;
			break;
		}
		j++;
	}

	// stop	monitoring if needed
	if (!stillMonitored) {
		if ((err = RemoveDirectory(&nref, addon)) != B_OK)
			return err;
	}
*/
	return B_OK;
}