haiku.git

/*
 * Copyright (c) 1999-2000, Eric Moon.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions, and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


// RouteAppNodeManager.cpp

#include "RouteAppNodeManager.h"

#include "MediaIcon.h"
#include "NodeGroup.h"
#include "NodeRef.h"
#include "Connection.h"

#include "route_app_io.h"
#include "ConnectionIO.h"
#include "DormantNodeIO.h"
#include "LiveNodeIO.h"
#include "MediaFormatIO.h"
#include "MessageIO.h"
#include "NodeSetIOContext.h"
#include "StringContent.h"
#include "MediaString.h"

#include <Autolock.h>
#include <Debug.h>
#include <Entry.h>
#include <Path.h>

#include <TimeSource.h>

#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <typeinfo>

#include "set_tools.h"

// Locale Kit
#include <Catalog.h>

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "CortexRouteApp"

using namespace std;

__USE_CORTEX_NAMESPACE

#define D_METHOD(x) //PRINT (x)
#define D_HOOK(x) //PRINT (x)
#define D_SETTINGS(x) //PRINT (x)

// -------------------------------------------------------- //
// *** ctor/dtor
// -------------------------------------------------------- //

RouteAppNodeManager::~RouteAppNodeManager() {

	_freeIcons();
}

RouteAppNodeManager::RouteAppNodeManager(
	bool													useAddOnHost) :
	NodeManager(useAddOnHost),
	m_nextGroupNumber(1) {
	
	// pre-cache icons? +++++
	
}

// -------------------------------------------------------- //
// *** group management
// -------------------------------------------------------- //

// -------------------------------------------------------- //
// *** icon management
// -------------------------------------------------------- //

// fetch cached icon for the given live node; the MediaIcon
// instance is guaranteed to last as long as this object.
// Returns 0 if the node doesn't exist.

const MediaIcon* RouteAppNodeManager::mediaIconFor(
	media_node_id									nodeID,
	icon_size											iconSize) {
	
	BAutolock _l(this);

	uint64 key = _makeIconKey(nodeID, iconSize);

	icon_map::const_iterator it = m_iconMap.find(key);
	if(it != m_iconMap.end()) {
		// already cached
		return (*it).second;
	}

	// look up live_node_info
	NodeRef* ref;
	status_t err = getNodeRef(nodeID, &ref);
	if(err < B_OK)
		return 0;	

	return mediaIconFor(ref->nodeInfo(), iconSize);	
}

const MediaIcon* RouteAppNodeManager::mediaIconFor(
	live_node_info								nodeInfo,
	icon_size											iconSize) {
	
	uint64 key = _makeIconKey(nodeInfo.node.node, iconSize);

	icon_map::const_iterator it = m_iconMap.find(key);
	if(it != m_iconMap.end()) {
		// already cached
		return (*it).second;
	}

	// create & cache icon
	MediaIcon* icon = new MediaIcon(
		nodeInfo, iconSize);

	m_iconMap.insert(
		icon_map::value_type(key, icon));

	return icon;
}

// -------------------------------------------------------- //
// *** error handling
// -------------------------------------------------------- //

status_t RouteAppNodeManager::setLogTarget(
	const BMessenger&							target) {
	
	BAutolock _l(this);
	
	if(!target.IsValid())
		return B_BAD_VALUE;
	
	m_logTarget = target;
	return B_OK;
}

// -------------------------------------------------------- //
// NodeManager hook implementations
// -------------------------------------------------------- //

void RouteAppNodeManager::nodeCreated(
	NodeRef*											ref) {

	// prepare the log message
	BMessage logMsg(M_LOG);
	BString title = B_TRANSLATE("Node '%name%' created");
	title.ReplaceFirst("%name%", ref->name());
	logMsg.AddString("title", title);

	// create a default group for the node
	// [em 8feb00]
	NodeGroup* g = createGroup(ref->name());

	if(ref->kind() & B_TIME_SOURCE) {
		// notify observers
		BMessage m(M_TIME_SOURCE_CREATED);
		m.AddInt32("nodeID", ref->id());
		notify(&m);
	}

	// adopt node's time source if it's not the system clock (the default)
	// [em 20mar00]
	media_node systemClock;
	status_t err = roster->GetSystemTimeSource(&systemClock);
	if(err == B_OK)
	{
		BTimeSource* ts = roster->MakeTimeSourceFor(ref->node());
		if (ts == NULL)
			return;
		if(ts->Node() != systemClock)
		{
			g->setTimeSource(ts->Node());
			logMsg.AddString("line", "Synced to system clock");
		}
		ts->Release();
	}

	g->addNode(ref);

	m_logTarget.SendMessage(&logMsg);
}

void RouteAppNodeManager::nodeDeleted(
	const NodeRef*								ref) {

	// prepare the log message
	BMessage logMsg(M_LOG);
	BString title = B_TRANSLATE("Node '%name%' released");
	title.ReplaceFirst("%name%", ref->name());
	logMsg.AddString("title", title);

	if(ref->kind() & B_TIME_SOURCE) {
		// notify observers
		BMessage m(M_TIME_SOURCE_DELETED);
		m.AddInt32("nodeID", ref->id());
		notify(&m);
	}

	m_logTarget.SendMessage(&logMsg);
}

void RouteAppNodeManager::connectionMade(
	Connection*										connection) {

	D_HOOK((
		"@ RouteAppNodeManager::connectionMade()\n"));
		
	status_t err;

	// prepare the log message
	BMessage logMsg(M_LOG);
	BString title = B_TRANSLATE("Connection made");
	if (strcmp(connection->outputName(), connection->inputName()) == 0) {
		title = B_TRANSLATE("Connection '%name%' made");
		title.ReplaceFirst("%name%", connection->outputName());
	}
	logMsg.AddString("title", title);

	if(!(connection->flags() & Connection::INTERNAL))
		// don't react to connection Cortex didn't make
		return;
	
	// create or merge groups
	NodeRef *producer, *consumer;
	err = getNodeRef(connection->sourceNode(), &producer);
	if(err < B_OK) {
		D_HOOK((
			"!!! RouteAppNodeManager::connectionMade():\n"
			"    sourceNode (%ld) not found\n",
			connection->sourceNode()));
		return;	
	}
	err = getNodeRef(connection->destinationNode(), &consumer);
	if(err < B_OK) {
		D_HOOK((
			"!!! RouteAppNodeManager::connectionMade():\n"
			"    destinationNode (%ld) not found\n",
			connection->destinationNode()));
		return;	
	}

	// add node names to log messages
	BString line = B_TRANSLATE("Between:");
	logMsg.AddString("line", line);
	line = "    ";
	line += B_TRANSLATE("%producer% and %consumer%");
	line.ReplaceFirst("%producer%", producer->name());
	line.ReplaceFirst("%consumer%", consumer->name());
	logMsg.AddString("line", line);

	// add format to log message
	line = B_TRANSLATE("Negotiated format:");
	logMsg.AddString("line", line);
	line = "    ";
	line << MediaString::getStringFor(connection->format(), false);
	logMsg.AddString("line", line);

	NodeGroup *group = 0;
	BString groupName = B_TRANSLATE("Untitled group");
	groupName += " ";
	if(_canGroup(producer) && _canGroup(consumer))
	{
		if (producer->group() && consumer->group() &&
			!(producer->group()->groupFlags() & NodeGroup::GROUP_LOCKED) &&
			!(consumer->group()->groupFlags() & NodeGroup::GROUP_LOCKED))
		{
			// merge into consumers group
			group = consumer->group();
			mergeGroups(producer->group(), group);
		}
		else if (producer->group() &&
			!(producer->group()->groupFlags() & NodeGroup::GROUP_LOCKED))
		{ // add consumer to producers group
			group = producer->group();
			group->addNode(consumer);
		}
		else if (consumer->group() &&
			!(consumer->group()->groupFlags() & NodeGroup::GROUP_LOCKED))
		{ // add producer to consumers group
			group = consumer->group();
			group->addNode(producer);
		}
		else
		{ // make new group for both
			groupName << m_nextGroupNumber++;
			group = createGroup(groupName.String());
			group->addNode(producer);
			group->addNode(consumer);
		}
	}
	else if(_canGroup(producer) && !producer->group())
	{ // make new group for producer
		groupName << m_nextGroupNumber++;
		group = createGroup(groupName.String());
		group->addNode(producer);
	}
	else if(_canGroup(consumer) && !consumer->group())
	{ // make new group for consumer
		groupName << m_nextGroupNumber++;
		group = createGroup(groupName.String());
		group->addNode(consumer);			
	}

	m_logTarget.SendMessage(&logMsg);
}

void RouteAppNodeManager::connectionBroken(
	const Connection*									connection) {

	D_HOOK((
		"@ RouteAppNodeManager::connectionBroken()\n"));
		
	// prepare the log message
	BMessage logMsg(M_LOG);
	BString title = B_TRANSLATE("Connection broken");
	if (strcmp(connection->outputName(), connection->inputName()) == 0) {
		title = B_TRANSLATE("Connection '%name%' broken");
		title.ReplaceFirst("%name%", connection->outputName());
	}
	logMsg.AddString("title", title);

	if(!(connection->flags() & Connection::INTERNAL))
		// don't react to connection Cortex didn't make
		return;

	status_t err;
	
	// if the source and destination nodes belong to the same group,
	// and if no direct or indirect connection remains between the
	// source and destination nodes, split groups

	NodeRef *producer, *consumer;
	err = getNodeRef(connection->sourceNode(), &producer);
	if(err < B_OK) {
		D_HOOK((
			"!!! RouteAppNodeManager::connectionMade():\n"
			"    sourceNode (%ld) not found\n",
			connection->sourceNode()));
		return;	
	}
	err = getNodeRef(connection->destinationNode(), &consumer);
	if(err < B_OK) {
		D_HOOK((
			"!!! RouteAppNodeManager::connectionMade():\n"
			"    destinationNode (%ld) not found\n",
			connection->destinationNode()));
		return;	
	}

	// add node names to log messages
	BString line = B_TRANSLATE("Between:");
	logMsg.AddString("line", line);
	line = "    ";
	line += B_TRANSLATE("%producer% and %consumer%");
	line.ReplaceFirst("%producer%", producer->name());
	line.ReplaceFirst("%consumer%", consumer->name());
	logMsg.AddString("line", line);
	
	if(
		producer->group() &&
		producer->group() == consumer->group() &&
		!findRoute(producer->id(), consumer->id())) {

		NodeGroup *newGroup;
		splitGroup(producer, consumer, &newGroup);
	}

	m_logTarget.SendMessage(&logMsg);
}

void RouteAppNodeManager::connectionFailed(
	const media_output &							output,
	const media_input &								input,
	const media_format &							format,
	status_t										error) {
	D_HOOK((
		"@ RouteAppNodeManager::connectionFailed()\n"));

	status_t err;
		
	// prepare the log message
	BMessage logMsg(M_LOG);
	BString title = B_TRANSLATE("Connection failed");
	logMsg.AddString("title", title);
	logMsg.AddInt32("error", error);

	NodeRef *producer, *consumer;
	err = getNodeRef(output.node.node, &producer);
	if(err < B_OK) {
		return;	
	}
	err = getNodeRef(input.node.node, &consumer);
	if(err < B_OK) {
		return;	
	}

	// add node names to log messages
	BString line = B_TRANSLATE("Between:");
	logMsg.AddString("line", line);
	line = "    ";
	line += B_TRANSLATE("%producer% and %consumer%");
	line.ReplaceFirst("%producer%", producer->name());
	line.ReplaceFirst("%consumer%", consumer->name());
	logMsg.AddString("line", line);

	// add format to log message
	line = B_TRANSLATE("Tried format:");
	logMsg.AddString("line", line);
	line = "    ";
	line << MediaString::getStringFor(format, true);
	logMsg.AddString("line", line);

	// and send it
	m_logTarget.SendMessage(&logMsg);
}

// -------------------------------------------------------- //
// *** IPersistent
// -------------------------------------------------------- //

void RouteAppNodeManager::xmlExportBegin(
	ExportContext&								context) const {

	status_t err;
	
	try {
		NodeSetIOContext& set = dynamic_cast<NodeSetIOContext&>(context);
		context.beginElement(_NODE_SET_ELEMENT);
		
		// validate the node set
		for(int n = set.countNodes()-1; n >= 0; --n) {
			media_node_id id = set.nodeAt(n);
			ASSERT(id != media_node::null.node);
			
			// fetch node
			NodeRef* ref;
			err = getNodeRef(id, &ref);
			if(err < B_OK) {
				D_SETTINGS((
					"! RVNM::xmlExportBegin(): node %ld doesn't exist\n", id));

				set.removeNodeAt(n);
				continue;
			}
			// skip unless internal
			if(!ref->isInternal()) {
				D_SETTINGS((
					"! RVNM::xmlExportBegin(): node %ld not internal; skipping.\n", id));

				set.removeNodeAt(n);
				continue;
			}
		}
	}
	catch(bad_cast& e) {
		context.reportError("RouteAppNodeManager: expected a NodeSetIOContext\n");
	}
}
	
void RouteAppNodeManager::xmlExportAttributes(
	ExportContext&								context) const {}

void RouteAppNodeManager::xmlExportContent(
	ExportContext&								context) const {

	status_t err;

	try {
		NodeSetIOContext& nodeSet = dynamic_cast<NodeSetIOContext&>(context);
		context.beginContent();
	
		// write nodes; enumerate connections
		typedef map<uint32,Connection> connection_map;
		connection_map connections;
		int count = nodeSet.countNodes();
		for(int n = 0; n < count; ++n) {
			media_node_id id = nodeSet.nodeAt(n);
			ASSERT(id != media_node::null.node);
			
			// fetch node
			NodeRef* ref;
			err = getNodeRef(id, &ref);
			if(err < B_OK) {
				D_SETTINGS((
					"! RouteAppNodeManager::xmlExportContent():\n"
					"  getNodeRef(%ld) failed: '%s'\n",
					id, strerror(err)));
				continue;
			}

			// fetch connections
			vector<Connection> conSet;
			ref->getInputConnections(conSet);
			ref->getOutputConnections(conSet);
			for(uint32 c = 0; c < conSet.size(); ++c)
				// non-unique connections will be rejected:
				connections.insert(
					connection_map::value_type(conSet[c].id(), conSet[c]));

			// create an IO object for the node & write it
			DormantNodeIO io(ref, nodeSet.keyAt(n));
			if(context.writeObject(&io) < B_OK)
				// abort
				return;
		}		

		// write connections
		for(connection_map::const_iterator it = connections.begin();
			it != connections.end(); ++it) {
		
			ConnectionIO io(
				&(*it).second, 
				this,
				&nodeSet);
			if(context.writeObject(&io) < B_OK)
				// abort
				return;
				
		}
	
		// +++++ write groups
	
		// write UI state
		{
			BMessage m;
			nodeSet.exportUIState(&m);
			context.beginElement(_UI_STATE_ELEMENT);
			context.beginContent();
			MessageIO io(&m);
			context.writeObject(&io);
			context.endElement();
		}
	}
	catch(bad_cast& e) {
		context.reportError("RouteAppNodeManager: expected a NodeSetIOContext\n");
	}	
}

void RouteAppNodeManager::xmlExportEnd(
	ExportContext&								context) const {

	context.endElement();
}

// -------------------------------------------------------- //
// IMPORT	
// -------------------------------------------------------- //

void RouteAppNodeManager::xmlImportBegin(
	ImportContext&								context) {

}

void RouteAppNodeManager::xmlImportAttribute(
	const char*										key,
	const char*										value,
	ImportContext&								context) {}
		
void RouteAppNodeManager::xmlImportContent(
	const char*										data,
	uint32												length,
	ImportContext&								context) {}

void RouteAppNodeManager::xmlImportChild(
	IPersistent*									child,
	ImportContext&								context) {

	status_t err;
	
	if(!strcmp(context.element(), _DORMANT_NODE_ELEMENT)) {
		DormantNodeIO* io = dynamic_cast<DormantNodeIO*>(child);
		ASSERT(io);
		
		NodeRef* newRef;
		err = io->instantiate(this, &newRef);
		if(err == B_OK) {
			// created node; add an entry to the set stored in the
			// ImportContext for later reference
			try {
				NodeSetIOContext& set = dynamic_cast<NodeSetIOContext&>(context);
				set.addNode(newRef->id(), io->nodeKey());
			}
			catch(bad_cast& e) {
				context.reportError("RouteAppNodeManager: expected a NodeSetIOContext\n");
			}
		}
		else {
			D_SETTINGS((
				"!!! RouteAppNodeManager::xmlImportChild():\n"
				"    DormantNodeIO::instantiate() failed:\n"
				"    '%s'\n",
				strerror(err)));
		}
	}
	else if(!strcmp(context.element(), _CONNECTION_ELEMENT)) {
		ConnectionIO* io = dynamic_cast<ConnectionIO*>(child);
		ASSERT(io);
		
		// instantiate the connection
		Connection con;
		err = io->instantiate(
			this,
			dynamic_cast<NodeSetIOContext*>(&context),
			&con);
		if(err < B_OK) {
			D_SETTINGS((
				"!!! ConnectionIO::instantiate() failed:\n"
				"    '%s'\n", strerror(err)));
		}
		
		// +++++ group magic?

	}
	else if(!strcmp(context.element(), _NODE_GROUP_ELEMENT)) {
		// +++++
	}
	else if(
		context.parentElement() &&
		!strcmp(context.parentElement(), _UI_STATE_ELEMENT)) {
	
		// expect a nested message
		MessageIO* io = dynamic_cast<MessageIO*>(child);
		if(!io) {
			BString err;
			err <<
				"RouteAppNodeManager: unexpected child '" <<
				context.element() << "'\n";
			context.reportError(err.String());
		}
		
		// hand it off via the extended context object
		try {
			NodeSetIOContext& set = dynamic_cast<NodeSetIOContext&>(context);
			set.importUIState(io->message());
		}
		catch(bad_cast& e) {
			context.reportError("RouteAppNodeManager: expected a NodeSetIOContext\n");
		}
	}
	
}
	
void RouteAppNodeManager::xmlImportComplete(
	ImportContext&								context) {

}

// -------------------------------------------------------- //

/*static*/
void RouteAppNodeManager::AddTo(
	XML::DocumentType*				docType) {

	// set up the document type

	MessageIO::AddTo(docType);
	MediaFormatIO::AddTo(docType);
	ConnectionIO::AddTo(docType);
	DormantNodeIO::AddTo(docType);
	LiveNodeIO::AddTo(docType);
	_add_string_elements(docType);
}

// -------------------------------------------------------- //
// implementation
// -------------------------------------------------------- //

uint64 RouteAppNodeManager::_makeIconKey(
	media_node_id nodeID, icon_size iconSize) {

	return ((uint64)nodeID) << 32 | iconSize;
}

void RouteAppNodeManager::_readIconKey(
	uint64 key, media_node_id& nodeID, icon_size& iconSize) {
	
	nodeID = key >> 32;
	iconSize = icon_size(key & 0xffffffff);
}

void RouteAppNodeManager::_freeIcons() {

	ptr_map_delete(
		m_iconMap.begin(),
		m_iconMap.end());
}

bool RouteAppNodeManager::_canGroup(NodeRef* ref) const {

	// sanity check & easy cases
	ASSERT(ref);
	if(ref->isInternal())
		return true;

	// bar 'touchy' system nodes
	if(ref == audioMixerNode() || ref == audioOutputNode())
		return false;
		
	return true;
}

// END -- RouteAppNodeManager.cpp --