From: christian mueller Date: Tue, 24 Jan 2012 16:07:25 +0000 (+0100) Subject: * finalized Router implementation X-Git-Tag: build/2012-06-15.125948~91 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=af0ba5b505b361679c07899187b7043d867742c3;p=profile%2Fivi%2Faudiomanager.git * finalized Router implementation * added new generated ControlSendInterface with router support --- diff --git a/AudioManagerDaemon/include/Router.h b/AudioManagerDaemon/include/Router.h index 7635522..8fb859b 100644 --- a/AudioManagerDaemon/include/Router.h +++ b/AudioManagerDaemon/include/Router.h @@ -27,51 +27,54 @@ #include -namespace am { +namespace am +{ class DatabaseHandler; -class Router { +class Router +{ public: - Router(DatabaseHandler* iDatabaseHandler); - am_Error_e getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector& returnList); - virtual ~Router(); + Router(DatabaseHandler* iDatabaseHandler); + am_Error_e getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector& returnList); + virtual ~Router(); private: - am_Error_e findBestWay(std::vector& listRoute,std::vector::iterator routeIterator,std::vector::iterator gatewayIterator,int choiceNumber); - void listPossibleConnectionFormats(const am_sourceID_t sourceID,const am_sinkID_t sinkID,std::vector& listFormats) const; - void listRestrictedOutputFormatsGateways(const am_gatewayID_t gatewayID, const am_ConnectionFormat_e sinkConnectionFormat, std::vector& listFormats) const; - DatabaseHandler* mDatabaseHandler; + am_Error_e findBestWay(std::vector& listRoute, std::vector::iterator routeIterator, std::vector::iterator gatewayIterator, int choiceNumber); + void listPossibleConnectionFormats(const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector& listFormats) const; + void listRestrictedOutputFormatsGateways(const am_gatewayID_t gatewayID, const am_ConnectionFormat_e sinkConnectionFormat, std::vector& listFormats) const; + DatabaseHandler* mDatabaseHandler; }; -class RoutingTreeItem { +class RoutingTreeItem +{ public: - RoutingTreeItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID = 0, RoutingTreeItem *parent = 0); - void appendChild(RoutingTreeItem *newChild); - void returnChildItems(std::vector listChildItems); - am_domainID_t returnDomainID() const; - am_gatewayID_t returnGatewayID() const; - virtual ~RoutingTreeItem(); - RoutingTreeItem* returnParent() const; + RoutingTreeItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID = 0, RoutingTreeItem *parent = 0); + void appendChild(RoutingTreeItem *newChild); + void returnChildItems(std::vector listChildItems); + am_domainID_t returnDomainID() const; + am_gatewayID_t returnGatewayID() const; + virtual ~RoutingTreeItem(); + RoutingTreeItem* returnParent() const; private: - std::vector mListChildItems; //!< List of all child items - am_domainID_t mDomainID; //!< the domain ID of the item - am_gatewayID_t mGatewayID; //!< the gateway Id - RoutingTreeItem *mParentItem; //!< pointer to the parent item + std::vector mListChildItems; //!< List of all child items + am_domainID_t mDomainID; //!< the domain ID of the item + am_gatewayID_t mGatewayID; //!< the gateway Id + RoutingTreeItem *mParentItem; //!< pointer to the parent item }; - -class RoutingTree { +class RoutingTree +{ public: - RoutingTree(const am_domainID_t rootDomainID); - RoutingTreeItem* insertItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID, RoutingTreeItem *parent); - void getRoute(RoutingTreeItem* targetItem, std::vector* listGateways); - am_domainID_t returnRootDomainID() const; - RoutingTreeItem* returnRootItem(); - virtual ~RoutingTree(); + RoutingTree(const am_domainID_t rootDomainID); + RoutingTreeItem* insertItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID, RoutingTreeItem *parent); + void getRoute(RoutingTreeItem* targetItem, std::vector* listGateways); + am_domainID_t returnRootDomainID() const; + RoutingTreeItem* returnRootItem(); + virtual ~RoutingTree(); private: - RoutingTreeItem mRootItem; //!< pointer to root item - std::vector mListChild; //!< list of all childs + RoutingTreeItem mRootItem; //!< pointer to root item + std::vector mListChild; //!< list of all childs }; } /* namespace am */ diff --git a/AudioManagerDaemon/src/Router.cpp b/AudioManagerDaemon/src/Router.cpp index 9e1b5f6..e7c9096 100644 --- a/AudioManagerDaemon/src/Router.cpp +++ b/AudioManagerDaemon/src/Router.cpp @@ -27,264 +27,268 @@ #include #include #include +#include using namespace am; am_Error_e getConnectionFormatChoice(const am_sinkID_t, const am_sourceID_t, const std::vector& listPossibleConnectionFormats, std::vector& listPriorityConnectionFormats) { - listPriorityConnectionFormats=listPossibleConnectionFormats; - return (E_OK); + listPriorityConnectionFormats = listPossibleConnectionFormats; + return (E_OK); } -Router::Router(DatabaseHandler *iDatabaseHandler) - :mDatabaseHandler(iDatabaseHandler) +Router::Router(DatabaseHandler *iDatabaseHandler) : + mDatabaseHandler(iDatabaseHandler) { - assert(mDatabaseHandler); + assert(mDatabaseHandler); } -am_Error_e am::Router::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector & returnList) +am_Error_e Router::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector & returnList) { - //first find out in which domains the source and sink are - am_domainID_t sourceDomainID; - am_domainID_t sinkDomainID; - if (mDatabaseHandler->getDomainOfSource(sourceID,sourceDomainID) != E_OK) return (E_NON_EXISTENT); - if (mDatabaseHandler->getDomainOfSink(sinkID,sinkDomainID) != E_OK) return (E_NON_EXISTENT); - - RoutingTree routingtree(sourceDomainID); //Build up a Tree from the Source_Domain to every other domain. - std::vector flattree; //This list is the flat tree - std::vector matchtree; //This List holds all TreeItems which have the right Domain Sink IDs - std::vector listGatewayID; //holds all gateway ids of the route - am_RoutingElement_s routingElement; - std::vector actualRoutingElement;//intermediate list of current routing pairs - am_Route_s actualRoute; //holds the actual Route - am_sourceID_t lastSource = 0; - - //TODO: kind of unclean. The separation between database and router could be better. - mDatabaseHandler->getRoutingTree(onlyfree, &routingtree, &flattree); //Build up the tree out of the database as - - //we go through the returned flattree and look for our sink, after that flattree holds only treeItems that match - std::vector::iterator flatIterator=flattree.begin(); - for(;flatIterator!=flattree.end();++flatIterator) - { - if((*flatIterator)->returnDomainID()!=sinkDomainID) - { - flatIterator=flattree.erase(flatIterator); - } - } - - //No we need to trace back the routes for each entry in matchtree - flatIterator=flattree.begin(); - for(;flatIterator!=flattree.end();++flatIterator) - { - //getting the route for the actual item - routingtree.getRoute(*flatIterator, &listGatewayID); //This gives only the Gateway IDs we need more - - //go throught the gatewayids and get more information - std::vector::iterator gatewayIterator =listGatewayID.begin(); - for(;gatewayIterator!=listGatewayID.end();++gatewayIterator) - { - am_Gateway_s gatewayData; - if (mDatabaseHandler->getGatewayInfoDB(2,gatewayData) != E_OK) return (E_UNKNOWN); - - //at the beginning of the route, we connect first the source to the first gateway - if (gatewayIterator ==listGatewayID.begin()) - { - routingElement.sourceID = sourceID; - routingElement.domainID = sourceDomainID; - } - else - { - routingElement.sourceID = lastSource; - routingElement.domainID = gatewayData.domainSinkID; - } - routingElement.sinkID = gatewayData.sinkID; - actualRoutingElement.push_back(routingElement); - lastSource = gatewayData.sourceID; - } - //at the end of the route, connect to the sink ! - routingElement.sourceID = lastSource; - routingElement.sinkID = sinkID; - routingElement.domainID = sinkDomainID; - actualRoutingElement.push_back(routingElement); - - //So now we got the route, what is missing are the connectionFormats... - - //Step through the routes and try to use always the best connectionFormat - std::vector::iterator routingInterator=actualRoutingElement.begin(); - gatewayIterator =listGatewayID.begin(); - if(findBestWay(actualRoutingElement,routingInterator,gatewayIterator,0)!=E_OK) continue; - - //add the route to the list of routes... - actualRoute.sourceID = sourceID; - actualRoute.sinkID = sinkID; - actualRoute.route = actualRoutingElement; - returnList.push_back(actualRoute); - } - return (E_OK); + //first find out in which domains the source and sink are + am_domainID_t sourceDomainID; + am_domainID_t sinkDomainID; + if (mDatabaseHandler->getDomainOfSource(sourceID, sourceDomainID) != E_OK) + return (E_NON_EXISTENT); + if (mDatabaseHandler->getDomainOfSink(sinkID, sinkDomainID) != E_OK) + return (E_NON_EXISTENT); + + RoutingTree routingtree(sourceDomainID); //Build up a Tree from the Source_Domain to every other domain. + std::vector flattree; //This list is the flat tree + std::vector matchtree; //This List holds all TreeItems which have the right Domain Sink IDs + std::vector listGatewayID; //holds all gateway ids of the route + am_RoutingElement_s routingElement; + std::vector actualRoutingElement; //intermediate list of current routing pairs + am_Route_s actualRoute; //holds the actual Route + am_sourceID_t lastSource = 0; + + //TODO: kind of unclean. The separation between database and router could be better. + mDatabaseHandler->getRoutingTree(onlyfree, &routingtree, &flattree); //Build up the tree out of the database as + + //we go through the returned flattree and look for our sink, after that flattree holds only treeItems that match + std::vector::iterator flatIterator = flattree.begin(); + for (; flatIterator != flattree.end(); ++flatIterator) + { + if ((*flatIterator)->returnDomainID() != sinkDomainID) + { + flatIterator = flattree.erase(flatIterator); + } + } + + //No we need to trace back the routes for each entry in matchtree + flatIterator = flattree.begin(); + for (; flatIterator != flattree.end(); ++flatIterator) + { + //getting the route for the actual item + routingtree.getRoute(*flatIterator, &listGatewayID); //This gives only the Gateway IDs we need more + + //go throught the gatewayids and get more information + std::vector::iterator gatewayIterator = listGatewayID.begin(); + for (; gatewayIterator != listGatewayID.end(); ++gatewayIterator) + { + am_Gateway_s gatewayData; + if (mDatabaseHandler->getGatewayInfoDB(*gatewayIterator, gatewayData) != E_OK) + return (E_UNKNOWN); + + //at the beginning of the route, we connect first the source to the first gateway + if (gatewayIterator == listGatewayID.begin()) + { + routingElement.sourceID = sourceID; + routingElement.domainID = sourceDomainID; + } + else + { + routingElement.sourceID = lastSource; + routingElement.domainID = gatewayData.domainSinkID; + } + routingElement.sinkID = gatewayData.sinkID; + actualRoutingElement.push_back(routingElement); + lastSource = gatewayData.sourceID; + } + //at the end of the route, connect to the sink ! + routingElement.sourceID = lastSource; + routingElement.sinkID = sinkID; + routingElement.domainID = sinkDomainID; + actualRoutingElement.push_back(routingElement); + + //So now we got the route, what is missing are the connectionFormats... + + //Step through the routes and try to use always the best connectionFormat + std::vector::iterator routingInterator = actualRoutingElement.begin(); + gatewayIterator = listGatewayID.begin(); + if (findBestWay(actualRoutingElement, routingInterator, gatewayIterator, 0) != E_OK) + continue; + + //add the route to the list of routes... + actualRoute.sourceID = sourceID; + actualRoute.sinkID = sinkID; + actualRoute.route = actualRoutingElement; + returnList.push_back(actualRoute); + } + return (E_OK); } -void Router::listPossibleConnectionFormats(const am_sourceID_t sourceID,const am_sinkID_t sinkID,std::vector& listFormats) const +void Router::listPossibleConnectionFormats(const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector& listFormats) const { - std::vector listSourceFormats; - std::vector listSinkFormats; - mDatabaseHandler->getListSinkConnectionFormats(sinkID,listSinkFormats); - mDatabaseHandler->getListSourceConnectionFormats(sourceID,listSourceFormats); - set_union(listSourceFormats.begin(), listSourceFormats.end(), listSinkFormats.begin(), listSinkFormats.end(), listFormats.begin()); + std::vector listSourceFormats; + std::vector listSinkFormats; + mDatabaseHandler->getListSinkConnectionFormats(sinkID, listSinkFormats); + mDatabaseHandler->getListSourceConnectionFormats(sourceID, listSourceFormats); + std::insert_iterator > inserter(listFormats, listFormats.begin()); + set_intersection(listSourceFormats.begin(), listSourceFormats.end(), listSinkFormats.begin(), listSinkFormats.end(), inserter); } am_Error_e Router::findBestWay(std::vector & listRoute, std::vector::iterator routeIterator, std::vector::iterator gatewayIterator, int choiceNumber) { - std::vector listConnectionFormats; - std::vector listPriorityConnectionFormats; - //get best connection format for the first connection, now - listPossibleConnectionFormats(routeIterator->sinkID,routeIterator->sourceID,listConnectionFormats); - - //if we get to the point that no choice makes sense, return ... - if (choiceNumber>=(int)listConnectionFormats.size()) return (E_NOT_POSSIBLE); - - //if we have not just started, we need to take care about the gateways... - if(routeIterator!=listRoute.begin()) - { - //since we have to deal with Gateways, there are restrictions what connectionFormat we can take. So we need to take the subset of connections that are restricted: - std::vector listRestrictedConnectionFormats; - listRestrictedOutputFormatsGateways(*gatewayIterator,(routeIterator--)->connectionFormat,listRestrictedConnectionFormats); - set_union(listConnectionFormats.begin(), listConnectionFormats.end(), listRestrictedConnectionFormats.begin(), listRestrictedConnectionFormats.end(), listConnectionFormats.begin()); - } - - //let the controller decide: - getConnectionFormatChoice(routeIterator->sinkID,routeIterator->sourceID,listConnectionFormats,listPriorityConnectionFormats); - - //go back one step, if we cannot find a format! - if(listPriorityConnectionFormats.empty()) - { - findBestWay(listRoute,routeIterator--,gatewayIterator--,choiceNumber++); - } - routeIterator->connectionFormat=listPriorityConnectionFormats.at(choiceNumber); - - if (routeIterator listConnectionFormats; + std::vector listPriorityConnectionFormats; + //get best connection format for the first connection, now + listPossibleConnectionFormats(routeIterator->sourceID, routeIterator->sinkID, listConnectionFormats); + + //if we get to the point that no choice makes sense, return ... + if (choiceNumber >= (int) listConnectionFormats.size()) + return (E_NOT_POSSIBLE); + + //if we have not just started, we need to take care about the gateways... + if (routeIterator != listRoute.begin()) + { + //since we have to deal with Gateways, there are restrictions what connectionFormat we can take. So we need to take the subset of connections that are restricted: + std::vector listRestrictedConnectionFormats; + std::insert_iterator > inserter(listConnectionFormats, listConnectionFormats.begin()); + std::vector::iterator tempIterator(routeIterator); + tempIterator--; + listRestrictedOutputFormatsGateways(*gatewayIterator, (tempIterator)->connectionFormat, listRestrictedConnectionFormats); + set_intersection(listConnectionFormats.begin(), listConnectionFormats.end(), listRestrictedConnectionFormats.begin(), listRestrictedConnectionFormats.end(), inserter); + gatewayIterator++; + } + + //let the controller decide: + getConnectionFormatChoice(routeIterator->sinkID, routeIterator->sourceID, listConnectionFormats, listPriorityConnectionFormats); + + //go back one step, if we cannot find a format and take the next best! + if (listPriorityConnectionFormats.empty()) + { + findBestWay(listRoute, --routeIterator, --gatewayIterator, ++choiceNumber); + } + + routeIterator->connectionFormat = listPriorityConnectionFormats.at(choiceNumber); + + //ok, we are through and found a way, if not, take the next part of the route and start with toplevel + if (routeIterator < listRoute.end()) + { + findBestWay(listRoute, ++routeIterator, gatewayIterator, 0); + } + return (E_OK); } void Router::listRestrictedOutputFormatsGateways(const am_gatewayID_t gatewayID, const am_ConnectionFormat_e sinkConnectionFormat, std::vector & listFormats) const { - listFormats.clear(); - am_Gateway_s gatewayData; - std::vector::const_iterator rowSinkIterator=gatewayData.listSinkFormats.begin(); - std::vector::const_iterator matrixIterator=gatewayData.convertionMatrix.begin(); - mDatabaseHandler->getGatewayInfoDB(gatewayID,gatewayData); - - //find the row number of the sink - rowSinkIterator = find (gatewayData.listSinkFormats.begin(), gatewayData.listSinkFormats.end(), sinkConnectionFormat); - int rowNumberSink=rowSinkIterator - gatewayData.listSinkFormats.begin(); - - //go through the convertionMatrix and find out if the conversion is possible, if yes, add connectionFormat ... - matrixIterator+rowNumberSink; - - //iterate line-wise through the matrix and add more formats - do - { - if(*matrixIterator) - { - listFormats.push_back(gatewayData.listSourceFormats.at(matrixIterator-gatewayData.convertionMatrix.begin())); - } - matrixIterator+gatewayData.listSinkFormats.size(); - } - while (matrixIterator-gatewayData.convertionMatrix.begin()<(int)gatewayData.listSourceFormats.size()); + listFormats.clear(); + am_Gateway_s gatewayData; + mDatabaseHandler->getGatewayInfoDB(gatewayID, gatewayData); + std::vector::const_iterator rowSinkIterator = gatewayData.listSinkFormats.begin(); + std::vector::const_iterator matrixIterator = gatewayData.convertionMatrix.begin(); + + //find the row number of the sink + rowSinkIterator = find(gatewayData.listSinkFormats.begin(), gatewayData.listSinkFormats.end(), sinkConnectionFormat); + int rowNumberSink = rowSinkIterator - gatewayData.listSinkFormats.begin(); + + //go through the convertionMatrix and find out if the conversion is possible, if yes, add connectionFormat ... + matrixIterator + rowNumberSink; + + //iterate line-wise through the matrix and add more formats + do + { + if (*matrixIterator) + { + listFormats.push_back(gatewayData.listSourceFormats.at(matrixIterator - gatewayData.convertionMatrix.begin())); + } + matrixIterator += gatewayData.listSinkFormats.size(); + } while (matrixIterator - gatewayData.convertionMatrix.begin() < (int) gatewayData.listSourceFormats.size()); } - Router::~Router() { } -RoutingTreeItem::RoutingTreeItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID, RoutingTreeItem *parent) - :mDomainID(domainID), - mGatewayID(gatewayID), - mParentItem(parent) +RoutingTreeItem::RoutingTreeItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID, RoutingTreeItem *parent) : + mDomainID(domainID), // + mGatewayID(gatewayID), // + mParentItem(parent) { - assert(mDomainID==0); - assert(mGatewayID==0); - assert(mParentItem); + assert(mDomainID!=0); } void RoutingTreeItem::appendChild(RoutingTreeItem *newChild) { - assert(newChild); - mListChildItems.push_back(newChild); + assert(newChild); + mListChildItems.push_back(newChild); } void RoutingTreeItem::returnChildItems(std::vector listChildItems) { - listChildItems=mListChildItems; + listChildItems = mListChildItems; } am_domainID_t RoutingTreeItem::returnDomainID() const { - return (mDomainID); + return (mDomainID); } am_gatewayID_t RoutingTreeItem::returnGatewayID() const { - return (mGatewayID); + return (mGatewayID); } RoutingTreeItem* RoutingTreeItem::returnParent() const { - return (mParentItem); + return (mParentItem); } RoutingTreeItem::~RoutingTreeItem() { } - -RoutingTree::RoutingTree(const am_domainID_t rootDomainID) - :mRootItem(RoutingTreeItem(rootDomainID)) +RoutingTree::RoutingTree(const am_domainID_t rootDomainID) : + mRootItem(RoutingTreeItem(rootDomainID)) { - assert(rootDomainID!=0); + assert(rootDomainID!=0); } RoutingTreeItem *RoutingTree::insertItem(const am_domainID_t domainID, const am_gatewayID_t gatewayID, RoutingTreeItem *parent) { - RoutingTreeItem *newTree = new RoutingTreeItem(domainID, gatewayID,parent); - parent->appendChild(newTree); - mListChild.push_back(newTree); - return newTree; + RoutingTreeItem *newTree = new RoutingTreeItem(domainID, gatewayID, parent); + parent->appendChild(newTree); + mListChild.push_back(newTree); + return newTree; } void RoutingTree::getRoute(RoutingTreeItem *targetItem, std::vector *listGateways) { - RoutingTreeItem *parentItem = targetItem; - while (parentItem != &mRootItem) { - listGateways->push_back(parentItem->returnGatewayID()); - parentItem = parentItem->returnParent(); - } + RoutingTreeItem *parentItem = targetItem; + while (parentItem != &mRootItem) + { + listGateways->push_back(parentItem->returnGatewayID()); + parentItem = parentItem->returnParent(); + } } am_domainID_t RoutingTree::returnRootDomainID() const { - return (mRootItem.returnDomainID()); + return (mRootItem.returnDomainID()); } RoutingTreeItem *RoutingTree::returnRootItem() { - return (&mRootItem); + return (&mRootItem); } RoutingTree::~RoutingTree() { - std::vector::iterator it=mListChild.begin(); - for(;it!=mListChild.end();++it) - { - delete *it; - } + std::vector::iterator it = mListChild.begin(); + for (; it != mListChild.end(); ++it) + { + delete *it; + } } - - - - - diff --git a/CHANGELOG b/CHANGELOG index 5b30a2f..088864e 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,4 +1,34 @@ -commit 126870e1c2af541558aefd46aad38565c0ece795 +commit 4fe50302a695c625d5161b538da771b2c36bd33e +Author: christian mueller + + * formatting all the source code with eclipse source code style + * added used xml to the project + +commit 80213f17291e5b58c733de09f06439d71640d2e2 +Author: christian mueller + + * fixed wrong memset in main.cpp (thanks to frank) + * fixed compiler warnings in signalhandler + * added Router Class: this class does now the autorouting job. First commit, no tests yet + +commit adf0d48f869007e4527b00e1a346ed37ee82cc1a +Author: christian mueller + + * fix for package building with lower cmake versions + * fix DBus interface to be GLIB tolerant 32bit types + +commit 8a99f39f0a5b84230bb6e764950dc674258870e8 +Author: christian mueller + + * fix build without git + +commit 3d458653de2ec50f524b38d33645fd773bcb207f +Author: christian mueller + + * fixed compilation without git + * fixed compilation without tests + +commit 23c90675c09d4e2947b5a827a5ebcd5516c0270e Author: christian mueller * added package creation based on cpack diff --git a/includes/control/ControlSendInterface.h b/includes/control/ControlSendInterface.h index 8d2f299..9c1fa7a 100644 --- a/includes/control/ControlSendInterface.h +++ b/includes/control/ControlSendInterface.h @@ -22,8 +22,8 @@ * * THIS CODE HAS BEEN GENERATED BY ENTERPRISE ARCHITECT GENIVI MODEL. PLEASE CHANGE ONLY IN ENTERPRISE ARCHITECT AND GENERATE AGAIN */ -#if !defined(EA_F5981A51_5790_4c74_A384_3600DFC50AF5__INCLUDED_) -#define EA_F5981A51_5790_4c74_A384_3600DFC50AF5__INCLUDED_ +#if !defined(EA_7E13E25E_46FA_4211_BD7C_7169D8F7D065__INCLUDED_) +#define EA_7E13E25E_46FA_4211_BD7C_7169D8F7D065__INCLUDED_ #include #include @@ -40,7 +40,7 @@ namespace am { * All the hooks represent system events that need to be handled. The callback functions are used to handle for example answers to function calls on the AudioManagerCoreInterface. * @author christian * @version 1.0 - * @created 11-Jan-2012 9:55:56 PM + * @created 19-Jan-2012 4:32:01 PM */ class ControlSendInterface { @@ -342,6 +342,16 @@ namespace am { */ virtual void cbAckSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error) =0; /** + * This function is used by the routing algorithm to retrieve a priorized list of connectionFormats from the Controller. + * @return E_OK in case of successfull priorisation. + * + * @param sourceID sourceID of source that shall be connected + * @param sinkID sinkID of sink that shall be connected + * @param listPossibleConnectionFormats list of possible connectionformats + * @param listPrioConnectionFormats the list return with prioos from the controller. Best choice on first position. + */ + virtual am_Error_e getConnectionFormatChoice(const am_sourceID_t sourceID, const am_sinkID_t sinkID, const std::vector listPossibleConnectionFormats, std::vector& listPrioConnectionFormats) =0; + /** * This function returns the version of the interface * returns E_OK, E_UNKOWN if version is unknown. */ @@ -349,4 +359,4 @@ namespace am { }; } -#endif // !defined(EA_F5981A51_5790_4c74_A384_3600DFC50AF5__INCLUDED_) +#endif // !defined(EA_7E13E25E_46FA_4211_BD7C_7169D8F7D065__INCLUDED_)