EP3077924A1 - Vorrichtung, system und verfahren zur effizienten und verzögerungsarmen synchronisation graphenförmiger datenstrukturen - Google Patents

Vorrichtung, system und verfahren zur effizienten und verzögerungsarmen synchronisation graphenförmiger datenstrukturen

Info

Publication number
EP3077924A1
EP3077924A1 EP14811795.5A EP14811795A EP3077924A1 EP 3077924 A1 EP3077924 A1 EP 3077924A1 EP 14811795 A EP14811795 A EP 14811795A EP 3077924 A1 EP3077924 A1 EP 3077924A1
Authority
EP
European Patent Office
Prior art keywords
data model
nodes
server
node
client
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Withdrawn
Application number
EP14811795.5A
Other languages
English (en)
French (fr)
Inventor
Gabriel Gatzsche
Tobias Gehlhaar
Thomas Sporer
Maximilian HELLER
Mario SEIDENECK
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Fraunhofer Gesellschaft zur Forderung der Angewandten Forschung eV
Original Assignee
Fraunhofer Gesellschaft zur Forderung der Angewandten Forschung eV
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Fraunhofer Gesellschaft zur Forderung der Angewandten Forschung eV filed Critical Fraunhofer Gesellschaft zur Forderung der Angewandten Forschung eV
Publication of EP3077924A1 publication Critical patent/EP3077924A1/de
Withdrawn legal-status Critical Current

Links

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/27Replication, distribution or synchronisation of data between databases or within a distributed database system; Distributed database system architectures therefor
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/80Information retrieval; Database structures therefor; File system structures therefor of semi-structured data, e.g. markup language structured data such as SGML, XML or HTML
    • G06F16/83Querying
    • G06F16/835Query processing
    • G06F16/8373Query execution
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/90Details of database functions independent of the retrieved data types
    • G06F16/901Indexing; Data structures therefor; Storage structures
    • G06F16/9024Graphs; Linked lists

Definitions

  • the application relates to low-delay synchronization, and more particularly to an apparatus, system and method for efficient low-delay synchronization of graphene-shaped, e.g. tree-shaped data structures.
  • a large number of software applications internally use a graph-shaped, e.g. tree-structured data structure.
  • a tree-structured data structure is In this case, the state of the application can be kept in such a data structure. If parts of the data structure change, the application responds to it and changes e.g. the screen display or controls a connected peripheral device.
  • the underlying design pattern is called MVC (Model View Controller). If one wishes to have such an application whose state is in such a graphiform, e.g. tree-shaped data structure, run on multiple devices simultaneously, e.g. to let multiple users work collaboratively (collaboratively / collaboratively) with the application, or a user wants to have different representations of the application on different terminals, e.g. distribute a tablet PC and a mobile phone for better usability, the following must happen:
  • the second approach is a so-called document-oriented approach, see e.g. CouchDb, MongoDb.
  • the data is structured in a graph, and can be reached via an address path (address path).
  • address path address path
  • a device according to claim 1, a server according to claim 14, a client according to claim 21, a system according to claim 25, a method according to claim 26 and a computer program according to claim 27 are provided.
  • the apparatus comprises a data model wherein the data model comprises three or more nodes, wherein one or more of the three or more nodes of the data model is assigned an ID, each of these one or more nodes being uniquely distinguishable by its ID from the other nodes of the data model, wherein at least two of the nodes of the data model each have one or more attributes, wherein each of said attributes may take on a value that is in the Data model is stored, each node of said at least two nodes is assigned a path, the path to the respective node, which is assigned to this path, and at least one of the three or more nodes of the data model, and wherein the path of each Node of the said at least two nodes is different from the ID of the respective node.
  • each of the nodes of the data model may be assigned an ID, wherein each of the nodes of the data model is uniquely distinguishable by its ID from the other nodes of the data model.
  • the apparatus comprises a controller comprising a write function for each attribute of each of the three or more nodes of the data model having attributes, and wherein the value of the attribute is changeable by the write function.
  • the device comprises a synchronizer.
  • the synchronizer is adapted to receive an update message designating one of the nodes of the data model, the update message further designating an attribute of that node, and wherein the update message indicates how to update the value of that attribute, wherein the update message is the node denoted by the ID of the node.
  • the controller is adapted to update the value of this attribute of this node in response to the update message using the write function of that attribute.
  • the write function assumes not only the setting of the value in the data model, but also informing the synchronizer and / or informing other observers, as well as other possible functions such as recording changes over time for later playback or cancellation.
  • the synchronizer is configured to send update messages.
  • Embodiments of the invention have numerous advantages over the prior art, for example considerably easier expandability of the synchronization protocol, completely web-based implementation of transparent synchronization for the application developer and / or easy integration of new components. While in the prior art provider only a protocol, but not persistent data representation in the client and in the server, according to embodiments, the persistent data representation defined and derived from the protocol. Embodiments provide additional tools.
  • a server is provided.
  • the server is a device as described above. Further, the server is adapted to receive a login from one or more clients. Further, the server is adapted to transfer information about the data model to the one or more clients upon their logon, which information, via the data model, includes the values of the attributes of all nodes or of two or more of the nodes of the data model, and the information about the data model further indicating, for each node of the data model or for the at least two nodes of the data model, one or more of the nodes of the data model immediately following that node and / or one or more nodes of the data model Immediately precede nodes.
  • the server may e.g. be configured to transmit the ID of two or more of the nodes of the data model of the server to the one or more clients upon their logon.
  • a client is provided.
  • the server is a device as described above. Further, the client is set up to log in to the server described above.
  • the client is set up, upon logging on to the server, to receive information about the server's data model, which information about the server's data model includes the values of the attributes of all the nodes or two or more nodes of the server's data model Attributes, and wherein the information about the data model of the server further for each node of the data model or for the two or more nodes of the data model of the server indicate which of the nodes of the data model of the server immediately follow this node and / or which nodes of the data model of the Servers immediately precede this node. Further, the client is set up to update its data model depending on the information about the data model of the server.
  • a system includes the server described above and the client described above.
  • the client is set up to send the server an update message.
  • the server's synchronizer is adapted to receive the update message designating one of the nodes of the data model, which further designates an attribute of that node, and which indicates how to update the value of this attribute.
  • the controller of the server is arranged to update the value of this attribute of that node in response to the update message, if the update message designates the ID of the node.
  • the method comprises:
  • the update message designating a node of a data model by means of an ID of the node, the update message further indicating an attribute of that node, and wherein the update message indicates how to update a value of that attribute
  • the data model comprising three or more nodes wherein one or more of the three or more nodes of the data model is assigned an ID, each of which one or more nodes being uniquely distinguishable by its ID from the other nodes of the data model, wherein at least two of the nodes of the data model are each one or a plurality of attributes, wherein each of said attributes may take on a value stored in the data model, each node of said at least two nodes being assigned a path, the path being specified to the respective node to which that path is assigned, and at least another one of the three or more nodes of the data model, and wherein the path specification of each node of said at least two nodes differs from the ID of the respective node.
  • the method may include a further step or steps, for example:
  • FIG. 1 a shows a device according to an embodiment
  • Fig. 1b shows the hierarchical graph structure of the data model according to a
  • 1 c shows a system according to an embodiment
  • FIG. 2a shows a data model, an observer structure and a controller
  • FIG. 2 c shows a practical example of the setup of a sound system without the use of UI.FM.
  • Fig. 2d - 2g show application examples according to the invention for low-delay
  • FIG. 3 shows a UI.FM system according to preferred embodiments
  • 5a-5c show an implementation according to the invention of a web application according to an embodiment
  • FIGS. 7a-7f show a data model and its programming implementation according to an embodiment
  • Figures 9a-9h show the change of a data structure by adding an attribute according to an embodiment
  • Figures 10a-10e show how users can be informed according to an embodiment when a value of the data model changes, and shows an alarm output upon playback of one Data recording according to the reproduced data recording according to an embodiment.
  • Fig. 1a shows a device according to an embodiment.
  • the apparatus comprises a data model 110, wherein the data model 110 comprises three or more nodes, wherein one or more of the three or more nodes of the data model 110 is assigned an ID, each of these one or more nodes by its ID from the others Node of the data model 1 10 is uniquely distinguishable, wherein at least two of the nodes of the data model 1 10 each having one or more attributes, each of said attributes can assume a value stored in the data model 1 10, each node of said at least two nodes are assigned a path specification, the path specification having the respective node to which this path assignment is assigned, and at least one further one of the three or more nodes of the data model 110, and wherein the path specification of each node of the at least two nodes is from the ID of the respective node is different.
  • each of the nodes of the data model 110 may be assigned an ID, with each of the nodes of the data model being uniquely distinguishable by its ID from the other nodes of the data model 110.
  • the nodes of the data model have a path that has more than one node. If, for example, in a tree hierarchy a node “Renderer” follows directly the node “root”, then the path can be For example, "root.Renderer” is the name of the path, and this path statement therefore includes two of the nodes of the data model, namely "root” and "renderer.”
  • the node "renderer” is also unique in the data model ID, for example the number "2" (see eg data model 310 in FIG. 3). In any case, the ID and path of a node are always different. The ID assigned to the node therefore exists in addition to the path.
  • One of the purposes of the path statement is that the nodes of the data model are intuitively accessible via the path structure, while the ID serves to address the node through a short identifier.
  • the apparatus comprises a controller 120 comprising a write function for each attribute of each of the three or more nodes of the data model having attributes, and wherein the value of the attribute is changeable by the write function.
  • the device further comprises a synchronizer 130.
  • the synchronizer 30 is adapted to receive an update message designating one of the nodes of the data model 110, the update message further designating an attribute of that node, and the update message indicating how the value of this attribute, the update message designating the node by the ID of the node.
  • the controller 120 is adapted to update the value of this attribute of this node in response to the update message using the write function of that attribute.
  • the data model 1 10 may have a graph-shaped structure. For example, it may be specified that a node "root” precedes the node "renderer”. This relationship can be defined or specified as a graph from "root” to "renderer”. Further, for example, it may be specified that the "Renderer” node precedes the "Scene” node. This relationship can be defined as a graph from "renderer” to "scene”. The graph-shaped structure of the data model 1 10 then results from all such relationships.
  • the data model 110 can have a tree-shaped hierarchical structure, which can be regarded as a special case of a graph-type structure. In a tree-shaped hierarchical structure, there is usually a root node to which all further nodes follow the data model directly or indirectly. Such a tree-shaped hierarchical structure is shown in Fig. 1 b.
  • a path statement "root.Renderer.Scene.srcO” may uniquely identify the corresponding node srcO in a tree-shaped hierarchy, such as the tree-shaped hierarchy of Fig. 1b.
  • Such a path statement includes the node “srcO” and three other nodes of the data model "root”, “renderer”, and "scene.”
  • Using only "srcO” as the name to uniquely identify the corresponding node may not be enough, because the node "srcO" might be the name in the file name. ten model several times before.
  • An ID with which the node is addressed briefly and unambiguously can be, for example, a number.
  • the node srcO could be designated by the ID "7.”
  • ID and path A simple ID has only one requirement: it must uniquely address a node system-wide, so that, for example, all nodes are sufficient
  • a path specification usually fulfills additional properties beyond the ID: It contains local node names which describe a path from the root of the graph to the node to be addressed via intermediate nodes The node name can only be unique for the node and its sibling nodes. The combination of the local node names of a node with the local node names of the parent or predecessor elements of a node also creates the system-wide, unambiguous path specification.
  • the ID of each of the three or more nodes of the data model may be a number or a string, or a hash value.
  • the controller 120 includes a read function for each attribute of each of the three or more nodes of the data model having attributes, the value of the attribute being readable by the read function.
  • the synchronizer 140 may be configured to receive the update message with the ID contained therein to determine an associated controller subunit of the controller 120 that is responsible for that node (for example, the synchronizer 140 has a dictionary for it (Dictionary) / a map ( Figure), which stores a reference to a controller subunit for each ID), and then to pass this to an information containing the name of the attribute to be changed as well as the value.
  • the controller subunit of the controller 120 then changes the data model 1 10 using the write function.
  • the synchronizer is adapted to receive the update message designating said node of the data model, the update message further designating said attribute of that node, and wherein the update message indicates how to update the value of that attribute, wherein the update message designates the path of the node, the controller being adapted to update the value of that attribute of that node in response to the update message.
  • the three or more nodes of the data model form a graphene, e.g. tree-shaped hierarchy such that each node of the data model immediately follows at least one of the nodes of the data model in the graph hierarchy and / or immediately precedes at least one of the nodes of the data model in the graph hierarchy, wherein at least one of the nodes of the data model has two nodes of the data model in the immediately follow tree-shaped hierarchy.
  • a graphene e.g. tree-shaped hierarchy such that each node of the data model immediately follows at least one of the nodes of the data model in the graph hierarchy and / or immediately precedes at least one of the nodes of the data model in the graph hierarchy, wherein at least one of the nodes of the data model has two nodes of the data model in the immediately follow tree-shaped hierarchy.
  • 1 b shows such a graph-shaped data structure using the example of a tree-shaped hierarchical data structure of the data model according to an embodiment.
  • the nodes "DHD®” and “Renderer” immediately follow the node “root.” Conversely, the node "root” immediately precedes the nodes "DHD®", and “renderer”.
  • the Renderer node is immediately followed by the LSSetups, Scene, Spatial Sound Wave, and WavPI nodes, and the Renderer node reverses the LSSetups, Scene, Spatial Sound Wave nodes. and "WavPI" immediately ahead, etc.
  • the device further comprises an interface adapted to receive information about changes in the data model that add one or more attributes to one of the nodes of the data model, the device being adapted to provide one or more attributes for each of these added automatically generating a read function and a write function, wherein the value of said attribute is readable by means of the read function, and wherein the value of the attribute is changeable by means of the write function.
  • the generated write function not only alters the value of the local data model, but also provides for notifying the synchronizer of the change, propagating change events in the system, and / or accompanying observers can respond to the change and / or know - Other things are caused, such as the recording of automation data, undo / redo, etc.
  • the apparatus is adapted to provide the read function and the write function for each of the attributes of each of the nodes of the data model having attributes by means of a web application such that said reading function and said writing function are useable by the web application.
  • the web application may be implemented in JavaScript and / or HTML.
  • the device is adapted to set up change monitoring for one of the attributes of one of the nodes of the data model, responsive to user input.
  • change monitoring may be set up to send or trigger an "event”.
  • the device is adapted to issue an alarm when a value of one of the attributes for which change monitoring is established changes.
  • a server is provided.
  • the server is a device as described above. Further, the server is adapted to receive a login from one or more clients.
  • the server is arranged to transmit information about the data model to the one or more clients upon their logon, which information about the data mode includes the values of the attributes of all nodes or of two or more of the nodes of the data model, the attributes and wherein the information about the data model further indicates, for each node of the data model or for the at least two nodes of the data model, which of the nodes of the data model immediately follow that node and / or which nodes of the data model immediately precede this node.
  • the data model also contains, for example, the node IDs.
  • the server is adapted to receive a logon from two or more clients, wherein the server's synchronizer is adapted to receive a message from one of the clients indicating that a value of an attribute of a node of the data model is changing and the server's synchronizer is configured to respond to the message from said client, the other two or more clients that have logged in to the server, that a value of an attribute of a node of the data model is changed Has.
  • the server can also receive the data model and updates from client. This may be useful, for example, if the client has been using it for a long time, e.g. without connection to the server, e.g. worked offline.
  • the server is configured to send a device wirelessly or by wire a device that notifies the device that an attribute of one of the nodes of the data model has changed.
  • the device is adapted to communicate to the device the message wirelessly, e.g. via WLAN, GPRS, UMTS or LTE.
  • the device is a renderer for generating one or more speaker signals.
  • the device may also be a DHD® audio matrix.
  • the connected clients may be a (3D) audio workstation, an audio plug-in (VST / RTAS / AudioUnits, etc.) and / or an iPad® app.
  • the server is adapted to receive from the client information about the client's data model, which information about the client's data model includes the values of the attributes of all the nodes or of two or more of the nodes of the client's data model, the attributes and wherein the information about the client's data model further indicates for each node of the client's data model or for the at least two nodes of the client's data model which of the clients' data model nodes directly to that node follow and / or which nodes of the data model of the client immediately precede this node.
  • a client is provided.
  • the server is a device as described above.
  • the client is set up to log in to the server described above.
  • the client is set up, upon logging on to the server, to receive information about the server's data model, which information about the server's data model includes the values of the attributes of all the nodes or two or more nodes of the server's data model Attributes, and wherein the information about the data model of the server further for each node of the data model or for the two or more nodes of the data model of the server indicate which of the nodes of the data model of the server immediately follow this node and / or which nodes of the data model of the Servers immediately precede this node.
  • the client is set up to update its data model depending on the information about the data model of the server.
  • the client is adapted to transfer information to the server via the client's data mode, which information, via the client's data model, includes the values of the attributes of all nodes or of two or more of the nodes of the client's data model, have the attributes, and wherein the information about the client's data model further indicates for each node of the client's data model or for the at least two nodes of the client's data model which of the clients' data model nodes immediately follow that node and / or which nodes of the client Data model of the client immediately precede this node.
  • the client may be configured to create object-oriented audio scenes.
  • Fig. 1 c shows a system according to an embodiment.
  • the system includes the above-described server 170 and the above-described client 160.
  • the client 160 is configured to send the server 170 an update message.
  • the synchronizer of the server 170 is adapted to receive the update message designating one of the nodes of the data model of the server 170, which further designates an attribute of that node, and indicating how to update the value of that attribute.
  • the controller of the server 170 is adapted to update the value of this attribute of this node in response to the update message if the update message identifies the ID of the node.
  • Embodiments provide a general mechanism that combines the benefits of key-value-based (key-value-based) databases with document-centric approaches.
  • the goal is to synchronize graphene-structured data structures in real time and / or with low-latent or low-delay data.
  • a graph-shaped data structure which represents the data of the application.
  • the executable controller and data model code is generated using a code generator. This can be done server-side as well as on the client side.
  • the code thus generated includes, for example, routines for reading and writing the data to the graph model, routines for notifying changes by interested observers, and routines for transmitting the changes to the data model to a central server or clients connected thereto.
  • Fig. 2a shows three structures, namely a data model (model) 201, an observer structure (view / view) 203, and a controller structure (controller) 202, which are automatically generated based on an original data model that is graph-shaped ,
  • the generated controller structure 202 includes the same code for synchronizing the tree hierarchy with the server and thus with other clients.
  • the synchronization can take place from the client to the server and / or from the server to the client.
  • 2b shows a possible flow of synchronization between a client 210 and a server 220.
  • the client 210 includes a data model 21 1, a controller 212, a view 213, and a synchronizer 214.
  • the server 220 includes FIG. 2 b shows a data model 221, a controller 222 and a synchronizer 224.
  • Anna modifies something
  • the controller 212 of the client 210 changes the tree-shaped data structure (model) 21 1, and simultaneously informs the synchronizer 214 of the client 210 by means of an update message. All this happens, e.g. with the help of the automatically generated write function.
  • Synchronizer 214 of client 210 transmits the change in an update message to server 220, e.g.
  • the server 220 enters the change in its local data model 221, e.g.
  • the server 220 simultaneously transmits the change to all clients (not shown in FIG. 2b).
  • server or a client application starts, they first load the definition of the graph-type data structure and generate the application code with the aid of the previously mentioned code generator.
  • the code generator can be loaded, for example, from a hard disk, or transferred, for example, when logging on from the server to the client. Furthermore, for example, each node of the graph-shaped data structure is assigned a unique identifier for the client.
  • the generation of the ID can take place, for example, as follows. Each client first gets a system-wide unique client ID. When a client creates a new node, a locally unique node identifier is combined with the client id to a system-wide unique node id. As a result, no central ID generation is necessary after transmission of the client ID.
  • the main advantages here are that no server queries are necessary to create new nodes in the client. This also allows the client offline to generate unique IDs system-wide. Prerequisite, however, is that the client was at least once connected to the server. In the client locally generated nodes are (later) eg to the server and the remaining clients to transfer and there to mount in the local data structure. However, it is no longer necessary to rename IDs.
  • the ID will only be valid at runtime. With the help of this ID it is possible later to address each node of the tree directly. Instead of a long path address, such as "/ stem / branch / branch / leaf / cell", the node of the tree can then also be addressed via the ID, which represents a short hash, eg "0d4" Applications (applications) with high data volume of importance.
  • the data structures must first be synchronized. If the client has worked offline for a while, it often makes sense to match the data structure from client to server, e.g. by informing the server about the current data structure of the client so that the server can, for example, adapt its data structure. If, on the other hand, the client wishes to subsequently load the existing application from the server, then e.g. to reconcile the data structure from the server to the client, for example by the client receiving the data structure of the server from the latter.
  • the node IDs must be matched between client and server, i. related client-side and server-side nodes must have the same addresses.
  • the server generates, for example, an ID tree which has the same structure as the data tree, but initially contains only the IDs.
  • the server or the client could, for example, also transmit a table which assigns paths to Ids. This ID tree is transmitted to the client. This replaces the existing IDs with those of the server. Viewers (views) of the tree are also informed about the renaming of the IDs.
  • Example 1 A first possibility is to transfer the tree data as a tree-shaped data structure to the client and to parse (enter) into the corresponding nodes.
  • Example 2 A second option is to transfer the tree data node-by-node from the server to the client. For this purpose, for example, the data of the respective node together with the node identifier or node name in a data packet packed and transferred to the client. The latter can use the node identifiers to determine the associated node and write the corresponding data in it.
  • the first option is used to initially transfer larger data structures from the server to the client or vice versa.
  • the second option is used to effectively exchange small but common changes between client and server.
  • Embodiments combine the performance benefits of key-value databases with the possibilities of document-based approaches (e.g., XML, JSON data) as well as automated code generation.
  • the key-value addressing of data enables fast machine access to data. This ensures a high-frequency low-latency synchronization of software applications.
  • Automatic code generation allows the automatic generation of recurring code components such as controllers, publishers, parsers, serializers, synchronizers, read and write functions from the graph-shaped data structure. This allows a further reduction of the development time for distributed software applications.
  • UI.FM User Interface Framework
  • some embodiments may be used to simultaneously render 3D audio systems from multiple listening positions, e.g. in a stadium to set up acoustically.
  • Fig. 2c shows an example without using UI.FM.
  • Fig. 2c represents the Bregenz floating stage.
  • a large number of speakers 231, 232, 233, 23N are installed.
  • the FoH comprises a mixing console 241, a directional mixer (RIM) 242, configuration tools (Config) 243, etc.
  • RIM directional mixer
  • Config configuration tools
  • UI.FM is a new user-interface framework (user-interface framework).
  • Fig. 2d shows an embodiment in which the new solution is implemented. Again, a stage 260, a FoH 270, and a viewer area 280 are shown. In the example of FIG. 2d, however, a UI.FM server 275 is now installed. The UI.FM Server 275 is connected to the components in the system. You can see three different devices, namely an iPad® 282, 283 and an iPhone® 281 twice. The devices could also be any other suitable devices.
  • three sound engineers 284, 285, 286 can simultaneously move to different positions of the grandstand, with each of the sound engineers 284, 285, 286 now being able to position, configure and / or adjust the sound.
  • the changes are made in each case via the respective mobile terminal 281, 282, 283.
  • the mobile terminal 281, 282, 283 is connected to the UI.FM server 275, for example via WLAN.
  • the end information is set in the UI.FM server 275, and then controls the components correspondingly (not shown in Fig. 2d) in the studio room.
  • config, rim, and mixer may be the components that are being controlled. Changes made by a sound engineer 286 on a terminal 283 are immediately forwarded to the other terminals 281, 282.
  • the other terminals 281, 282 are updated accordingly.
  • the other participants eg in Fig. 2d: the other sound engineers
  • the other participants eg in Fig. 2d: the other sound engineers
  • the other participants eg in Fig. 2d: the other sound engineers
  • person 285 in position B can react immediately, adjust something else, and make changes again.
  • FIG. 2d thus represents a significant simplification and improvement in comparison to the procedure explained with reference to FIG. 2c.
  • FIG. 2e Another application scenario, namely the establishment of a sound system in the car is shown in Fig. 2e.
  • a vehicle here, e.g. a car 255, with four seats 261, 262, 263, 264 in it.
  • a sound system with numerous loudspeakers 265 is installed accordingly. It is now desirable that for each seat 261, 262, 263, 264 an optimal sound is generated.
  • a UI.FM server 276 is used, to which the iPads® 266, 267, 268, 269 are connected via Wifi. Any changes a user 256 makes to device 266 are transferred from device 266 to UI.FM server 276, and UI.FM server 276 relays the changes to the other devices 267, 268, 269. All this happens with little delay.
  • 2f shows a further embodiment according to an embodiment in which the audio laboratory of the Fraunhofer Institute for Digital Media Technology in Ilmenau is shown. There is a lot of server technology available to collaborate with each other. Among other things, FIG. 2f shows a renderer 291, furthermore a light controller 292, an amplifier 293, and 294 an audio matrix. On the left in Fig.
  • a number of terminals are shown, such as a PC workstation 295, a first i-Pad® (iPad® 1) 296, a second iPad® 2 (iPad® 2) 297, and eg a terminal 298 from a guest.
  • a guest may also carry his mobile phone 298 with him, which is to collaborate with the other devices 291, 292, 293, 294, 295, 296, 297.
  • the linking of the devices 295, 296, 297, 298 in Fig. 2f left with the hardware 291, 292, 293, 294 in Fig. 2f right is realized by a UI.FM server 290.
  • the UI.FM server 290 is connected on the one hand to the hardware 291, 292, 293, 294 in FIG. 2f on the right.
  • level data and control data are exchanged.
  • the further hardware 292, 293, 294 in Fig. 2f right connected to the UI.FM server 290.
  • the terminals 295, 296, 297, 298 in FIG. 2f are also connected on the left to the UI.FM server 290.
  • the UI.FM server may be implemented as a web server 215, as shown in FIG. 2g, and the clients, such as iPads® 216, 217, may implement web clients 226, 227.
  • the web server 215 delivers the software to the clients 216, 217 when the clients 216, 217 are logged on.
  • UI.FM Another advantage of UI.FM is that the system works in low delay. Control parameters set in one of the clients 216, for example, realized as web client 226, are immediately transferred to the UI.FM server 215. The UI.FM server 215 then transmits the control data directly to the one or more further clients, eg to another iPad® 217. On the (one or more) further clients 217 there is also a respective web client 227. The respective further web client 227 on the corresponding further terminals 217 then immediately updates the relevant parameter. At the same time, the UI.FM server 215 informs the attached peripherals, such as a renderer 229, about the parameter update. In one embodiment, the client may be configured to run in a web browser.
  • the application developer can open a command line (reference numeral 228 in Figure 2g) in which he can directly enter commands directly.
  • a command line reference numeral 228 in Figure 2g
  • the system is therefore very well scriptable.
  • the client may be configured to transmit to the server the ID of two or more of the nodes of the client's data model.
  • a workstation PC is shown 350 on the one hand.
  • Fig. 3 shows a mobile iPad® 360.
  • Fig. 3 shows a renderer 380 and an audio matrix unit 390, e.g. a DHD® audio matrix unit.
  • FIG. 3 shows a UI.FM server 300.
  • the renderer 380 may include submodules, eg, a Spatial Sound Wave 381 submodule. Further, for example, the renderer 380 may hold a scene, such as a scene unit 382. Further, the renderer 380 may include, for example, a speaker setup unit 383 for configuring a speaker setup. Further submodules may be present. For example, a Wav Player 384 may be present. Likewise, the audio matrix unit 390 may have sub-modules. For example, the DHD® audio matrix unit 390 may include, for example, a crosspoint matrix in a crosspoint matrix submodule 391.
  • the UI.FM server 300 is set up to render the real world, such as the renderer 380 and / or the DHD® audio matrix 390, into a graph-shaped, For example, to map a tree-shaped data model 310.
  • the data model 310 is shown on the right.
  • a root node is shown.
  • the DHD ⁇ audio matrix (“DHD®") and the renderer.
  • the node DHD® in the data model 310 which represents the DHD® audio matrix 390, has a node "crosspoint matrix” below it, this representation of the crosspoint matrix 391, in turn, having nodes, for example, x 0 , Xi, and x 2.
  • the representation of the renderer 380 in the data model 310 in turn, has the nodes "Speaker Setup", “Wav Player” and "Scene” as subsequent nodes that represent the real submodules of the renderer 380.
  • the scene in turn has sources, eg srcO, srd and src2.
  • the data model 310 represents a particularly advantageously designed memory.
  • the renderer 380 receives this information and also correspondingly changes the position of the corresponding source, e.g. srcO, srd or src2.
  • controller control unit
  • the controller 320 has a corresponding function for setting the value of the property and a corresponding function for reading out the value of the property.
  • the controller 320 provides a setPosmitted function for setting the value of the pos property, and a Poscutaneous function for reading the value of the pos property.
  • the setPost function specifies the current position to which the position should be set, eg (1, 2, 3).
  • Calling the function setPos defined in the controller 320 changes the position pos in the data model.
  • the term "value” is to be understood broadly and includes eg numerical values, string values, ie values that represent words or sentences, tuples of numerical values, such as (1, 2, 3) or eg tuples of string values, eg ("hello world", "code”), and any other types of value types.
  • a message is sent to a device, such as the renderer 380 or the DHD® audio matrix 390, wirelessly or by wire, which notifies the device that an attribute of one of the nodes of the data model 310 has changed.
  • a renderer driver 330 which represents a view, that is, a view of the data model 310 and / or their attributes, or a view of the controller structure 320 represents.
  • the periphery e.g. the renderer
  • the renderer driver 330 of the UI.FM server 300 may register with the node srcO of the controller 320 of the UI.FM server 300 as a view.
  • the renderer driver thereby becomes a view to the srcO node of the controller 320.
  • the renderer driver 330 Upon such notification, the renderer driver 330 then loads the property pos of the srcO (ie, location of the srcO source) that has been updated from the data model 310. However, the property may also be passed to the renderer driver 330 in the subset - direction. This eliminates access to the data model.
  • the property pos of the srcO ie, location of the srcO source
  • the renderer driver 330 generates a log message and sends this log message to the renderer 380.
  • the log message may be an Open Sound Control (OSC) control message.
  • OSC Open Sound Control
  • the UI.FM server 300 may include additional drivers that are also registered to the source srcO of the controller 320, but these other or alternative views behave differently exhibit. Again, for example, changing the pos property of the srcO (that is, the srcO position) changes the data model and notifies all connected (ie appropriately registered) drivers. The connected drivers generate corresponding protocol messages, which are transmitted to the corresponding hardware peripherals. In the hardware periphery then appropriate changes are made.
  • the reverse way of data transmission and updating is also possible: For example, a process, e.g. in renderer 380, the position e.g. change the srcO.
  • the renderer 380 sends a log message to the corresponding renderer driver 330.
  • the renderer driver 330 is notified by such a message that the corresponding position changed, calling the setPosmitted function of the srcO of the controller 320, and the value of the pos property of the srcO in the data model 310 is then changed.
  • the renderer driver 330 of the UI.FM server 300 may specify that he is aware of a change in the position of srcO, eg a change he himself has made, does not want to be informed.
  • additional drivers e.g. a renderer driver e.g. for the DHD® Audio Matrix Unit 390.
  • Hierarchy 320 which also has a tree structure analogous thereto. This tree structure of the controller 320 then looks the same as the tree structure of the data model hierarchy 310.
  • the data model hierarchy 310 of the UI.FM server 300 may be user-defined.
  • the data model hierarchy 310 of the UI.FM server 300 may be completely defined by the user.
  • the controller hierarchy 320 may be generated, or vice versa, the data model hierarchy 310 may also be generated from the controller hierarchy 320.
  • the controller hierarchy 320 is defined and the data model hierarchy 310 derived therefrom.
  • a particular feature of the UI.FM server 300 is that two parallel hierarchies, namely the controller hierarchy 320 and the data model hierarchy 310, exist side by side and are linked together.
  • each node in the controller hierarchy 320 has a corresponding reference to the corresponding node in the data model hierarchy 310.
  • a reference may exist between the root node of the controller hierarchy 320 and the root node of the data model hierarchy 310.
  • connection between the control devices and the UI.FM server 300 or between the control devices and the controller hierarchy 320 or the data model hierarchy 310 of the UI.FM server 300 is described below.
  • the data model 310 is organized in a database. Further, in the prior art, the client sends queries to the database, retrieves responses from the database, and can work with the data received. Further, according to the prior art, the client registers on nodes of the data model 310 and gets messages when the node of the data model changes.
  • the data model itself may for example be stored in a database.
  • the organization of the data model 310 and the handling of how the data model 310 is to be updated for example, is completely left to the application developer in the prior art. According to one embodiment, a mechanism is provided that relieves the user of a great deal of work. This mechanism is explained below.
  • the client When starting a client, e.g. of the workstation PC 350, the client logs on to the UI.FM server 300 (see item (1) between workstation PC 350 and UI.FM server 300 in FIG. 3). First of all, the client logs on to the UI.FM Server 300.
  • the UI.FM server 300 then transmits the controller hierarchy 320 to the client (see item (2) between workstation PC 350 and UI.FM server 300 in FIG. 3). With the controller hierarchy 320, the data model hierarchy 310 is also transmitted. This can be implicitly done by, for example, deriving the data model hierarchy 310 from the controller hierarchy 320 or, alternatively, the data model hierarchy 310 being explicitly transmitted adjacent to the controller hierarchy 320.
  • the same hierarchy exists on the client as on the UI.FM server 300. That at the client, e.g. the workstation PC 350 has the controller hierarchy 352 and the data model 351.
  • controller hierarchy 320 and data model hierarchy 310 may also be performed for other clients, such as, e.g. in addition to the workstation PC 350, also for e.g. an iPad® 360 when logging in to the UI.FM Server 300.
  • the iPad® 360 in FIG. 3 has a controller hierarchy 362 and a data model 361, as does the workstation PC in FIG. 3.
  • the controller hierarchy 352 of the workstation PC 350 has a "root” and, moreover, identical to the controller hierarchy of the UI.FM server 300, the nodes downstream of the root "root”, e.g. including srcO and its subordinate nodes.
  • the data model in the clients e.g. for the data model of the workstation PC 350 and for the data model of the iPads® 360.
  • Also in their controller hierarchies 352, 362 are, for example, the source srcO.
  • the same data model structure 351, 361 is initially set up as in the UI.FM server. This applies, for example, to the controller hierarchy 362 and the data model 361 of the iPads® 360 Controller hierarchies 352, 362 and data models 351, 361 of the clients 350, 360 with the data model 310, and the controller 320 hierarchy of the UI.FM server 300 matched.
  • controller hierarchy 320 and data model 310 has to be transferred from server 300 to client 350, but also the actual data, for example, e.g. which values the attributes in the data model have in each case (for example, which value (s) has the position pos of the sources srcO, srd, src2, etc.
  • each node of the controller hierarchy 320 of the UI.FM server 300 is assigned an ID.
  • the ID is used to quickly address nodes.
  • each node has a short "phone number” that can be used instead of specifying a long path, for example, in the controller hierarchy 320 of the UI.FM server 300, the node " root "the ID 0, the node” DHD® "has the ID 1, the node” renderer "has the ID 2, the node” LSSetups "has the ID 3, the node” WavPl.
  • the IDs are transferred from UI.FM server 300 to client 350 (see item (4) between workstation PC 350 and UI.FM server 300 in FIG. 3) and into the data model 351 and into the controller hierarchy 352 of the client 350, for example, in the data model 351 and in the controller hierarchy 352 of the workstation PC clients 350.
  • I D transfer That is, an I D tree is generated that has the same structure as the controller hierarchy. The difference is that the IDs are located in the individual nodes. The IDs are then written to the appropriate nodes.
  • items (2), (3), and (4) may be executed at initialization of the client 350 at the UI.FM server 300 in any order.
  • a (sound) source is repositioned by means of a workstation PC 350.
  • a web application running on a workstation PC 350 will be used to determine the spatial position of a, e.g. to re-position virtual, (sound) -Quelie.
  • the three audio signals are then mixed according to the virtual position of the sound source. If, for example, the virtual position of a first sound source is far away from the assumed listener position, then the proportion of its audio signal in the overall signal is generally less than the proportion of the audio signal of a second sound source whose virtual position is close to the assumed listener position located. Or, but it will be from the e.g. three audio signals of the three sources generates a plurality of loudspeaker signals.
  • the proportion of its audio signal in the loudspeaker signal for this loudspeaker is generally lower than the proportion of the audio signal of a second sound source whose virtual position is located near the (assumed) speaker position.
  • the (virtual) positions of the (sound) sources can be set, which can be controlled from the workstation PC 350 as the renderer 380, the individual audio signals of the sources to one Whole signal, or mixes to a plurality of individual speaker signals.
  • a view (view) 353 is set up at the client (eg the workstation PC 350).
  • the workstation PC 350 includes this View 353.
  • a source 358 is shown in the view 353 of the workstation PC 350 in FIG. 3.
  • the source 358 is displayed eg by a touch screen, can be touched with the finger and moved eg by pulling. When this movement happens, for example, an event is triggered.
  • the controller 352 of the client 350 comprises an update mechanism which has already been discussed analogously in connection with the UI.FM server 300.
  • the workstation PC 350 also has a view 353.
  • the setPost function which is called when the source is moved, sets a position in the data model of the workstation PC.
  • the position change of the source in the data model 351 of the workstation PC 350 is subsequently transmitted to the UI.FM server 300.
  • the ID described above is used.
  • a unit of the controller of the PC 350 responsible for the srcO informs a synchronizer (synchronizer) 354 of the workstation PC 350.
  • the synchronizer 354 can be thought of as a kind of view, which is informed when data changes.
  • the synchronizer 354 uses the corresponding ID and generates a message, for example, that the position has changed in the node with the ID 7, and what the value of the corresponding position is (e.g., (8, 9, 10)).
  • This update message generated by synchronizer 354, e.g. a message "7: Pos: (8, 9, 10)" is transmitted to the UI.FM Server 300.
  • a synchronizer 340 on the UI.FM server 300 which receives the new position of the srcO conveyed by the update message.
  • the Synchronizer 340 of the UI. FM Server 300 transmits the received position to the node with the corresponding ID, ie here, e.g. the node with the ID 7.
  • the synchronizer 340 of the UI.FM server 300 uses the ID to determine the corresponding node of the controller 320.
  • the synchronizer 340 determines, for example, that the node with the ID 7 is the node srcO, and calls the setPos extended function of the srcO controller node.
  • the setPost function enters the position in the data model 310 of the UI.FM server 300, and also notifies the renderer driver 330 of the new location.
  • the renderer driver 330 passes the new position to the renderer 330.
  • the message from the workstation PC 350 is forwarded by synchronizer 340 with minimal delay to all other clients, e.g.
  • the iPad® 360 has the same controller hierarchy 362 and data structure 361 with the same IDs as the UI.FM Server 300.
  • the iPad® 360 also includes a synchronizer 364.
  • the synchronizer 364 of the iPads® 360 carries enter this ID into its data model 361 as well. If the iPad® has views (in Fig. 3, for example, the view 363), the controller 362 transmits the information from the synchronizer 364 about the changed position not only to the data model
  • a user can also move a source on the iPad® 360 analogously to the above description.
  • the information would be written analogously via the setPospar function of the controller 362 of the iPads® 360.
  • the controller
  • the controller 362 of the iPads® 360 would update the data model 361 of the iPads® 360. Further, the controller 362 of the iPads® 360 would inform the synchronizer 364 of the iPads® 360. The synchronizer 364 of the iPads® 360 would transmit this information in an update message to the synchronizer 340 of the UI.FM server 360. The synchronizer 364 of the UI.FM server 360 would forward the information contained in the update message directly to synchronizers of other clients, eg to the synchronizer 354 of the workstation PC 350. Further, the synchronizer 340 of the UI.FM server 300 would also include this information in the controller 320 of the server 300.
  • the controller 320 of the UI.FM server 300 would update the location of srcO in the data model 310 of the server 300. Further, the controller 320 of the server 300 would notify the corresponding driver of the server of the change in position. This driver, in this case, the renderer driver 330, would inform the renderer 380 accordingly.
  • the code that implements the functionality described above is capable of running in the web browser. In one embodiment, for example, you can call the server side via the browser, eg via a URL.
  • the code for the workstation PC 350 is transmitted live and is then immediately executed on the workstation PC 350. This eliminates complex installation processes.
  • Embodiments provide means for dynamic code generation, e.g. the dynamic generation of executable code.
  • the system is web-based, and functions can be used to generate other functions. These other functions that have been embarrassed are then executable. This means that the user only has to define the controller hierarchy minimally, and all other code for synchronizing to assign IDs etc. can be automatically generated.
  • the system is adapted to automatically generate two functions from this information, e.g.
  • embodiments of the above two functions are automatically generated for each of the clients, eg in the workstation PC 350, by the clients adopt the controller hierarchy.
  • a controller eg such a controller unit of the node srcO
  • embodiments of the invention enable, on the one hand, intuitive access and, on the other hand, access to nodes of the data structure that is simultaneously fast.
  • embodiments combine both the property of intuitiveness and the property of speed, whereas conventional systems are usually either intuitive or fast, but not both.
  • the intuitiveness of the data structure is especially important for the application developer. If the application developer wants to put information in the data model, then it must be quite simply provided a way, such as e.g. to the information of the source srcO approaches.
  • the system generates a command set for this, with which individual nodes can be easily addressed in the browser. For example, you can open a command line in the browser. In this command line, the user or application developer can enter: "root.Renderer.Scene.src0.setXyz (8, 9, 10)". Such a line is highly intuitive if one knows the corresponding structure of the graph-shaped data structure. So you can very easily, i. intuitive, access information of the data structure, load information, update information. With all this, the documentation effort is very low, because the data structure already results from their hierarchical tree-shaped structure.
  • commands that are e.g. in JavaScript allows the point operators between nodes to be generated.
  • the browser or server command line generates these dot operators.
  • the controller structure is designed such that these operators can be easily used.
  • a path to a desired node is thus specified by, for example, starting from the root node or starting from one of its successor nodes, the successive nodes are indicated successively to the desired node, wherein successive nodes are each separated by a point.
  • the node srcO can be accessed, for example, by specifying the path "root.Renderer.Scene.srcO" or, for example, by specifying the path "Rendeer.Scene.srcO" (if, for example, it is clear that the root node is "root”). always the first node).
  • the renderer 380 may be configured to generate level data that is appropriately communicated via OSC messages to the renderer driver 330 of the UI.FM server 300.
  • the renderer driver 330 sets the level data accordingly in the controller hierarchy 320 and thus in the data model 310.
  • this is 64 information, e.g. Updated 50 times a second, i. Every second, 3,200 updates are needed in this example.
  • other high-frequency information can regularly arise that needs to be processed.
  • a path of the form "root.Renderer.Scene.src0.posXyz (8, 9, 10)" would then have to be addressed each time.
  • Such a command would then be sent each time in a message from the client, e.g. the workstation PC 350 to be sent to the UI.FM Server 300.
  • this is inefficient.
  • the IDs already introduced above are used. Since each node has an ID representing a kind of hash value, with the ID acting as a short address, the ID may be used as an alternative to the long path that is good for the human developer.
  • An example would be e.g. the command "node [7] .setXyz (8, 9, 10)" This calls the function "setXyz specified" of the node with the ID7, that is the setXyz defined function of the node srcO ,
  • the ability to address items very briefly may be beneficial when certain information changes frequently, and is useful in synchronization, for example.
  • moving source 358 entails many position updates.
  • it is not the long path from the client to the server that is transmitted, but the ID.
  • data messages of the form "7: pos: [8, 9, 10]” one has very short data messages, which are then very efficiently transferable to the UI.FM server 300 and all clients, eg the iPad® 360 long path has the advantage that it is intuitive, especially for the human developer, while the short path, eg "7: pos: [8, 9, 10]", has the advantage of being very well processable for the system.
  • Data transfer using the ID very quickly.
  • Embodiments combine both advantages by providing both the long path and the short ID addressing.
  • both addressing possibilities are automatically generated by the system when the controller hierarchy and / or the data structure is defined.
  • Multi-client capability means launching the same application on multiple clients.
  • the same application can be started on the workstation PC 350, on the iPad® 360, and on other devices, for example. Any change made on a client, e.g. the workstation PC 350 is transferred to all other clients 360. In other words, the application is simultaneously present on several screens and also visible at the same time.
  • a part of the application can be displayed on a first client, eg the workstation PC 350, while other parts of the application can be displayed on a second client, eg an iPad® 360.
  • a source on the iPad® 360 can be muted with the left hand, while a sound source is positioned on the workstation PC 350 with the right hand.
  • Such functionality may be referred to as multi-device capability.
  • a web-based implementation according to embodiments is advantageous. Another important feature of embodiments is their ability to execute requests with a delay.
  • a source 358 is moved in a browser of a client, eg workstation PC 350, then this source movement will be transferred to the other clients, eg the iPad® 360, with almost no time delay, and will be visible there almost without time delay.
  • level data which comes from the Render 380, for example. It turns out that the system is so fast that it can handle very high-frequency parameter changes.
  • the controller 320 has various tasks, one task being to change the data model 310, where a further object is to provide the drivers, e.g. the renderer driver 330, to further initiate synchronization by the synchronizer 340.
  • a further object is to provide the drivers, e.g. the renderer driver 330, to further initiate synchronization by the synchronizer 340.
  • controller 320 implemented in UI.FM 300 has yet another capability, namely the ability to record data changes over time. That when moving a source 358, this change may be recorded by controller 320 and rendered later. This can e.g. used to record source movements. Accordingly, these recorded source movements can later be played back or played back. This can be characterized as automatability.
  • Embodiments have the property of automatic code generation, that is to say that the read and write functions for the corresponding access node attributes are automatically generated. This is called dynamic code generation.
  • the synchronizer code may also be automatically generated. Not only the access routines, ie the read and write functions, but also the synchronization functions can be generated automatically.
  • embodiments have the property that the code which notifies the views 363 can be automatically generated from the controller definition and / or from the definition of the data structure.
  • the public address technology of a stadium will be set up.
  • four persons may be involved in setting up the PA technology, eg four sound engineers.
  • each of the sound engineers may be responsible for one wing of the stadium, such as one for the north wing, one for the south wing, one for the east wing, and one for the west wing.
  • Each of the sound engineers also has an iPad®, for example. With this iPad®, the central mixing console and the central sound device can be controlled. A first person then starts optimally adjusting the sound for his position.
  • UI.FM is provided, which can be implemented eg as a software framework.
  • UI.FM refers to the so-called user interface framework. This framework allows such applications to be implemented much faster and easier than previously possible.
  • All applications developed by UI.FM are inherently multi-client capable.
  • FIG. 4 a an application that is loaded on an iPad® 410 is shown.
  • the application is still loaded onto a workstation PC 420.
  • the application is still loaded on another client, another workstation PC 430.
  • the application is now present on three different clients 410, 420, 430.
  • one of the eight sources 41 1, 412, 413, 414, 415, 416, 417, 418 can be touched and moved on this iPad®, for example.
  • the touching and moving of one of the sources, eg with a finger 419, is shown for example in FIG. 4c.
  • the source moves in all other clients 420, 430.
  • the source 416 can also be moved with a mouse or by its mouse pointer.
  • the source can be moved with one mouse on one PC and the corresponding source on the other clients, eg on another iPad®, moves accordingly. This means that several people can work with one application at the same time, and change the parameters there, with the changed parameters being transmitted to the other terminals.
  • Embodiments have the ability to distribute applications to multiple terminals to extend a workstation. For example, e.g. in Fig. 4d on the one hand the workstation PC 420 to see in the background, on which the eight different sources 41 1, 412, 413, 414, 415, 416, 417, 418 are shown.
  • the workspace has been expanded to include the iPad® 410 in the foreground. Both devices 410, 420 are separated. Both devices 410, 420 are running different client applications.
  • On the PC workstation 420 is a Source Positioning Canvas, by means of which one can move the sources 41 1, 412, 413, 414, 415, 416, 417, 418.
  • On the iPad® 410 is a Mute Matrix, which mutes any or all of the sources 41 1, 412, 413, 414, 415, 416, 417, 418.
  • the Positioning Canvas and the Mute Matrix can be controlled simultaneously with two hands.
  • one or more sources are muted with the left hand, as seen in Figure 4e, while the right hand can be used to control and position sources.
  • one has a PC workstation 420 extended to a second application running on a mobile terminal 410, and both work together perfectly for a single user.
  • UI.FM is web-based.
  • Figure 5a shows the server side of UI.FM according to one embodiment.
  • the application "ProductionApp” running on the UI.FM server can be clicked to open the "ProductionApp” as shown in Fig. 5c. Now you can work with this application ("app" application).
  • UI.FM runs with little delay. Everything that is done in one application on one client is transferred as quickly as possible to the corresponding application on the other client. This allows real-time data to be displayed in the web browser.
  • up to 32 sources can be displayed and controlled. The levels of these up to 32 sources are updated at 25 frames per second. Likewise, the up to 32 source positions are updated, and in no time.
  • the change of an attribute of one of the nodes of the data model may be recorded.
  • all parameters can be automated in UI.FM.
  • Fig. 6b a scenario is shown where one can start a recording, move a source, stop recording, and then start recording so that the swelling movement that was previously performed is now played. Embodiments thus enable the recording of parameters.
  • the application developer may use a graphene-like, e.g. define a tree-shaped data model, as e.g. is shown in Fig. 7a.
  • Fig. 7a an example data model of an example application is shown.
  • the root node is not designated as "root” but as "ssc" in Fig.
  • the node “audio” contains several subnodes, eg the subnode “scenes”
  • the node “scenes” contains the subnode “sceneO”
  • the subnode “sceneO” in turn contains the subnodes “soloManager”, “manage3d” and “sources” the node “sources” contains the source “srcO”
  • the subnodes “micSetups”, “IsSetups” and “virtualLsSetups” so that the data that occurs in the system becomes graph-shaped, eg tree - structured.
  • Figures 7b and 7c show an example of how a data model is formulated quite concretely. Specifically, it is the definition of a source. Here you define first the attributes of the object, in a source eg the position, the rotation, if it is needed (isUsed), if the source is selected (isSelected), if the source is locked (isLocked), whether the source is muted (isMuted), or, for example, whether the source is a 3D source, and so on.
  • a source eg the position, the rotation, if it is needed (isUsed), if the source is selected (isSelected), if the source is locked (isLocked), whether the source is muted (isMuted), or, for example, whether the source is a 3D source, and so on.
  • Each of these attributes is assigned a default value.
  • the default value is also used to determine the data type of the attribute.
  • automate all attributes except automate all attributes except for).
  • timeline should look like for automation (timeline configuration), and how closely adjacent markup points (keyframes) should be. Furthermore, for example, spatial notifications, as well as direction changes should be specified. Optimization of the data logging / automation described above is achieved. Furthermore, it can also be described that not all attributes are stored directly in a file, but only certain. So there are very different combination options.
  • a new controller subunit for a new node can be created by calling NewControllerClass in the data model. This call is passed the name, attributes, childCreationFunction, and options. This will define the new node.
  • the individual nodes are still in a graphiform, e.g. to bring tree-shaped hierarchy.
  • the tree-shaped hierarchy has already been graphically represented in FIG. 7a.
  • the source source source is in a sources container, which in turn resides in a sceneO container, which in turn resides in a scenes container.
  • FIGS. 7d, 7e, 7f For the design of the data model sketched in FIG. 7a, there are various programming commands, which are illustrated in FIGS. 7d, 7e, 7f.
  • the nodes are to be defined, the attributes of the nodes are to be defined, and the nodes are to be assigned to a parent node via predefined commands.
  • UI.FM is able to derive a number of useful tools from the graph-type, for example, tree-shaped data structure, and For example, automatically generate.
  • These software tools such as software development tools, are described below.
  • a first tool implements the automatic generation of programming commands for reaching nodes in the data model.
  • UI.FM automatically generates programming commands from the previously defined tree hierarchy.
  • 8a shows an example in which a JavaScript console 810 is opened.
  • a JavaScript console 810 is e.g. in browsers like Chrome® and Firefox®. This console is used to access the data model loaded in the browser.
  • Fig. 8e shows the command to shift the source to position [-100, -100, 0]. If the command is issued by pressing Enter, the source is automatically shifted, as shown in Fig. 8f. This is due, for example, to the fact that an event (message) was generated within the automatically generated setXyz function. The source representation subscribed to this message and could then change its position. The application developer can thus easily, intuitively access the components, ie the nodes of the data model. In addition to the setXyzQ function, there is also a function for reading that is automatically generated. This function is shown in Fig. 8f and designated by "xyzQ".
  • the UI.FM Server 300 can be restarted with a server command line. After restarting the server 300, the two applications 910, 920 are restarted.
  • FIG. 9e shows that this newly inserted attribute "uifm” can now be queried in both applications 910, 920 via the automatically generated command “uifm ()” and supplies the data string "uifm” as the return value. This works both in the client and in the server.
  • UI.FM thus allows a quick and easy extension of the data model and allows the quick and easy generation of synchronization code.
  • UI.FM automatically generates code that allows connected observers to be alerted when a value of the data model changes (see, for example, Publisher-Observer, a design pattern). It does not mean a human observer, but a program module that subscribes to a change message and automatically receives it as soon as the data model changes.
  • a change monitor is set up. For example, an alarm is issued when a value of one of the attributes for which change monitoring is set changes.
  • the output of an alarm is just one example. Another possibility is, e.g. that the title bar of the browser is updated or similar.
  • Fig. 10d the opening of a second client is shown.
  • the value of uifm is changed in a console by the function "setUifm".
  • the first client also issues the alarm that the value of uifm has changed to "overhead,” as shown in Figure 10e.
  • the new value of uifm was transferred from the second client to the server, the value was transferred from the server to the first client, the value of uifm was updated accordingly and the observer was informed what to do to output the alarm, as shown in FIG 10e.
  • UI.FM it is also very easy to record timeline data.
  • the uifm attribute has been added to the data model.
  • code is also automatically generated to record timeline data. For example, various changes in the value uifm over time can be recorded. Pressing on e.g. a play button, can make sure that time runs out. If you now set the value of uifm first to "Friday”, then to "Saturday”, then to "Sunday", these data changes are recorded in chronological order over time.
  • the read mode / playback mode is activated, the previously recorded data is again written to the data model via the write function from the timeline. Connected observers (views) are informed and, for example, automatically output alarms (in English: "alerts"), at the time in the playback in which the value was changed during the recording mode. 1 1, the alarm "Sunday” is outputted at the time the recording is repeated also changing the value of "Sunday.”
  • alarms in English: "alerts”
  • embodiments allow recordings of inputs that are timely reproduced as they are played back by the system, and for example timely output alarms according to the recording.
  • aspects have been described in the context of a device, it will be understood that these aspects also constitute a description of the corresponding method, so that a block or a component of a device is also to be understood as a corresponding method step or as a feature of a method step. Similarly, aspects described in connection with or as a method step also represent a description of a corresponding block or detail or feature of a corresponding device.
  • Some or all of the method steps may be performed by a hardware device (or using a Hardware apparatus), such as a microprocessor, a programmable computer or an electronic circuit. At some According to embodiments, some or more of the most important method steps may be performed by such an apparatus.
  • embodiments of the invention may be implemented in hardware or in software.
  • the implementation may be performed using a digital storage medium such as a floppy disk, a DVD, a BluRay disc, a CD, a ROM, a PROM, an EPROM, an EEPROM or FLASH memory, a hard disk, or other magnetic or optical Memory are stored on the electronically readable control signals are stored, which can cooperate with a programmable computer system or cooperate such that the respective method is performed. Therefore, the digital storage medium can be computer readable.
  • some embodiments according to the invention include a data carrier having electronically readable control signals capable of interacting with a programmable computer system such that one of the methods described herein is performed.
  • embodiments of the present invention may be implemented as a computer program product having a program code, wherein the program code is operable to perform one of the methods when the computer program product runs on a computer.
  • the program code can also be stored, for example, on a machine-readable carrier.
  • an embodiment of the method according to the invention is thus a computer program which has a program code for performing one of the methods described herein when the computer program runs on a computer.
  • a further embodiment of the method according to the invention is thus a data medium (or a digital storage medium or a computer-readable medium) on which the computer program is recorded for performing one of the methods described herein.
  • a further embodiment of the method according to the invention is thus a data stream or a sequence of signals, which represent the computer program for performing one of the methods described herein.
  • the data stream or the sequence of signals may be configured, for example, to be transferred via a data communication connection, for example via the Internet.
  • Another embodiment includes a processing device, such as a computer or programmable logic device, configured or adapted to perform any of the methods described herein.
  • a processing device such as a computer or programmable logic device, configured or adapted to perform any of the methods described herein.
  • Another embodiment includes a computer on which the computer program is installed to perform one of the methods described herein.
  • Another embodiment according to the invention comprises a device or system adapted to transmit a computer program for performing at least one of the methods described herein to a receiver.
  • the transmission can be done for example electronically or optically.
  • the receiver may be, for example, a computer, a mobile device, a storage device or a similar device.
  • the device or system may include a file server for transmitting the computer program to the recipient.
  • a programmable logic device eg, a field programmable gate array, an FPGA
  • a field programmable gate array may cooperate with a microprocessor to perform one of the methods described herein.
  • the methods are performed by any hardware device. This may be a universal hardware such as a computer processor (CPU) or hardware specific to the process, such as an ASIC.

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Databases & Information Systems (AREA)
  • Data Mining & Analysis (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Computing Systems (AREA)
  • Software Systems (AREA)
  • Information Retrieval, Db Structures And Fs Structures Therefor (AREA)

Abstract

Eine Vorrichtung wird bereitgestellt. Die Vorrichtung umfasst ein Datenmodell (110), wobei das Datenmodell (110) drei oder mehr Knoten umfasst, wobei einem oder mehr der drei oder mehr Knoten des Datenmodells (110) eine ID zugewiesen ist, wobei jeder dieser ein oder mehr Knoten durch seine ID von den anderen Knoten des Datenmodells (110) eindeutig unterscheidbar ist, wobei wenigstens zwei der Knoten des Datenmodells (110) jeweils ein oder mehrere Attribute aufweisen, wobei jedes der besagten Attribute einen Wert annehmen kann, der in dem Datenmodell (110) gespeichert ist, wobei jedem Knoten der besagten wenigstens zwei Knoten eine Pfadangabe zugewiesen ist, wobei die Pfadangabe den jeweiligen Knoten, dem diese Pfadangabe zugewiesen ist, und wenigstens einen weiteren der drei oder mehr Knoten des Datenmodells (110) aufweist, und wobei sich die Pfadangabe von jedem Knoten der besagten wenigstens zwei Knoten von der ID des jeweiligen Knotens unterscheidet. Des Weiteren umfasst die Vorrichtung einen Controller, der zu jedem Attribut von jedem der drei oder mehr Knoten des Datenmodells (110), der Attribute aufweist, eine Schreibfunktion umfasst, und wobei der Wert des Attributs mittels der Schreibfunktion änderbar ist. Ferner umfasst die Vorrichtung einen Synchronizer (130). Der Synchronizer (130) ist dafür eingerichtet, eine Aktualisierungsmitteilung zu empfangen, die einen der Knoten des Datenmodells (110) bezeichnet, wobei die Aktualisierungsmitteilung des Weiteren ein Attribut dieses Knotens bezeichnet, und wobei die Aktualisierungsmitteilung angibt, wie der Wert dieses Attributs zu aktualisieren ist, wobei die Aktualisierungsmitteilung den Knoten mittels der ID des Knotens bezeichnet. Der Controller (120) ist dafür eingerichtet, den Wert dieses Attributs dieses Knotens in Abhängigkeit von der Aktualisierungsmitteilung mittels der Schreibfunktion dieses Attributs zu aktualisieren.

Description

Vorrichtung, System und Verfahren
zur effizienten und verzögerungsarmen Synchronisation
graphenförmiger Datenstrukturen Beschreibung
Die Anmeldung betrifft die verzögerungsarme Synchronisation, und, im Speziellen, eine Vorrichtung, ein System und ein Verfahren zur effizienten verzögerungsarmen Synchroni- sation graphenförmiger, z.B. baumförmiger Datenstrukturen.
Eine große Anzahl von Software-Applikationen verwendet intern eine graphenförmige, z.B. baumförmig organisierte Datenstruktur. Eine solche baumförmig organisierte Datenstruktur ist Dabei kann der Zustand der Applikation in einer solchen Datenstrukturen ge- halten werden. Ändern sich Teile der Datenstruktur, so reagiert die Applikation darauf und ändert z.B. die Bildschirmdarstellung oder steuert ein angeschlossenes Peripheriegerät. Das zugrunde liegende Design-Pattern wird MVC (englisch: Model View Controller = Modell - Präsentation - Steuerung) genannt. Möchte man eine derartige Applikation, deren Zustand in einer solchen graphenförmigen, z.B. baumförmigen Datenstruktur gehalten wird, auf mehreren Geräten gleichzeitig ausführen, z.B. um mehrere Nutzer kollaborativ (gemeinschaftlich/zusammenwirkend) mit der Applikation arbeiten zu lassen, oder möchte ein Nutzer unterschiedliche Darstellungen der Applikation auf verschiedene Endgeräte, z.B. einen TabletPC und ein Mobiltelefon zum Zwecke besserer Bedienbarkeit verteilen, so muss folgendes passieren:
Zum einen müssen aufwändig Kommunikationsprotokolle zur Synchronisation der auf unterschiedlichen Endgeräten gleichzeitig laufenden Applikation geschaffen und implementiert werden. Diese Implementierung ist in der Regel teuer und zeitaufwändig und damit auch fehleranfällig.
Zum anderen müssen diese Protokolle schnell und effizient sein. Zwischen einer Nutzereingabe auf einem ersten Gerät und der Aktualisierung der Applikation auf einem weiteren Gerät darf keine spürbare Verzögerung auftreten. Gerade für die Steuerung von Audio- Systemen darf die Synchronisation nur wenige Millisekunden dauern. Im Stand der Technik sind bereits Vorrichtungen bekannt, mit denen man mit mehreren Mobilgeräten ein System gleichzeitig steuern kann, z.B. Mackie-Control, oder diverse iPad Steuerungen für Mischpulte. Die Kommunikation unterschiedlicher Clients (Klienten, Clientanwendungen) einer Applikation erfolgt derzeit in der Regel mit Hilfe von Datenbanken. Über ein Datenbankprotokoll werden Zustände in einer Datenbank gesetzt, welche wiederum an die unterschiedlichen Clients übertragen werden. Hierbei gibt es zwei Ansätze: Der erste Ansatz ist ein sogenannter Key-Value-Ansatz (Schlüsselwert-Ansatz), siehe z.B. die Redis-Datenbank. Zu einem Schlüssel wird ein Datensatz gespeichert. Über den Schlüssel kann schnell auf den Datensatz zugegriffen werden. Vorteil dieses Ansatzes ist hohe Performanz. Jedoch ist die Entwicklung komplexer Applikationen auf Basis des Key- Value-Ansatzes unüberschaubar, und damit teuer und fehleranfällig.
Der zweite Ansatz ist ein sogenannter dokumentenorientierter Ansatz, siehe z.B. CouchDb, MongoDb. Dabei liegen die Daten graphenförmig strukturiert vor, und können über einen Adress-Pfad (Adressen-Pfad) erreicht werden. Dieser Ansatz ermöglicht gut strukturierte Daten und somit einfach zu handhabende Applikationen. Die Entwicklung von Applikationen (Anwendungen) erfolgt damit schnell und unkompliziert. Nachteil ist, dass Zugriffe auf die Daten teuer sind. Für sich hochfrequent ändernde, niedrig latente Steuerdaten ist ein solcher Ansatz jedoch weniger geeignet.
Wünschenswert wäre es jedoch, wenn Konzepte bereitgestellt würden, die einerseits ho- he Performanz bei der verzögerungsarmen Synchronisation und bei der Datenaktualisierung realisieren, und die andererseits ein hohes Maß an Intuitivität beim Datenzugriff realisieren.
Eine Vorrichtung nach Anspruch 1 , ein Server nach Anspruch 14, ein Client nach An- spruch 21 , ein System nach Anspruch 25, eine Verfahren nach Anspruch 26 und ein Computerprogramm nach Anspruch 27 wird bereitgestellt.
Eine Vorrichtung wird bereitgestellt. Die Vorrichtung umfasst ein Datenmodell wobei das Datenmodell drei oder mehr Knoten umfasst, wobei einem oder mehr der drei oder mehr Knoten des Datenmodells eine ID zugewiesen ist, wobei jeder dieser ein oder mehr Knoten durch seine ID von den anderen Knoten des Datenmodells eindeutig unterscheidbar ist, wobei wenigstens zwei der Knoten des Datenmodells jeweils ein oder mehrere Attribute aufweisen, wobei jedes der besagten Attribute einen Wert annehmen kann, der in dem Datenmodell gespeichert ist, wobei jedem Knoten der besagten wenigstens zwei Knoten eine Pfadangabe zugewiesen ist, wobei die Pfadangabe den jeweiligen Knoten, dem diese Pfadangabe zugewiesen ist, und wenigstens einen weiteren der drei oder mehr Knoten des Datenmodells aufweist, und wobei sich die Pfadangabe von jedem Knoten der besag- ten wenigstens zwei Knoten von der ID des jeweiligen Knotens unterscheidet.
In einer Ausführungsform kann beispielsweise jedem der Knoten des Datenmodells eine ID zugewiesen sein, wobei jeder der Knoten des Datenmodells durch seine ID von den anderen Knoten des Datenmodells eindeutig unterscheidbar ist.
Des Weiteren umfasst die Vorrichtung einen Controller, der zu jedem Attribut von jedem der drei oder mehr Knoten des Datenmodells, der Attribute aufweist, eine Schreibfunktion umfasst, und wobei der Wert des Attributs mittels der Schreibfunktion änderbar ist. Ferner umfasst die Vorrichtung einen Synchronizer. Der Synchronizer ist dafür eingerichtet, eine Aktualisierungsmitteilung zu empfangen, die einen der Knoten des Datenmodells bezeichnet, wobei die Aktualisierungsmitteilung des Weiteren ein Attribut dieses Knotens bezeichnet, und wobei die Aktualisierungsmitteilung angibt, wie der Wert dieses Attributs zu aktualisieren ist, wobei die Aktualisierungsmitteilung den Knoten mittels der ID des Knotens bezeichnet. Der Controller ist dafür eingerichtet, den Wert dieses Attributs dieses Knotens in Abhängigkeit von der Aktualisierungsmitteilung mittels der Schreibfunktion dieses Attributs zu aktualisieren.
In Ausführungsformen übernimmt die Schreibfunktion nicht nur das Setzen des Wertes im Datenmodell, sondern auch das Informieren des Synchronizers und/oder das Informieren weiterer Beobachter sowie weitere mögliche Funktionen wie beispielsweise das Aufzeichnen von Änderungen über die Zeit zum Zwecke der späteren Wiedergabe oder Rückgängigmachung.
Gemäß Ausführungsformen ist der Synchronizer dafür eingerichtet, Aktualisierungsmittei- lungen zu senden.
Ausführungsformen der Erfindung weisen gegenüber dem Stand der Technik zahlreiche Vorteile auf, beispielsweise Deutlich leichtere Erweiterbarkeit des Synchronisations- Protokolls, vollständig webbasierte Umsetzung transparente Synchronisation für den An- Wendungsentwickler und/oder leichte Einbindung neuer Komponenten. Während im Stand der Technik Anbieter lediglich ein Protokoll, nicht jedoch persistente Datenrepräsentation im Clienten und im Server, wird gemäß Ausführungsformen die persistente Datenreprä- sentation definiert und daraus das Protokoll abgeleitet. Ausführungsformen stellen weitere Tools bereit.
Gemäß einer Ausführungsform wird ein Server bereitgestellt. Der Server ist eine Vorrich- tung wie oben beschrieben. Ferner ist der Server dafür eingerichtet, eine Anmeldung von ein oder mehreren Clients entgegenzunehmen. Ferner ist der Server dafür eingerichtet, den ein oder mehreren Clients auf deren Anmeldung hin, Informationen über das Datenmodell zu übertragen, wobei diese Informationen über das Datenmodell die Werte der Attribute von allen Knoten oder von zwei oder mehr der Knoten des Datenmodells umfas- sen, die Attribute aufweisen, und wobei die Informationen über das Datenmodell ferner für jeden Knoten des Datenmodells oder für die wenigstens zwei Knoten des Datenmodells angeben, welche ein oder mehreren der Knoten des Datenmodells diesem Knoten unmittelbar nachfolgen und/oder welche ein oder mehreren Knoten des Datenmodells diesem Knoten unmittelbar vorausgehen.
In einer Ausführungsform kann der Server z.B. dafür eingerichtet sein, den ein oder mehreren Clients auf deren Anmeldung hin, die ID von zwei oder mehreren der Knoten des Datenmodells des Servers zu übertragen. Gemäß einer weiteren Ausführungsform wird ein Client bereitgestellt. Der Server ist eine Vorrichtung wie oben beschrieben. Ferner ist der Client dafür eingerichtet, sich bei dem oben beschriebenen Server anzumelden. Der Client ist dafür eingerichtet, auf die Anmeldung beim Server hin, Informationen über das Datenmodell des Servers zu empfangen, wobei diese Informationen über das Datenmodell des Servers die Werte der Attribute von allen Knoten oder von zwei oder mehr Knoten des Datenmodells des Servers umfassen, die Attribute aufweisen, und wobei die Informationen über das Datenmodell des Servers ferner für jeden Knoten des Datenmodells oder für die zwei oder mehr Knoten des Datenmodells des Servers angeben, welche der Knoten des Datenmodells des Servers diesem Knoten unmittelbar nachfolgen und/oder welche Knoten des Datenmodells des Ser- vers diesem Knoten unmittelbar vorausgehen. Ferner ist der Client dafür eingerichtet, sein Datenmodell abhängig von den Informationen über das Datenmodell des Servers hin zu aktualisieren.
Des Weiteren wird ein System bereitgestellt. Das System umfasst den oben beschriebe- nen Server und den oben beschriebenen Client. Dabei ist der Client dafür eingerichtet, dem Server eine Aktualisierungsmitteilung zu senden. Der Synchronizer des Servers ist dafür eingerichtet, die Aktualisierungsmitteilung zu empfangen, die einen der Knoten des Datenmodells bezeichnet, die des Weiteren ein Attribut dieses Knotens bezeichnet, und die angibt, wie der Wert dieses Attributs zu aktualisieren ist. Der Controller des Servers ist dafür eingerichtet, den Wert dieses Attributs dieses Knotens in Abhängigkeit von der Aktualisierungsmitteilung zu aktualisieren, wenn die Aktualisierungsmitteilung die ID des Knotens bezeichnet.
Ferner wird ein Verfahren bereitgestellt. Das Verfahren umfasst:
Empfangen einer Aktualisierungsmitteilung, die einen Knoten eines Datenmodells mittels einer ID des Knotens bezeichnet, wobei die Aktualisierungsmitteilung des Weiteren ein Attribut dieses Knotens bezeichnet, und wobei die Aktualisierungsmitteilung angibt, wie ein Wert dieses Attributs zu aktualisieren ist, wobei das Datenmodell drei oder mehr Knoten umfasst, wobei einem oder mehr der drei oder mehr Knoten des Datenmodells eine ID zugewiesen ist, wobei jeder dieser ein o- der mehr Knoten durch seine ID von den anderen Knoten des Datenmodells ein- deutig unterscheidbar ist, wobei wenigstens zwei der Knoten des Datenmodells jeweils ein oder mehrere Attribute aufweisen, wobei jedes der besagten Attribute einen Wert annehmen kann, der in dem Datenmodell gespeichert ist, wobei jedem Knoten der besagten wenigstens zwei Knoten eine Pfadangabe zugewiesen ist, wobei die Pfadangabe den jeweiligen Knoten, dem diese Pfadangabe zugewiesen ist, und wenigstens einen weiteren der drei oder mehr Knoten des Datenmodells aufweist, und wobei sich die Pfadangabe von jedem Knoten der besagten wenigstens zwei Knoten von der ID des jeweiligen Knotens unterscheidet. Und:
Aktualisieren des Wertes des in der Aktualisierungsmitteilung bezeichneten Attri- buts mittels der Schreibfunktion dieses Attributs in Abhängigkeit von der Aktualisierungsmitteilung.
In Ausführungsformen kann das Verfahren beispielsweise einen weiteren Schritt oder weitere Schritte umfassen, beispielsweise:
Generierung der IDs, und/oder
Aktualisierungen zwischen Client und Server
Abgleich der Datenmodelle zwischen Server und Client, und/oder
Spezifikation der Schreibfunktion / Speicherfunktion.
Des Weiteren wird ein Computerprogramm mit einem Programmcode zur Durchführung des oben beschriebenen Verfahrens bereitgestellt. Bevorzugte Ausführungsformen finden sich in den abhängigen Ansprüchen.
Nachfolgend werden bevorzugte Ausführungsformen der Erfindung unter Bezugnahme auf die Zeichnungen beschrieben.
In den Zeichnungen ist dargestellt:
Fig. 1 a zeigt eine Vorrichtung gemäß einer Ausführungsform,
Fig. 1 b zeigt die hierarchische Graphenstruktur des Datenmodells gemäß einer
Ausführungsform,
Fig. 1 c zeigt ein System gemäß einer Ausführungsform,
Fig. 2a zeigt ein Datenmodell, eine Beobachter-Struktur und eine Controller-
Struktur,
Fig. 2b zeigt einen möglichen Ablauf der Synchronisation zwischen einem Client und einem Server,
Fig. 2c zeigt ein Praxisbeispiel für die Einrichtung eines Beschallungssystems ohne Verwendung von UI.FM,
Fig. 2d - 2g zeigen erfindungsgemäße Anwendungsbeispiele zur verzögerungsarmen
Synchronisation gemäß Ausführungsformen,
Fig. 3 zeigt ein UI.FM System gemäß bevorzugter Ausführungsformen,
Fig. 4a - 4e zeigen weitere erfindungsgemäße Anwendungsbeispiele zur verzögerungsarmen Synchronisation gemäß Ausführungsformen,
Fig. 5a - 5c zeigen eine erfindungsgemäße Realisierung einer Web-Applikation gemäß einer Ausführungsform,
Fig. 6a, 6b zeigen weitere Ausführungsbeispiele der verzögerungsarmen Synchronisation gemäß Ausführungsformen, Fig. 7a - 7f zeigen ein Datenmodell und dessen programmiertechnische Umsetzung gemäß einer Ausführungsform,
Fig. 8a - 8g zeigen die Konsoleneingabe von Programmierbefehlen und die zurückge- lieferten Ergebnisse gemäß Ausführungsformen,
Fig. 9a - 9h zeigen die Änderung einer Datenstruktur durch Hinzufügung eines Attributs gemäß einer Ausführungsform, Fig. 10a - 10e zeigen, wie Nutzer sich gemäß einer Ausführungsform informieren lassen können, wenn ein Wert des Datenmodells sich ändert, und zeigt eine Alarmausgabe bei Wiedergabe einer Datenaufzeichnung ent sprechend der wiedergegebenen Datenaufzeichnung gemäß einer Ausfüh rungsform.
Fig. 1 a zeigt eine Vorrichtung gemäß einer Ausführungsform. Die Vorrichtung umfasst ein Datenmodell 1 10, wobei das Datenmodell 1 10 drei oder mehr Knoten umfasst, wobei einem oder mehr der drei oder mehr Knoten des Datenmodells 1 10 eine ID zugewiesen ist, wobei jeder dieser ein oder mehr Knoten durch seine ID von den anderen Knoten des Datenmodells 1 10 eindeutig unterscheidbar ist, wobei wenigstens zwei der Knoten des Datenmodells 1 10 jeweils ein oder mehrere Attribute aufweisen, wobei jedes der besagten Attribute einen Wert annehmen kann, der in dem Datenmodell 1 10 gespeichert ist, wobei jedem Knoten der besagten wenigstens zwei Knoten eine Pfadangabe zugewiesen ist, wobei die Pfadangabe den jeweiligen Knoten, dem diese Pfadangabe zugewiesen ist, und wenigstens einen weiteren der drei oder mehr Knoten des Datenmodells 1 10 aufweist, und wobei sich die Pfadangabe von jedem Knoten der besagten wenigstens zwei Knoten von der ID des jeweiligen Knotens unterscheidet.
In einer Ausführungsform kann beispielsweise jedem der Knoten des Datenmodells 1 10 eine ID zugewiesen sein, wobei jeder der Knoten des Datenmodells durch seine ID von den anderen Knoten des Datenmodells 1 10 eindeutig unterscheidbar ist.
Mit anderen Worten weisen also zahlreiche der Knoten des Datenmodells eine Pfadangabe auf, die mehr als einen Knoten aufweisen. Ist folgt in einer Baumhierarchie beispielsweise ein Knoten„Renderer" unmittelbar dem Knoten„root", so kann die Pfadangabe bei- spielsweise„root.Renderer" lauten, und diese Pfadangabe weist somit zwei der Knoten des Datenmodells, nämlich „root" und „Renderer" auf. Über die Pfadangabe „root.Renderer" hinaus ist dem Knoten„Renderer" auch noch eine im Datenmodell eindeutige ID zugewiesen, beispielsweise die Zahl„2" (siehe z.B. Datenmodell 310 in Fig. 3). In jedem Fall aber, sind ID und Pfadangabe eines Knotens immer voneinander verschieden. Die ID, die dem Knoten zugewiesen ist, existiert also zusätzlich zur Pfadangabe. Zweck der Pfadangabe ist unter anderem, dass die Knoten des Datenmodells intuitiv über die Pfadstruktur ansprechbar sind, während die ID dazu dient, den Knoten durch einen kurzen Identifikator anzusprechen.
Des Weiteren umfasst die Vorrichtung einen Controller 120, der zu jedem Attribut von jedem der drei oder mehr Knoten des Datenmodells, der Attribute aufweist, eine Schreibfunktion umfasst, und wobei der Wert des Attributs mittels der Schreibfunktion änderbar ist.
Ferner umfasst die Vorrichtung einen Synchronizer 130. Der Synchronizer 30 ist dafür eingerichtet, eine Aktualisierungsmitteilung zu empfangen, die einen der Knoten des Datenmodells 1 10 bezeichnet, wobei die Aktualisierungsmitteilung des Weiteren ein Attribut dieses Knotens bezeichnet, und wobei die Aktualisierungsmitteilung angibt, wie der Wert dieses Attributs zu aktualisieren ist, wobei die Aktualisierungsmitteilung den Knoten mittels der ID des Knotens bezeichnet.
Der Controller 120 ist dafür eingerichtet, den Wert dieses Attributs dieses Knotens in Abhängigkeit von der Aktualisierungsmitteilung mittels der Schreibfunktion dieses Attributs zu aktualisieren.
Dabei kann das Datenmodell 1 10 eine graphenförmige Struktur aufweisen. So kann zum Beispiel festgelegt sein, dass ein Knoten„root" dem Knoten„Renderer" vorausgeht. Diese Beziehung kann als ein Graph von von„root" nach„Renderer" definiert sein, bzw. ange- geben werden. Ferner kann zum Beispiel festgelegt sein, dass der Knoten „Renderer" dem Knoten„Scene" vorausgeht. Diese Beziehung kann als ein Graph von von„Renderer" nach „Scene" definiert sein, bzw. ansehen werden. Aus all solchen Beziehungen ergibt sich dann die graphenförmige Struktur des Datenmodells 1 10. Das Datenmodell 1 10 kann baumförmige hierarchische Struktur aufweisen, die als Sonderfall einer graphenförmigen Struktur angesehen werden kann. In einer baumförmigen hierarchischen Struktur existiert üblicherweise ein Wurzelknoten, dem alle weiteren Kno- ten des Datenmodells mittelbar oder unmittelbar nachfolgen. Ein solche baumförmigen hierarchischen Struktur ist in Fig. 1 b dargestellt..
Beispielsweise kann eine Pfadangabe „root.Renderer.Scene.srcO" den entsprechenden Knoten srcO in einer baumförmigen Hierarchie, wie die baumförmige Hierarchie der Fig. 1 b, eindeutig bezeichnen. Eine solche Pfadangabe umfasst den Knoten„srcO" und drei weitere Knoten des Datenmodells, nämlich„root",„Renderer" und„Scene". Nur„srcO" als Namen zu verwenden, um den entsprechenden Knoten eindeutig zu bezeichnen, ist unter Umständen nicht ausreichend, denn eventuell kommt der Knoten„srcO" als Name im Da- tenmodell mehrmals vor.
Eine ID, mit der der Knoten kurz und eindeutig angesprochen wird, kann beispielsweise eine Zahl sein. Beispielsweise könnte der Knoten srcO durch die ID„7" bezeichnet sein. Zur Unterscheidung der Begriffe ID und Pfadangabe kann folgendes erläutert werden. Eine einfache ID hat nur eine Anforderung: Sie muss einen Knoten lediglich systemweit eindeutig adressieren. Es reicht hier also beispielsweise alle Knoten einfach zu numme- rieren. Eine Pfadangabe erfüllt in der Regel über die ID hinausgehende weitere Eigenschaften: Sie umfasst lokale Knotennamen, welche einen Weg von der Wurzel des Graphen bis hin zum zu adressierenden Knoten über Zwischenknoten beschreiben. Im Gegensatz zur globalen ID muss der lokale Knotenname nur für den Knoten und seine Geschwisterknoten eindeutig sein. Über die Kombination der lokalen Knotennamen eines Knoten mit den lokalen Knotennamen der Eltern- bzw. Vorgängerelemente eines Knotens entsteht die ebenfalls systemweit eindeutige Pfadangabe.
In einer Ausführungsform kann die ID jedes der drei oder mehr Knoten des Datenmodells beispielsweise eine Zahl oder eine Zeichenkette oder ein Hashwert sein.
In einer Ausführungsform weist der Controller 120 zu jedem Attribut von jedem der drei oder mehr Knoten des Datenmodells, der Attribute auf, eine Lesefunktion umfasst, wobei der Wert des Attributs mittels der Lesefunktion lesbar ist. Beispielsweise kann in einer besonderen Ausführungsform der Synchronizer 140 dafür eingerichtet sein, die Aktualisierungsnachricht zu empfangen, mit der darin enthaltenen ID eine zugehörige Controller-Subeinheit des Controllers 120 zu ermitteln, die für diesen Knoten zuständig ist (dafür besitzt der Synchronizer 140 beispielsweise ein Dictionary (Wörterbuch) / eine Map (Abbildung), welche zu jeder ID eine Referenz auf eine Control- ler-Subeinheit speichert), und dann dieser eine Information zu übergeben, welche den Namen des zu ändernden Attributs als auch den Wert enthält. Die Controller-Subeinheit des Controllers 120 ändert dann mit Hilfe der Schreibfunktion das Datenmodell 1 10.
Gemäß einer Ausführungsform ist der Synchronizer dafür eingerichtet, die Aktualisierungsmitteilung zu empfangen, die den besagten Knoten des Datenmodells bezeichnet, wobei die Aktualisierungsmitteilung des Weiteren das besagte Attribut dieses Knotens bezeichnet, und wobei die Aktualisierungsmitteilung angibt, wie der Wert dieses Attributs zu aktualisieren ist, wobei die Aktualisierungsmitteilung die Pfadangabe des Knotens bezeichnet, wobei der Controller dafür eingerichtet ist, den Wert dieses Attributs dieses Knotens in Abhängigkeit von der Aktualisierungsmitteilung zu aktualisieren.
In einer Ausführungsform bilden die drei oder mehr Knoten des Datenmodells eine gra- phenförmige, z.B. baumförmige Hierarchie, so dass jedem Knoten des Datenmodells wenigstens einer der Knoten des Datenmodells in der graphenförmigen Hierarchie unmittelbar nachfolgt und/oder mindestens einer der Knoten des Datenmodells in der graphenförmigen Hierarchie unmittelbar vorausgeht, wobei wenigstens einem der Knoten des Datenmodells zwei Knoten des Datenmodells in der baumförmigen Hierarchie unmittelbar nachfolgen.
Fig. 1 b zeigt eine solche graphenförmige Datenstruktur am Beispiel einer baumförmigen hierarchischen Datenstruktur des Datenmodells gemäß einer Ausführungsform. In der baumförmigen Hierarchie des Datenmodells folgen die Knoten„DHD®" und„Renderer" dem Knoten„root" unmittelbar nach. Umgekehrt geht der Knoten„root" geht den Knoten „DHD®", und„Renderer" unmittelbar voraus. Dem Knoten„Renderer" folgen die Knoten „LSSetups", „Scene", „Spatial Sound Wave" und „WavPI" unmittelbar nach. Umgekehrt geht der Knoten„Renderer" den Knoten„LSSetups",„Scene",„Spatial Sound Wave" und „WavPI" unmittelbar voraus, usw.
Gemäß einer Ausführungsform weist die Vorrichtung ferner eine Schnittstelle auf, die dafür eingerichtet ist, Informationen über Änderungen des Datenmodells entgegenzunehmen, die einem der Knoten des Datenmodels ein oder mehrere Attribute hinzufügen, wobei die Vorrichtung dafür eigerichtet ist, für jedes dieser hinzugefügten ein oder mehreren Attribute eine Lesefunktion und eine Schreibfunktion automatisch zu erzeugen, wobei der Wert des besagten Attributs mittels der Lesefunktion lesbar ist, und wobei der Wert des Attributs mittels der Schreibfunktion änderbar ist. In Ausführungsformen ändert beispielsweise die erzeugte Schreibfunktion nicht nur den Wert des lokalen Datenmodells, sondern sorgt gleichzeitig dafür, dass der Synchronizer über die Änderung informiert wird, Änderungs-Events im System propagiert werden und/oder angeschlossene Beobachter auf die Änderung reagieren können und/oder wei- tere Dinge veranlasst werden, wie z.B. die Aufzeichnung von Automationsdaten, Und- o/Redo usw.
In einer Ausführungsform ist die Vorrichtung dafür eingerichtet, die Lesefunktion und die Schreibfunktion für jedes der Attribute jedes der Knoten des Datenmodells, der Attribute aufweist, mittels einer Webapplikation bereitzustellen, so dass die besagte Lesefunktion und die besagte Schreibfunktion mittels der Webapplikation nutzbar sind. In einer Ausführungsform kann die Webapplikation beispielsweise in JavaScript und/oder HTML implementiert sein. Gemäß einer Ausführungsform ist die Vorrichtung dafür eingerichtet, für eines der Attribute eines der Knoten des Datenmodells, auf eine Nutzereingabe hin, eine Änderungsüberwachung einzurichten.
Beispielsweise kann die Änderungsüberwachung dafür eingerichtet sein, ein „Event" (event = Ereignis) zu versenden bzw. auszulösen.
Beispielsweise kann z.B. die Vorrichtung dafür eingerichtet ist, einen Alarm auszugeben, wenn ein Wert eines der Attribute sich ändert, für das eine Änderungsüberwachung eingerichtet ist.
Um z.B. einen Alarm anzuzeigen, kann man einen Beobachter auf das Event registrieren. Dieser empfängt das Event und gibt dann einen Alarm aus. Statt der Ausgabe eines Alarms kann die Reaktion aber auch jede andere sein. Gemäß einer Ausführungsform wird ein Server bereitgestellt. Der Server ist eine Vorrichtung wie oben beschrieben. Ferner ist der Server dafür eingerichtet, eine Anmeldung von ein oder mehreren Clients entgegenzunehmen. Ferner ist der Server dafür eingerichtet, den ein oder mehreren Clients auf deren Anmeldung hin, Informationen über das Datenmodell zu übertragen, wobei diese Informationen über das Datenmodeii die Werte der Attribute von allen Knoten oder von zwei oder mehr der Knoten des Datenmodells umfassen, die Attribute aufweisen, und wobei die Informationen über das Datenmodell ferner für jeden Knoten des Datenmodells oder für die wenigstens zwei Knoten des Datenmodells angeben, welche der Knoten des Datenmodells diesem Knoten unmittelbar nachfolgen und/oder welche Knoten des Datenmodells diesem Knoten unmittelbar vorausgehen. Das Datenmodell enthält dabei beispielsweise auch die Knoten IDs.
In einer Ausführungsform ist der Server dafür eingerichtet, eine Anmeldung von zwei oder mehreren Clients entgegenzunehmen, wobei der Synchronizer des Server dafür eingerichtet ist, eine Nachricht von einem der Clients zu empfangen, die angibt, dass ein Wert eines Attributs eines Knotens des Datenmodells sich geändert hat, und wobei der Synchronizer des Server dafür eingerichtet ist, auf die Nachricht des besagten Clients hin, die anderen zwei oder mehreren Clients, die sich beim Server angemeldet haben, davon un- terrichtet, dass ein Wert eines Attributs eines Knotens des Datenmodells sich geändert hat.
Umgekehrt kann der Server auch das Datenmodell und Aktualisierungen von Client empfangen. Dies kann beispielsweise dann sinvoll sein, wenn der Client längere Zeit z.B. oh- ne Verbindung mit dem Server, z.B. offline gearbeitet hat.
Gemäß einer Ausführungsform ist der Server dafür eingerichtet, einem Gerät drahtlos, oder drahtgebunden eine Nachricht zuzusenden, die dem Gerät mitteilt, dass ein Attribut eines der Knoten des Datenmodells sich geändert hat.
In einer Ausführungsform ist die Vorrichtung dafür eingerichtet ist, dem Gerät die Nachricht drahtlos, z.B. mittels WLAN, mittels GPRS, mittels UMTS oder mittels LTE, zuzusenden. Gemäß einer Ausführungsform ist das Gerät ein Renderer zur Erzeugung von ein oder mehreren Lautsprechersignalen ist. In einer Ausführungsform kann das Gerät auch eine DHD®-Audio Matrix sein. Beispielsweise können die angeschlossenen Clients eine (3D) Audio-Workstation, ein Audio-Plugin (VST / RTAS / AudioUnits etc.) und/oder eine iPad®- App sein.
In einer Ausführungsform ist der Server dafür eingerichtet, vom Client Informationen über das Datenmodell des Clients zu empfangen, wobei diese Informationen über das Datenmodell des Clients die Werte der Attribute von allen Knoten oder von zwei oder mehr der Knoten des Datenmodells des Clients umfassen, die Attribute aufweisen, und wobei die Informationen über das Datenmodell des Clients ferner für jeden Knoten des Datenmodells des Clients oder für die wenigstens zwei Knoten des Datenmodells des Clients angeben, welche der Knoten des Datenmodells des Clients diesem Knoten unmittelbar nachfolgen und/oder welche Knoten des Datenmodells des Clients diesem Knoten unmittelbar vorausgehen.
Gemäß einer weiteren Ausführungsform wird ein Client bereitgestellt. Der Server ist eine Vorrichtung wie oben beschrieben. Ferner ist der Client dafür eingerichtet, sich bei dem oben beschriebenen Server anzumelden. Der Client ist dafür eingerichtet, auf die Anmeldung beim Server hin, Informationen über das Datenmodell des Servers zu empfangen, wobei diese Informationen über das Datenmodell des Servers die Werte der Attribute von allen Knoten oder von zwei oder mehr Knoten des Datenmodells des Servers umfassen, die Attribute aufweisen, und wobei die Informationen über das Datenmodell des Servers ferner für jeden Knoten des Datenmodells oder für die zwei oder mehr Knoten des Datenmodells des Servers angeben, welche der Knoten des Datenmodells des Servers diesem Knoten unmittelbar nachfolgen und/oder welche Knoten des Datenmodells des Servers diesem Knoten unmittelbar vorausgehen. Ferner ist der Client dafür eingerichtet, sein Datenmodell abhängig von den Informationen über das Datenmodell des Servers hin zu aktualisieren.
In einer Ausführungsform ist der Client dafür eingerichtet, dem Server Informationen über das Datenmodeil des Clients zu übertragen, wobei diese Informationen über das Daten- modell des Clients die Werte der Attribute von allen Knoten oder von zwei oder mehr der Knoten des Datenmodells des Clients umfassen, die Attribute aufweisen, und wobei die Informationen über das Datenmodell des Clients ferner für jeden Knoten des Datenmodells des Clients oder für die wenigstens zwei Knoten des Datenmodells des Clients angeben, welche der Knoten des Datenmodells des Clients diesem Knoten unmittelbar nachfolgen und/oder welche Knoten des Datenmodells des Clients diesem Knoten unmittelbar vorausgehen.
Gemäß einer Ausführungsform kann der Client zur Erstellung objektorientierter Audioszenen eingerichtet sein.
Fig. 1 c zeigt ein System gemäß einer Ausführungsform.
Das System umfasst den oben beschriebenen Server 170 und den oben beschriebenen Client 160. Dabei ist der Client 160 dafür eingerichtet, dem Server 170 eine Aktualisie- rungsmitteilung zu senden. Der Synchronizer des Servers 170 ist dafür eingerichtet, die Aktualisierungsmitteilung zu empfangen, die einen der Knoten des Datenmodells des Servers 170 bezeichnet, die des Weiteren ein Attribut dieses Knotens bezeichnet, und die angibt, wie der Wert dieses Attributs zu aktualisieren ist. Der Controller des Servers 170 ist dafür eingerichtet, den Wert dieses Attributs dieses Knotens in Abhängigkeit von der Aktualisierungsmitteilung zu aktualisieren, wenn die Aktualisierungsmitteilung die ID des Knotens bezeichnet. Im Folgenden werden zunächst Grundkonzepte vom Ausführungsformen erläutert. Daran anschließend werden bevorzugte Ausführungsformen und deren Konzepte im Detail beschrieben.
Ausführungsformen stellen einen allgemeinen Mechanismus bereit, welcher die Vorteile Key-Value-basierter (Schlüsselwert-basierter) Datenbanken mit dokumentenorientierten Ansätzen kombiniert. Ziel ist, graphenförmig strukturierte Datenstrukturen in Echtzeit und/oder niedrig-latent bzw. verzögerungsarm miteinander zu synchronisieren.
Gemäß Ausführungsformen wird bei der Entwicklung einer Applikation folgendermaßen vorgegangen:
Es wird eine graphenförmige Datenstruktur definiert, welche die Daten der Applikation repräsentiert. Die Datenstruktur kann z.B. ein JSON- oder XML-Datensatz sein (JSON = JavaScript Object Notation = JavaScript Objekt-Notation; XML = Extensible Markup Lan- guage = erweiterbare Auszeichnungssprache).
Aus der graphenförmigen Datenstruktur wird mit Hilfe eines Code-Generators der ausführbare Controller- und Datenmodell-Code generiert. Dies kann Server- als auch Client- seitig erfolgen. Der so generierte Code umfasst beispielsweise Routinen zum Lesen und Schreiben der Daten in das Graphen-Modell, Routinen zum Benachrichtigen an Änderungen interessierter Beobachter, sowie Routinen zum Übertragen der Änderungen am Datenmodell an einen zentralen Server bzw. daran angeschlossene Clients.
Fig. 2a zeigt drei Strukturen, nämlich ein Datenmodell (Model) 201 , eine Beobachter- Struktur (View / Sicht) 203, sowie eine Controller-Struktur (Controller) 202, die basierend auf einem ursprünglichen Datenmodell, das graphenförmig ist, automatisch generiert werden.
Die erzeugte Controller-Struktur 202 umfasst dabei gleich den Code zur Synchronisation der Baum-Hierarchie mit dem Server und damit auch mit anderen Clients. Die Synchronisation kann dabei vom Client zum Server und/oder vom Server zum Client erfolgen. Fig. 2b zeigt einen möglichen Ablauf der Synchronisation zwischen einem Client 210 und einem Server 220. In Fig. 2b umfasst der Client 210 ein Datenmodell 21 1 , einen Controller 212, eine View 213 und einen Synchronizer (Synchronisator) 214. Der Server 220 umfasst in Fig. 2b ein Datenmodell 221 , einen Controller 222 und einen Synchronizer 224.
Ändert beispielweise eine Nutzerin (Anna) 205 etwas, dann wird dies dem Controller 212 des Clients 210 mitgeteilt. Der Controller 212 des Clients 210 ändert die baumförmige Datenstruktur (Model) 21 1 , und informiert mittels einer Aktualisierungsmitteilung gleichzeitig noch den Synchronizer 214 des Client 210. All das passiert, z.B. mit Hilfe der automa- tisch erzeugten Schreibfunktion.
Der Synchronizer 214 des Clients 210 überträgt die Änderung in einer Aktualisierungsmitteilung an den Server 220, z.B. an den Synchronizer 224 des Servers 220. Der Server 220 trägt wiederum auf die Aktualisierungsmitteilung hin die Änderung in sein lokales Da- tenmodell 221 ein, z.B. durch den Controller 222 des Servers 220. Daneben überträgt der Server 220 die Änderung gleichzeitig auch an alle Clients (in Fig. 2b nicht dargestellt).
Startet der Server oder eine Client-Applikation, so laden diese zunächst die Definition der graphenförmigen Datenstruktur und erzeugen mit Hilfe des zuvor angesprochenen Code- Generators den Applikations-Code.
Der Code-Generator kann dabei beispielsweise von einer Festplatte geladen werden, oder aber beispielsweise beim Anmelden vom Server an den Client übertragen werden. Weiterhin wird beispielsweise jedem Knoten der graphenförmigen Datenstruktur eine für den Client eindeutige ID zugeordnet.
Die Erzeugung der ID kann dabei beispielsweise folgendermaßen erfolgen. Jeder Client bekommt zunächst eine systemweit eindeutige Client-ID. Erzeugt ein Client einen neuen Knoten, so wird eine lokal eindeutige Knotenbezeichner mit der Client-Id zu einer systemweit eindeutigen Knoten-Id kombiniert. Dadurch ist nach Übertragung der Client-Id keine zentrale ID-Erzeugung mehr notwendig. Die Vorteile liegen hier vor allem darin, dass für das Erzeugen neuer Knoten im Clients keine Server-Abfragen notwendig sind. Damit ist der Client auch offline in der Lage, systemweit eindeutige IDs zu generieren. Voraussetzung ist jedoch, dass der Client mind. einmal mit dem Server verbunden war. Im Client lokal erzeugte Knoten sind (später) z.B. an den Server und die restlichen Clients zu übertragen und dort in die lokale Datenstruktur einzuhängen. Jedoch ist kein Umbenennen von IDs mehr nötig. Beispielsweise behält die ID ihre Gültigkeit nur zur Laufzeit. Mit Hilfe dieser ID ist es später möglich, jeden Knoten des Baumes direkt zu adressieren. Statt einer langen Pfad- Adresse wie z.B. ,,/stamm/ast/zweig/blatt/zelle" kann der Knoten des Baumes dann auch über die ID, die einen kurzen Hash darstellt, z.B. "0d4", adressiert werden. Dies ist gerade für Applikationen (Anwendungen) mit hohem Datenaufkommen von Bedeutung.
Sind Client und Server gestartet, so müssen zunächst die Datenstrukturen initial abgeglichen werden. Hat der Client eine Zeit lang offline gearbeitet, ist es oftmals sinnvoll, die Datenstruktur von Client zum Server abzugleichen, z.B. indem der Client den Server über die aktuelle Datenstruktur des Clients unterrichtet, damit der Server beispielweise seine Datenstruktur anpassen kann. Möchte hingegen der Client die bestehende Applikation nachträglich vom Server laden, dann ist z.B. die Datenstruktur vom Server zum Client abzugleichen, indem beispielsweise der Client die Datenstruktur des Servers von diesem erhält.
Nimmt man beispielweise an, dass die Daten vom Server auf den Client abgeglichen werden sollen, kann dies beispielweise wie folgt erfolgen: In einem ersten Schritt müssen die Knoten-IDs zwischen Client und Server abgeglichen werden, d.h. zugehörige Knoten auf Clientseite und auf Serverseite müssen die gleichen Adressen haben. Dazu generiert der Server beispielsweise einen ID-Baum, welcher die gleiche Struktur wie der Datenbaum hat, jedoch zunächst nur die IDs enthält. Alternativ dazu könnte der Server bzw. der Client beispielsweise auch eine Tabelle übertragen, wel- che Pfaden zu Ids zuordnet. Dieser ID-Baum wird an den Client übertragen. Dieser ersetzt die bestehenden IDs durch die des Servers. Beobachter (Views) des Baumes werden ebenfalls über die Umbenennung der IDs informiert.
Nach diesem Schritt müssen die tatsächlichen Baum-Daten vom Server auf den Client übertragen werden. Hier zwei Möglichkeiten, wie das beispielsweise funktionieren kann:
Beispiel 1 : Eine erste Möglichkeit ist, die Baum-Daten als baumförmige Datenstruktur an den Client zu übertragen und in die entsprechenden Knoten zu parsen (einzutragen). Beispiel 2: Eine zweite Möglichkeit ist, die Baum-Daten Knoten für Knoten einzeln vom Server an den Client zu übertragen. Dazu werden beispielsweise die Daten des jeweiligen Knotens zusammen mit dem Knotenbezeichner bzw. Knotennamen in ein Datenpaket verpackt und an den Client übertragen. Dieser kann mit Hilfe der Knotenbezeichner den zugehörigen Knoten ermitteln und die entsprechenden Daten in diesen schreiben.
Die erste Möglichkeit wird verwendet, um größere Datenstrukturen initial vom Server an den Client bzw. umgekehrt zu übertragen. Die zweite Möglichkeit wird verwendet, um kleine, aber häufig auftretende Änderungen effektiv zwischen Client und Server auszutauschen.
Um mehrere Clients miteinander zu verbinden, ist es dabei ausreichend, wenn der Server die Datenpakete, die er von einem Client erhält, einfach an die anderen Clients weiterleitet. Durch das hier vorgeschlagene System besitzen alle Clients die gleiche Baumstruktur und dieselben IDs. Jeder der Clients ist damit in der Lage, Änderungs-Nachrichten der anderen Clients zu verstehen. Ausführungsformen kombinieren die Performance- Vorteile der Schlüsselwert- Adressierung (Key-Value-Datenbanken) mit den Möglichkeiten dokumentenonentierter Ansätze (z.B. XML, JSON-Daten) sowie der automatisierten Code-Generierung.
Die Key-Value-Adressierung von Daten ermöglichen einen schnellen maschinellen Zugriff auf Daten. Hierdurch wird eine hochfrequente niedriglatente Synchronisation von Software-Applikationen gewährleistet.
Der dokumentenorientierte Ansatz vereinfacht die Verwaltung von großen, komplex strukturierten Datensätzen. Der Zugriff auf die Daten, z.B. durch eine(n) Anwendungsentwick- ler/in, ist hierdurch sehr einfach. Anwendungen können dadurch schnell und effizient entwickelt werden.
Die automatische Code-Generierung erlaubt wiederkehrende Code-Bestandteile wie Controller, Publisher, Parser, Serializer, Synchronizer, Lese- und Schreibfunktionen automati- siert aus der graphenförmigen Datenstruktur zu erzeugen. Dies ermöglicht eine weitere Herabsetzung der Entwicklungsdauer für verteilte Software-Applikationen.
Ebenso spart auch die automatische Code-Erzeugung aus einer graphenförmigen Datenstruktur Zeit und Kosten für die Entwicklung verteilter Software-Applikationen. Eine Erwei- terung der graphenförmigen Datenstruktur bedeutet automatisch auch eine Erweiterung des Protokolls, eine Erweiterung des Parsers, des Serializers usw., des Synchronizers usw. Die Synchronisation zwischen den graphenförmigen Datenstrukturen erfolgt für den Anwendungsentwickler völlig transparent. Der Anwendungsentwickler definiert einfach seine Datenstruktur, den Rest übernimmt der Code-Generator. Dadurch das sowohl jeder Client, als auch der Server das gesamte Datenmodell (oder, gemäß Ausführungsformen, zumindest einen Teil des Datenmodells) besitzen, ist es möglich, Clients offline arbeiten zu lassen und später zu synchronisieren. Gleichzeitig wird die Stabilität des Systems deutlich erhöht. Jeder Client kann damit gleichzeitig als Backup des Servers agieren.
Ein maßgebliches Einsatzgebiet von Ausführungsformen liegt in der Web-Entwicklung. Hierbei wird der Code in der Regel offen als JavaScript, Ruby oder ähnliches, aber nicht in Form von Maschinencode übertragen. Technische Anwendungsgebiete sind beispielsweise kollaborative verteilte Echtzeitapplikationen, z.B., die Steuerung- und Überwachung von Maschinen, die Steuerung und Überwachung von Audio-Systemen, verteilte Software-Applikationen im Allgemein, und Webapplikationen. Ausführungsformen sind als ein User-Interface-Framework (UI.FM) realisiert, das z.B. webbasiert sein kann, und welches die Entwicklung verteilter Applikationen deutlich nutzerfreundlicher, kosteneffizienter und plattformübergreifend gestaltet.
Einige Ausführungsformen können beispielweise dafür eingesetzt werden, um 3D-Audio- Systeme gleichzeitig von mehreren Hörpositionen aus, z.B. in einem Stadion, akustisch einzurichten.
Fig. 2c zeigt ein Beispiel ohne Verwendung von UI.FM. Dabei stellt Fig. 2c die Bregenzer Seebühne dar. Vorne ist die Bühne 230 dargestellt. Auf der Bühne 230 sind eine große Anzahl Lautsprecher 231 , 232, 233, 23N installiert. Im Zuschauerbereich sieht man das FoH 240 ("Front of House": Der Platz in der Mitte vor dem Bühnenhaus, der Ort wo der Tonmeister den Ton mischt), dass die Lautsprecher 231 , 232, 233, 23N entsprechend einstellbarere Steuerparameter ansteuert. Das FoH umfasst ein Mischpult 241 , einen Richtungsmischer (RIM) 242, Konfigurationswerkzeuge (Config) 243, usw. Im großen Zu- schauerbereich 250 können beispielsweise 7.000 Personen sitzen. Angestrebt ist, dass alle Zuschauer einen optimalen Sound haben. Dazu geht man, wenn Ausführungsformen der Erfindung nicht zur Verfügung stehen, beispielsweise folgendermaßen vor: Man geht an einen ersten Platz, z.B. an eine Position 251 auf der rechten Seite. An dieser ersten Position 251 hört man sich den Klang an und gibt dann per Handy Änderungswünsche zum FoH 240 durch. Beim FoH 240 werden entsprechend Parameter geändert. Man hört sich dann den Sound an und, wenn man mit dem Sound zufrieden ist, bewegt man sich in eine zweite Position 252 , z.B. eine Position weiter links. Dort hört man sich entsprechend wieder den Klang an, übergibt dann per Funk wiederum Änderungswünsche zum FoH 240 durch. Beim FoH werden entsprechend wieder Parameter geändert, in der zweiten Position 252 hört man entsprechend wieder den geänderten Sound (Klang), und nimmt man entsprechend wieder einen Abgleich mit dem FoH vor. Dann bewegt man sich in die nächste Position und setzt das Verfahren entsprechend fort. Ein solches Verfahren ist sehr aufwendig und mühsam. Im Folgenden werden nun Ausführungsformen im Detail beschrieben. Dabei wird die Funktionalität von UI.FM erläutert. UI.FM ist ein neues User- Interface Framework (User- Interface Framework = Nutzer-Schnittstellen Rahmenstruktur).
Fig. 2d zeigt eine Ausführungsform, bei der die neue Lösung implementiert ist. Wiederum sind eine Bühne 260, ein FoH 270 und ein Zuschauerbereich 280 dargestellt. Im Beispiel der Fig. 2d, ist nun jedoch ein UI.FM Server 275 installiert. Der UI.FM Server 275 ist mit den Komponenten im System verbunden. Zu sehen sind drei verschiedene Endgeräte, nämlich zweimal ein iPad® 282, 283 und ein iPhone® 281. Bei den Endgeräten könnte es sich auch um beliebige, andere geeignete Endgeräte handeln.
Nun können sich beispielsweise drei Toningenieure 284, 285, 286 gleichzeitig auf unterschiedliche Positionen der Tribüne begeben, wobei jeder der Toningenieure 284, 285, 286 nun den Klang positionieren, konfigurieren und/oder einstellen kann. Die Änderungen werden jeweils über das jeweilige mobile Endgerät 281 , 282, 283 vorgenommen. Das mobile Endgerät 281 , 282, 283 ist mit dem UI.FM Server 275 verbunden z.B. über WLAN. Die Endinformation wird im UI.FM Server 275 eingestellt, und steuert dann entsprechend die Komponenten (in Fig. 2d nicht gezeigt) im Studioraum. Beispielsweise können Config, Rim und Mischpult dabei die Komponenten sein, die gesteuert werden. Änderungen, die ein Toningenieur 286 auf einem Endgerät 283 tätigt, werden sofort an die anderen Endgeräte 281 , 282 weitergegeben. D.h., die anderen Endgeräte 281 , 282 werden entsprechend aktualisiert. Das bedeutet, die anderen Teilnehmer (z.B. in Fig. 2d: die anderen Toningenieure) 284, 285 können sofort sehen, was einer der Teilnehmer 286 geändert hat, können die Änderung entsprechend hören, und darauf unmittelbar reagieren. Mit anderen Worten, ändert einer der Toningenieure in Position C etwas, was sich in Position C sehr gut anhört, aber nicht in Position B, so kann die Person 285 in Position B sofort darauf reagieren, etwas anderes einstellen und so wieder Änderungen vornehmen. Hierdurch wird ermöglicht, dass die drei Personen 284, 285, 286 in den Positionen A, B und C z.B. Steuerparameter untereinander optimal aushandeln können. Die Ausführungsform der Fig. 2d stellt also eine deutliche Vereinfachung und Verbesserung im Vergleich zu dem Vorgehen, dass unter Bezugnahme auf Fig. 2c erläutert wurde, dar.
Ein anderes Anwendungsszenario, nämlich die Einrichtung eines Soundsystems im Auto ist in Fig. 2e gezeigt. Zu sehen ist ein Fahrzeug, hier, z.B. ein Auto 255, mit vier Plätzen 261 , 262, 263, 264 darin. Im Fahrzeug ist entsprechend ein Beschallungssystem mit zahlreichen Lautsprechern 265 installiert. Erwünscht ist nun, dass für jeden Sitzplatz 261 , 262, 263, 264 ein optimaler Sound erzeugt wird.
Um dies zu realisieren können nun vier iPads® 266, 267, 268, 269 im Auto 255 verwendet werden. Vier Toningenieure 256, 257, 258, 259 können nun die vier iPads® 266, 267, 268, 269 im Auto 255 nutzen. So können die vier Toningenieure 256, 257, 258, 259 im Auto 255 gleichzeitig den Sound mithilfe der iPads® 266, 267, 268, 269 einstellen. So können die vier Toningenieure 256, 257, 258, 259 im Auto 255 den Sound sofort hören und mithilfe der iPads® 266, 267, 268, 269 einen optimalen (Gesamt-)Klang untereinander aushandeln, ebenso wie bereits für das Beispiel der Fig. 2d im Fall der Bregenzer Seebühne erläutert. Hierzu wird ein UI.FM Server 276 eingesetzt, mit dem die iPads® 266, 267, 268, 269 über Wifi verbunden sind. Alle Änderungen, die ein Benutzer 256 an einem Gerät 266 vornimmt, werden von dem Gerät 266 an den UI.FM Server 276 übertragen, und der UI.FM Server 276 überträgt die Änderungen an die anderen Geräte 267, 268, 269 weiter. Dies alles geschieht verzögerungsarm. Fig. 2f zeigt ein weiteres Ausführungsbeispiel gemäß einer Ausführungsform, in dem das Audiolabor des Fraunhofer Instituts für Digitale Medientechnologie in Ilmenau dargestellt ist. Hier ist sehr viel Server-Technik vorhanden, die untereinander kollaborieren sollen. Unter anderem ist in Fig. 2f ein Renderer 291 dargestellt, des Weiteren eine Lichtsteuerung 292, fem er ein Verstärker 293, und 294 eine Audiomatrix. Links in Fig. 2f, sind eine Reihe von Endgeräten dargestellt, beispielsweise ein PC-Arbeitsplatz 295, ein erstes i- Pad® (iPad® 1 ) 296, ein zweites iPad® 2 (iPad® 2) 297, und z.B. ein Endgerät 298 von einem Gast. So kann ein Gast beispielsweise auch sein Mobiltelefon 298 bei sich führen, das mit den anderen Geräten 291 , 292, 293, 294, 295, 296, 297 kollaborieren soll.
Beispielsweise kann erwünscht sein, dass die Hardware 291 , 292, 293, 294, in Fig. 2f rechts, durch die Geräte 295, 296, 297, 298, in Fig. 2f links, gesteuert werden kann. So soll es beispielweise möglich sein, dass alle Parameter durch die Geräte 295, 296, 297, 298 in Fig. 2f links einstellbar sind.
Die Verknüpfung der Geräte 295, 296, 297, 298 in Fig. 2f links mit der Hardware 291 , 292, 293, 294 in Fig. 2f rechts wird durch einen UI.FM Server 290 realisiert. Der UI.FM Server 290 ist einerseits mit der Hardware 291 , 292, 293, 294 in Fig. 2f rechts, verbunden. Z.B. werden zwischen dem UI.FM Server 290 und dem Renderer 291 Pegeldaten und Steuerdaten ausgetauscht. Entsprechend ist auch die weitere Hardware 292, 293, 294 in Fig. 2f rechts, mit dem UI.FM Server 290 verbunden. Entsprechend sind auch die Endgeräte 295, 296, 297, 298 in Fig. 2f links mit dem UI.FM Server 290 verbunden. Wenn nun ein Benutzer etwas über eines der iPads® 296, 297, z.B. über„iPad® 1 " 296 eingibt, beispielsweise Steuerinformation, wird diese Eingabe entsprechend an den UI.FM Server übertragen 290. Der UI.FM Server 290 übergibt dann diese Information entsprechend an die Peripherie-Hardware 291 , 292, 293, 294 in Fig. 2f rechts.
UI.FM weist zahlreiche Vorteile auf. So kann der UI.FM Server beispielsweise als Webserver 215 realisiert sein, wie in Fig. 2g gezeigt, und die Clients, beispielsweise iPads® 216, 217, können Webclients 226, 227 realisieren. Es muss also auf den Clients 216, 217 keine Software installiert werden, sondern der Webserver 215 liefert die Software beim Anmelden der Clients 216, 217 an die Clients 216, 217 aus. Durch eine Realisierung als Webserver 215 bzw. als Webclients 226, 227 wird sehr viel Aufwand eingespart.
Ein weiterer Vorteil von UI.FM ist, dass das System in verzögerungsarm funktioniert. Steuerparameter, die in einem der Clients 216, der beispielweise als Webclient 226 reali- siert ist, gesetzt werden, werden sofort an den UI.FM Server 215 übertragen. Der UI.FM Server 215 überträgt die Steuerdaten dann unmittelbar an die ein oder mehreren weiteren Clients, z.B. an ein weiteres iPad® 217. Auf den (ein oder mehreren) weiteren Clients 217 befindet sich dann ebenfalls jeweils ein Webclient 227. Der jeweilige weitere Webclient 227 auf den entsprechenden weiteren Endgeräten 217 aktualisiert dann unmittelbar den betreffenden Parameter. Gleichzeitig informiert der UI.FM Server 215 die angeschlossene Peripherie, beispielsweise einen Renderer 229 über die Parameteraktualisierung. Gemäß einer Ausführungsform kann der Client dafür eingerichtet sein, in einem Webbrowser zu laufen. Der Vorteil ist, dass, dadurch, dass das Programm Client-seitig im Webbrowser läuft, der Anwendungsentwickler eine Kommandozeile (Bezugszeichen 228 in Fig. 2g) öffnen kann, in der er direkt Befehle direkt eingeben kann. Z.B. kann in dem Ausführungsbeispiel der Fig. 2g der Befehl„scene.sourceO.pos = " ... eingegeben werden, wodurch beispielsweise die Position von„sourceO" geändert werden kann. Das System ist also sehr gut skriptfähig. In einer Ausführungsform kann der Client z.B. dafür eingerichtet sein, dem Server die ID von zwei oder mehreren der Knoten des Datenmodells des Clients zu übertragen.
Im Folgenden wird ein System und dessen Komponenten anhand eines Beispiel-Setups erläutert, das in Fig. 3 dargestellt ist. Es versteht sich, dass jede einzelne der Komponen- ten der Fig. 3 für sich alleine realisiert werden kann, und damit für sich alleine eine Ausführungsform darstellt. Ferner versteht sich, dass allgemeine Verfahren und allgemeine Realisierungen, die in Bezug auf eine oder mehrere Komponenten der Fig. 3 beschrieben sind, auch allgemein realisiert werden können, und somit auch als allgemeines Verfahren bzw. als allgemeine Realisierung eine Ausführungsform der Erfindung darstellen.
In Fig. 3 ist zum einen ein Arbeitsplatz-PC dargestellt 350. Des Weiteren zeigt Fig. 3 ein mobiles iPad® 360. Darüber hinaus zeigt Fig. 3 einen Renderer 380 und eine Audiomatrix Einheit 390, z.B. eine DHD®-Audio Matrix Einheit. Ferner ist in Fig. 3 ein UI.FM Server 300 dargestellt.
Der Renderer 380 kann Untermodule umfassen, z.B. ein Untermodul Spatial Sound Wave 381 . Ferner kann der Renderer 380 beispielsweise eine Szene halten, z.B. ein einer Szenen Einheit 382. Ferner kann der Renderer 380 beispielsweise eine Lautsprecher Setup Einheit 383 zum Konfigurieren eines Lautsprecher-Setups umfassen. Weitere Untermodu- le können vorhanden sein. So kann z.B. ein Wav Player 384 zusätzlich vorhanden sein. Ebenso kann die Audiomatrix Einheit 390 Untermodule aufweisen. So kann z.B. die DHD®-Audiomatrix Einheit 390 beispielweise eine Koppelpunktmatrix in einem Koppelpunktmatrix Untermodul 391 umfassen. Der UI.FM Server 300 ist dafür eingerichtet, die reale Welt, wie sie beispielsweise der Renderer 380 und/oder die DHD®-Audiomatrix darstellen 390, in ein graphenförmiges, beispielsweise ein baumförmiges Datenmodell 310 abzubilden. So ist z.B. in der Darstellung des UI.FM Servers 300 in Fig. 3 rechts das Datenmodell 310 dargestellt. Oben im Datenmodell 310 ist ein Wurzelknoten ("Root") dargestellt. Unter dem Wurzelknoten ist die DHD©-Audiomatrix ("DHD®") und der Renderer dargestellt. Der Knoten DHD® im Datenmodell 310, der die DHD®-Audiomatrix 390 darstellt, weist unter sich einen Knoten „Koppelpunktmatrix" auf. Diese Repräsentation der Koppelpunktmatrix 391 wiederum weist Knotenpunkte auf, beispielsweise x0, Xi und x2. Die Darstellung des Renderers 380 im Datenmodell 310 wiederum, hat unter sich die Knoten „Lautsprecher-Setup", „Wav Player" und„Scene" als nachfolgende Knoten, die die realen Untermodule des Renderers 380 darstellen. Die Scene wiederum hat Quellen, z.B. srcO, srd und src2. Die Quellen srcO, srd , src2 ihrerseits haben wiederum Eigenschaften, z.B. eine Position pos, eine Rotation rot, on/off, mute, usw. All diese Untermodule, Attribute und Beziehungen können vom Datenmodell 310 abgebildet werden. So stellt das Datenmodell 310 einen besonders vorteilhat ausgebildeten Speicher dar.
Im Folgenden wird das Zusammenspiel von UI.FM Server 300 und Peripherie-Hardware 380, 390 erläutert:
So stellt sich eine besondere Schwierigkeit, wenn realisiert werden soll, dass, wenn z.B. die Position einer der Quellen srcO, srd , src2 im Datenmodell geändert wird, z.B. der Renderer 380 diese Information erhält und auch entsprechend in eine Änderung der Position der entsprechenden Quelle z.B. srcO, srd oder src2 umsetzt.
Um eine Lösung hierfür zu realisieren, wird eim UI.FM Server 300 ein Controller 320 ein- geführt (Controller = Steuereinheit). So gibt es z.B. zu der srcO des Datenmodells ebenfalls einen Knoten srcO in dem Controller 320 des UI.FM Servers 300. Für jede Eigenschaft der Quelle srcO, z.B. für die Eigenschaften„pos",„rot",„on/off" und„mute", weist der Controller 320 eine entsprechende Funktion zum Setzen des Wertes der Eigenschaft und eine entsprechende Funktion zum Auslesen des Wertes der Eigenschaft auf. So stellt der Controller 320 beispielsweise eine setPos(... )-Funktion zum Setzen des Wertes der Eigenschaft pos, und eine Pos(... )-Funktion zum Lesen des Wertes der Eigenschaft pos bereit. Möchte man z.B. die Position im Datenmodell ändern, so ruft man die setPos(... )~ Funktion auf. In der setPos(... )-Funktion wird die aktuelle Position angegeben, auf die die Position gesetzt werden soll, z.B. (1 , 2, 3). Durch den Aufruf der Funktion setPos(... ) im Controller 320 wird die Position pos im Datenmodell geändert. Wenn davon die Rede ist, dass ein Attribut einen Wert hat, so ist der Begriff „Wert" breit zu verstehen, und umfasst z.B. Zahlenwerte, String -Werte, also Werte, die Worte oder Sätze darstellen, Tupel von Zahlenwerten, wie (1 , 2, 3) oder z.B. Tupel von String-Werten, z.B. („Hallo Welt",„Code"), und beliebige andere Arten von Wert-Typen. Neben der bloßen Möglichkeit, Werte von Attributen (Eigenschaften) festzulegen und zu ändern, stellt die setPos(... )-Funktion zudem die Möglichkeit bereit, angeschlossene Views (Views = Sichten) zu informieren.
In einer Ausführungsform wird einem Gerät, beispielsweise dem Renderer 380 oder der DHD®-Audio Matrix 390 drahtlos oder drahtgebunden eine Nachricht zuzugesandt, die dem Gerät mitteilt, dass ein Attribut eines der Knoten des Datenmodells 310 sich geändert hat.
Hierzu ist, um z.B. den Renderer durch eine solche Nachricht zu steuern, beispielsweise ein Renderer Treiber 330 zu programmieren, der eine View darstellt, also eine Sicht auf das Datenmodell 310 und/oder deren Attribute, bzw. eine Sicht auf die Controllerstruktur 320 darstellt. Durch derartige Views kann die Peripherie, z.B. der Renderer, entsprechend gesteuert werden. Beispielsweise kann sich der Renderer-Treiber 330 des UI.FM Servers 300 bei dem Knoten srcO des Controllers 320 des UI.FM Servers 300 als View registrieren. Der Renderer- Treiber wird hierdurch eine Sicht (View) auf den srcO Knoten des Controllers 320. Setzt man nun die Position im Datenmodell durch Aufruf von src0.setPos(... )-Funktion des Controllers 320 des UI.FM Servers 300, so wird gleichzeitig die View 330 (also der Renderer Treiber 330) entsprechend unterrichtet.
Auf eine solche Unterrichtung hin, lädt der Renderer-Treiber 330 dann die Eigenschaft pos der srcO, (also Position der Quelle srcO), die aktualisiert wurde, aus dem Datenmodell 310. Die Eigenschaft kann dem Renderer-Treiber 330 aber auch im Rahmen der Unter- richtung mitgeteilt werden. Dadurch entfällt der Zugriff auf das Datenmodell.
Darüber hinaus generiert der Renderer-Treiber 330 eine Protokollnachricht und schickt diese Protokollnachricht an den Renderer 380. Beispielsweise kann es sich bei der Protokollnachricht um eine OSC-Kontrollnachricht (OSC = Open Sound Control)-Nachricht handeln. Über den Renderer-Treiber 330 hinaus, oder alternativ zum Renderer-Treiber 330, kann der UI.FM Server 300 weitere Treiber umfassen, die z.B. auch auf die Quelle srcO des Controllers 320 registriert sind, wobei diese weiteren oder alternativen Views aber ein anderes Verhalten aufweisen. Wiederum wird beispielsweise bei Ändern der Eigenschaft pos der srcO (also der Position der srcO) das Datenmodell geändert und alle angeschlossene (also entsprechend registrierten) Treiber werden benachrichtigt. Die angeschlossenen Treiber generieren entsprechende Protokollnachrichten, die an die entsprechende Hardware-Peripherie übertragen werden. In der Hardware-Peripherie werden dann entsprechende Änderungen vorgenommen.
Auch der umgekehrte Weg der Datenübermittlung und Aktualisierung ist möglich: Beispielsweise kann ein Prozess, z.B. im Renderer 380, die Position z.B. der srcO ändern. In diesem Fall sendet der Renderer 380 eine Protokollnachricht an den entsprechenden Renderer-Treiber 330. Der Renderer-Treiber 330 wird durch eine solche Nachricht unter- richtet, dass sich die entsprechende Position geändert, er ruft die setPos(... )-Funktion der srcO des Controllers 320 auf, und der Wert der Eigenschaft pos der srcO im Datenmodell 310 wird daraufhin geändert.
Um zu vermeiden, dass der Renderer-Treiber 330 von einer Änderung der Position der srcO informiert wird, die er selbst veranlasst hat (unter Umständen, aber nicht notwendigerweise, Gefahr einer Endlosschleife), kann der Renderer-Treiber 330 des UI.FM Servers 300 festlegen, dass er von einer Änderung der Position der srcO, z.B. einer Änderung, die er selbst veranlasst hat, nicht informiert werden möchte. Analog können im UI.FM Server 300 weitere Treiber, z.B. ein Renderer-Treiber z.B. für die DHD®-Audio Matrix Einheit 390 realisiert werden.
Im Folgenden werden weitere Eigenschaften des Controllers 320 des UI.FM Servers 300 beschrieben.
Es sollte beachtet werden, dass nicht nur die Quelle srcO, sondern auch die weiteren Quellen srd und src2 sowie die Scene vom Controller 320 umfasst sind. Mit anderen Worten gibt es zu jedem Knoten im Datenmodell 310 eine Controller-Subeinheit. Dies ist eine wichtige Eigenschaft des UI.FM Servers 300. So ergibt sich schließlich neben der Datenmodell-Hierarchie 310, die eine Baumstruktur hat, eine Controller- ^
Hierarchie 320, die ebenfalls eine Baumstruktur analog hierzu hat. Diese Baumstruktur des Controllers 320 sieht dann ebenso aus, wie die Baumstruktur der Datenmodell- Hierarchie 310. Gemäß Ausführungsformen kann die Datenmodell-Hierarchie 310 des UI.FM Servers 300 vom Nutzer definiert werden. Beispielsweise kann die Datenmodell-Hierarchie 310 des UI.FM Servers 300 vom Nutzer vollständig definiert werden. Beispielsweise kann entweder aus der Datenmodell-Hierarchie 310 die Controller-Hierarchie 320 erzeugt werden, oder umgekehrt kann auch aus der Controller-Hierarchie 320 die Datenmodell-Hierarchie 310 generiert werden. In einer bevorzugten Ausführungsform wird die Controller- Hierarchie 320 definiert und die Datenmodell-Hierarchie 310 daraus abgeleitet.
So ist also eine besondere Eigenschaft des UI.FM Servers 300, dass zwei parallele Hierarchien, nämlich die Controller-Hierarchie 320 und die Datenmodell-Hierarchie 310 ne- beneinander existieren und miteinander verknüpft sind. So weist jeder Knoten in der Controller-Hierarchie 320 eine entsprechende Referenz auf den entsprechenden Knoten in der Datenmodell-Hierarchie 310 auf. Beispielsweise kann eine Referenz zwischen dem Root-Knoten der Controller-Hierarchie 320 auf den Root-Knoten der Datenmodell- Hierarchie 310 existieren. Es existiert also eine Verbindung zwischen der Controller- so- wie Datenmodell-Hierarchie 310 und der angeschlossenen Hardware-Peripherie.
Im Folgenden wird die Verbindung zwischen den Steuergeräten und dem UI.FM Server 300 bzw. zwischen den Steuergeräten und der Controller-Hierarchie 320 bzw. der Datenmodell-Hierarchie 310 des UI.FM Servers 300 beschrieben.
Im Stand der Technik wird das Datenmodell 310 in einer Datenbank organisiert. Im Stand der Technik sendet ferner der Client Anfragen an die Datenbank, erhält Antworten von der Datenbank zurück und kann mit den erhaltenen Daten arbeiten. Ferner kann gemäß dem Stand der Technik sich der Client auf Knoten des Datenmodells 310 registrieren und bekommt Nachrichten, wenn sich der Knoten des Datenmodells ändert. Das Datenmodell selbst kann beispielsweise in einer Datenbank gespeichert sein. Die Organisation des Datenmodells 310 und des Handlings, wie das Datenmodell 310 beispielsweise zu aktualisieren ist, wird dabei jedoch im Stand der Technik vollständig dem Anwendungsentwickler überlassen. Gemäß einer Ausführungsform wird ein Mechanismus bereitgestellt, der dem Anwender sehr viel Arbeit abnimmt. Dieser Mechanismus wird im Folgenden erläutert.
Beim Start eines Clients, z.B. des Arbeitsplatz-PCs 350, meldet sich der Client bei dem UI.FM Server 300 an (siehe Punkt (1 ) zwischen Arbeitsplatz-PC 350 und UI.FM Server 300 in Fig. 3). So erfolgt zunächst eine Anmeldung durch den Client beim UI.FM Server 300.
Der UI.FM Server 300 überträgt dann die Controller-Hierarchie 320 an den Client (siehe Punkt (2) zwischen Arbeitsplatz-PC 350 und UI.FM Server 300 in Fig. 3). Mit der Controller-Hierarchie 320 wird auch die Datenmodell-Hierarchie 310 übertragen. Dies kann implizit dadurch erfolgen, dass der Client beispielsweise die Datenmodell-Hierarchie 310 aus der Controller-Hierarchie 320 ableitet oder aber, die Datenmodell-Hierarchie 310 wird explizit neben der Controller-Hierarchie 320 übertragen.
Durch Übertragung der Controller-Hierarchie 320 (und eventuell zusätzlich der Datenmodell-Hierarchie 310) liegt beim Client dieselbe Hierarchie wie auf dem UI.FM Server 300 vor. D.h. beim Client, z.B. dem Arbeitsplatz-PC 350 liegen die Controller-Hierarchie 352 und das Datenmodell 351 vor.
Die Übertragung von Controller-Hierarchie 320 und Datenmodell-Hierarchie 310 kann auch für weitere Clients durchgeführt werden, wie, z.B. neben dem Arbeitsplatz-PC 350, auch für z.B. ein iPad® 360, wenn sich diese beim UI.FM Server 300 anmelden. So weist das iPad® 360 in Fig. 3 eine Controller-Hierarchie 362 und ein Datenmodell 361 auf, ebenso wie der Arbeitsplatz-PC in Fig. 3.
Die Controller-Hierarchie 352 des Arbeitsplatz-PCs 350 weist eine„root" (Wurzel) auf und darüber hinaus, identisch zu der Controller-Hierarchie des UI.FM-Servers 300, die der Wurzel„root" nachgeordnete Knoten, z.B. unter anderem srcO und dessen nachgeordnete Knoten. Gleiches gilt für das Datenmodell in den Clients, z.B. für das Datenmodell des Arbeitsplatz-PCs 350 und für das Datenmodell des iPads® 360. Auch in deren Controller- Hierarchien 352, 362 finden sich beispielsweise die Quelle srcO.
In jedem Client, der sich beim UI.FM Server 300 anmeldet, wird initial die gleiche Daten- modellstruktur 351 , 361 wie im UI.FM Server eingerichtet. Dies gilt beispielsweise für die Controller-Hierarchie 362 und das Datenmodell 361 des iPads® 360. Somit sind sämtliche Controller-Hierarchien 352, 362 und Datenmodelle 351 , 361 der Clients 350, 360 mit dem Datenmodell 310, und der Controller-Hierarchie 320 des UI.FM Servers 300 abgeglichen.
Des Weiteren erfolgt die eigentliche Datenübertragung vom Server zum Client (siehe Punkt (3) zwischen Arbeitsplatz-PC 350 und UI.FM Server 300 in Fig. 3). So muss vom Server 300 zum Client 350 eben nicht nur die hierarchische Struktur von Controller- Hierarchie 320 und Datenmodell 310 übertragen werden, sondern eben gerade auch die eigentlichen Daten, beispielsweise also, z.B. welche Werte die Attribute im Datenmodell jeweils haben (also zum Beispiel welche/n Wert/e die Position pos der Quellen srcO, srd , src2 jeweils hat, usw.
Gemäß Ausführungsformen ist jedem Knoten der Controller-Hierarchie 320 des UI.FM Servers 300 eine ID zugeordnet. Die ID dient dazu, Knoten schnell zu adressieren. So müsste aufgrund der graphenförmigen Struktur der Controller-Hierarchie 320 und des Datenmodells 310 normalerweise ein kompletter Pfad angegeben werden, z.B. „root/Renderer/Scene/srcO", um ein bestimmtes Element im Datenmodell bzw. in der Controller-Hierarchie zu adressieren. Dadurch, dass nun jedem Knoten eine ID zugewiesen wird, hat man jedoch einen kurzen Identifikator für jeden der Knoten und kann den jeweiligen Knoten somit durch seinen Identifikator adressieren. Bildlich gesprochen liegt also für jeden Knoten eine kurze "Telefonnummer" vor, die statt der Angabe eines langen Pfades verwendet werden kann. Beispielsweise hat in der Controller-Hierarchie 320 des UI.FM Servers 300 der Knoten„root" die ID 0, der Knoten „DHD®" hat die ID 1 , der Knoten „Renderer" hat die ID 2, der Knoten„LSSetups" hat die ID 3, der Knoten„WavPl." (Wav Player) hat die ID 4, der Knoten„Koppelpunktmatrix" hat die ID 5, der Knoten„Scene" hat die ID 6, der Knoten„srcO" hat die ID 7, der Knoten„srd " hat die ID 8, usw.
Entsprechend werden die IDs vom UI.FM Server 300 zum Client 350 übertragen (siehe Punkt (4) zwischen Arbeitsplatz-PC 350 und UI.FM Server 300 in Fig. 3) und in das Datenmodell 351 und in die Controller-Hierarchie 352 des Clients 350 eingeschrieben, zum Beispiel in das Datenmodell 351 und in die Controller-Hierarchie 352 des Arbeitsplatz- PCs Clients 350.
Es folgt also nach der Datenübertragung die I D-Übertragung. D.h., es wird ein I D-Baum generiert, der die gleiche Struktur wie die Controller-Hierarchie hat. Unterschied ist, dass in den einzelnen Knoten die IDs stehen. Die IDs werden dann in die entsprechenden Knoten geschrieben. Bei den obigen Ausführungen versteht es sich, dass die Punkte (2), (3) und (4) bei der Initialisierung des Clients 350 beim UI.FM Server 300 in beliebiger Reihenfolge ausgeführt werden können.
Im Folgenden wird ein Beispiel gemäß einer Ausführungsform erläutert, bei dem eine (Schall)-Quelle mittels eines Arbeitsplatz-PCs 350 umpositioniert wird. Mit anderen Worten wird beispielsweise eine Web-Applikation, die auf einem Arbeitsplatz-PC 350 läuft, dazu verwendet, die räumliche Position einer, z.B. virtuellen, (Schall)-Quelie umzupositio- nieren. So kann zum Beispiel ein Szenario vorliegen, bei dem z.B. der jeweilige Klang dreier Schallquellen in drei separaten Audiosignalen aufgenommen wird.
Beim späteren Mischen dieser drei Audiosignale zu einem Gesamtsignal werden dann die drei Audiosignale entsprechend der virtuellen Position der Schallquelle gemischt. Befindet sich etwa die virtuelle Position einer ersten Schallquelle weit entfernt von der angenommenen Zuhörer-Position, so ist der Anteil ihres Audiosignals am Gesamtsignal in der Regel geringer als der Anteil des Audiosignals einer zweiten Schallquelle, deren virtuelle Position sich nahe an der angenommenen Zuhörer-Position befindet. Oder aber es werden aus den z.B. drei Audiosignalen der drei Quellen eine Mehrzahl von Lautsprechersignalen erzeugt. Befindet sich etwa die virtuelle Position einer ersten Schallquelle weit entfernt von der (angenommenen) Position des jeweils betrachteten Lautsprechers, so ist der Anteil ihres Audiosignals am Lautsprechersignal für diesen Lautsprecher in der Regel geringer als der Anteil des Audiosignals einer zweiten Schallquelle, deren virtuelle Position sich nahe an der (angenommenen) Lautsprecher-Position befindet.
Mit der angesprochenen Web-Applikation auf dem Arbeitsplatz-PC 350 können also die (virtuellen) Positionen der (Schall-)quellen eingestellt werden, wodurch vom Arbeitsplatz- PC 350 aus gesteuert werden kann, wie der Renderer 380 die einzelnen Audiosignale der Quellen zu einem Gesamtsignal, oder zu einer Mehrzahl einzelner Lautsprechersignale mischt.
Um die jeweilige Quelle bewegen zu können, wird beim Client (z.B. dem Arbeitsplatz-PC 350) eine View (Sicht) 353 eingerichtet. Hierfür umfasst der Arbeitsplatz-PC 350 diese View 353. In der View 353 des Arbeitsplatz-PCs 350 in Fig. 3 ist eine Quelle 358 dargestellt. Die Quelle 358 wird z.B. durch ein Touchscreen angezeigt, kann mit dem Finger berührt und z.B. durch Ziehen bewegt werden. Wenn diese Bewegung passiert, wird beispielsweise ein Event ausgelöst.
Eine Bewegung dieser Quelle durch den Anwender führt dabei beispielsweise dazu, dass die Quelle in eine neue Position bewegt wird, z.B. in die Position (x, y, z) = (8, 9, 10). Diese Position wird über die Funktion setPos(... ), die Teil der Controller-Hierarchie ist, ent- sprechend an der Quelle srcO gesetzt. Der Controller 352 des Clients 350 umfasst gleichzeitig einen Update-Mechanismus, der bereits sinngemäß im Zusammenhang mit dem UI.FM Server 300 besprochen wurde. Wie auch der UI.FM Server 300 hat also auch der Arbeitsplatz-PC 350 eine View 353. Die setPos(... )-Funktion, die bei Bewegen der Quelle aufgerufen wird, setzt eine Position im Datenmodell des Arbeitsplatz-PCs.
Die Positionsänderung der Quelle im Datenmodell 351 des Arbeitsplatz-PCs 350 wird darauffolgend an den UI.FM Server 300 übertragen. Zur Datenübertragung wird gemäß Ausführungsformen die oben beschriebene ID verwendet. Dabei informiert beispielsweise eine Einheit des Controllers des PCs 350, die für die srcO zuständig ist, einen Synchroni- zer (Synchronisator) 354 des Arbeitsplatz-PCs 350.
Den Synchronizer 354 kann man sich dabei als eine Art View vorstellen, der informiert wird, wenn sich Daten ändern. So verwendet der Synchronizer 354 die entsprechende ID und generiert eine Nachricht, beispielsweise, dass sich in dem Knoten mit der ID 7 die Position geändert hat, und was der Wert der entsprechenden Position ist (z.B. (8, 9, 10)). Diese vom Synchronizer 354 generierte Aktualisierungsmitteilung, z.B. eine Nachricht "7: Pos: (8, 9, 10)" wird zum UI.FM Server 300 übertragen.
So gibt es auch auf dem UI.FM Server 300 einen Synchronizer 340, der die durch die Aktualisierungsmitteilung übermittelte, neue Position der srcO empfängt. Der Synchronizer 340 des UI. FM Servers 300 übermittelt die empfangene Position an den Knoten mit der entsprechenden ID, also hier, z.B. dem Knoten mit der ID 7.
Der Synchronizer 340 des UI.FM Servers 300 ermittelt daraufhin mittels der ID den ent- sprechenden Knoten des Controllers 320. So ermittelt der Synchronizer 340 beispielswei- se, dass es sich bei dem Knoten mit der ID 7 um den Knoten srcO handelt, und ruft die setPos(... ) Funktion des srcO-Controller-Knotens auf.
Die setPos(... )-Funktion trägt die Position in das Datenmodell 310 des UI.FM Servers 300 ein, und unterrichtet darüber hinaus den Renderer-Treiber 330 über die neue Position. Der Renderer-Treiber 330 seinerseits übergibt die neue Position an den Renderer 330.
Was den Synchronizer 300 des UI.FM Servers 300 betrifft, wird die Nachricht vom Arbeitsplatz-PC 350 wird von Synchronizer 340 mit minimaler zeitlicher Verzögerung an alle weiteren Clients weitergeleitet, z.B. an das iPad® 360. Das iPad® 360 weist dieselbe Controller-Hierarchie 362 und Datenstruktur 361 mit denselben IDs auf wie der UI.FM Server 300. Ferner umfasst das iPad® 360 zudem einen Synchronizer 364. Der Synchronizer 364 des iPads® 360 trägt diese ID genauso in sein Datenmodell 361 ein. Wenn das iPad® Views aufweist (in Fig. 3 z.B. die View 363), überträgt der Controller 362 die Infor- mation vom Synchronizer 364 über die geänderte Position nicht nur in das Datenmodell
361 des iPads® 360, sondern zusätzlich auch in die View 363 des iPads® 360. Die View 363 des iPads® 360 wird also aktualisiert.
Statt mittels des Arbeitsplatz-PCs 350 kann ein Nutzer analog zu der obigen Beschrei- bung auch auf dem iPad® 360 eine Quelle bewegen. Die Information würde analog über die setPos(... )-Funktion des Controllers 362 des iPads® 360 geschrieben. Der Controller
362 des iPads® 360 würde das Datenmodell 361 des iPads® 360 aktualisieren. Ferner würde der Controller 362 des iPads® 360 den Synchronizer 364 des iPads® 360 informieren. Der Synchronizer 364 des iPads® 360 würde diese Information in einer Aktualisie- rungsmitteilung zum Synchronizer 340 des UI.FM Servers 360 übertragen. Der Synchronizer 364 des UI.FM Servers 360 würde die in der Aktualisierungsmitteilung enthaltene Information unmittelbar zu Synchronizern anderer Clients weiterleiten, z.B. zum Synchronizer 354 des Arbeitsplatz-PCs 350. Ferner würde der Synchronizer 340 des UI.FM Servers 300 diese Information auch im Controller 320 des Servers 300 setzen. Der Controller 320 des UI.FM Servers 300 würde die Position von srcO im Datenmodell 310 des Servers 300 aktualisieren. Ferner würde der Controller 320 des Servers 300 den entsprechenden Treiber des Servers über die Positionsänderung unterrichten. Dieser Treiber, also hier, der Renderer-Treiber 330, würde den Renderer 380 entsprechend informieren. Im Folgenden sollen nun besondere Vorteile der bereitgestellten Konzepte gemäß Ausführungsformen dargestellt werden. Gemäß Ausführungsformen, ist der Code, der die oben beschriebene Funktionalität realisiert dazu geeignet, im Webbrowser zu laufen. In einer Ausführungsform kann man beispielsweise über den Browser die Serverseite aufrufen, z.B. über eine URL. Der Code für den Arbeitsplatz-PC 350 wird live übertragen und wird dann auf dem Arbeitsplatz-PC 350 sofort ausgeführt. Hierdurch entfallen aufwendige Installationsprozesse.
Ein weiterer großer Vorteil betrifft die Dokumentation. Dadurch, dass die komplette Datenmodell-Hierarchie an den Client, z.B. an den Arbeitsplatz-PC 350 übertragen wird, liegt dort eine semantisch intuitiv sehr verständliche Systembeschreibung vor. Auf diese Systembeschreibung kann auf dem Client 350 einfach zugegriffen werden. Ferner liegt die Systembeschreibung wegen ihrer hierarchisch strukturierten Baumstruktur dann auch in verständlicher Form vor. Hierdurch entfällt Dokumentationsaufwand. Ausführungsformen stellen Mittel zur dynamischen Codegenerierung bereit, z.B. die dynamische Erzeugung von ausführbarem Code. Das System ist Web-basiert, wobei mithilfe von Funktionen andere Funktionen generiert werden können. Diese anderen Funktionen, die geniert wurden, sind dann ausführbar. Das bedeutet, dass der Anwender nur minimal die Controller-Hierarchie definieren muss, und sämtlicher anderer Code zum Synchroni- sieren zum Zuweisen von IDs usw. automatisch generiert werden kann.
Z.B. kann der Anwender einfach definieren, dass die Quelle srcO eine Eigenschaft, z.B. eine Position (x, y, z) hat, mit dem Standardwert (x, y, z) = (0, 0, 0). In Ausführungsformen ist das System dafür eingerichtet, aus dieser Information automatisch zwei Funktio- nen zu generieren, z.B. die Funktion ,,Pos()", um den Wert des Attributs pos der srcO zu lesen, d.h. um den Wert der Position der Quelle srcO zurückgeliefert zu bekommen, und die Funktion setPos(... ), um eine neuen Wert für das Attribut pos der Quelle srcO festzulegen, z.B.„setPos(8, 9, 10)", wodurch der Wert des Attributs pos auf (x, y, z) = (8, 9, 10) festgesetzt werden kann.
Indem der Anwendungsentwickler einmal die Information hinterlegt, dass z.B. ein Attribut pos mit dem Standardwert (0, 0, 0) hat, werden in Ausführungsformen automatisch die obigen beiden Funktionen generiert, und zwar für jedem der Clients, z.B. im Arbeitsplatz- PC 350, indem die Clients die Controller-Hierarchie übernehmen. Mit anderen Worten ist zum Definieren eines solchen Controllers, z.B. einer solchen Controller-Einheit des Knotens srcO, extrem wenig Information nötig. Ein weiterer Vorteil ist, dass Ausführungsformen der Erfindung einerseits einen intuitiven Zugriff und andererseits eine Zugriff auf Knoten der Datenstruktur ermöglichen, der gleichzeitig schnell ist. Ausführungsformen verbindet also sowohl die Eigenschaft der Intu- itivität als auch die Eigenschaft der Schnelligkeit, während herkömmliche Systeme normalerweise entweder intuitiv oder schnell, nicht aber beides sind.
Die Intuitivität der Datenstruktur ist vor allem wichtig für den Anwendungsentwickler. Wenn der Anwendungsentwickler eine Information im Datenmodell setzen möchte, dann muss diesem recht einfach ein Weg bereitgestellt werden, wie er z.B. an die Information der Quelle srcO herankommt.
Gemäß einer Ausführungsform generiert das System hierfür einen Befehlssatz, mit dem im Browser einzelne Knoten leicht adressierbar sind. Z.B. kann man im Browser eine Kommandozeile öffnen. In diese Kommandozeile kann der Nutzer oder Anwendungsentwickler Folgendes eingeben: "root.Renderer.Scene.src0.setXyz(8, 9, 10)". Eine solche Zeile ist hochgradig intuitiv, wenn man die entsprechende Struktur der graphenförmigen Datenstruktur kennt. Man kann also sehr leicht, d.h. intuitiv, auf Information der Datenstruktur zugreifen, Informationen laden, Informationen aktualisieren. Bei alledem wird der Dokumentationsaufwand wird sehr gering, denn die Datenstruktur ergibt sich bereits aus ihrem hierarchischen baumförmigen Aufbau.
Gemäß Ausführungsformen werden wenn die Baumstruktur einmal definiert wurde, automatisch Befehle, die z.B. in JavaScript die Punktoperatoren zwischen den Knoten ermög- liehen, generiert. So generiert in Ausführungsformen beispielsweise der Browser- bzw. die Server-Kommandozeile diese Punktoperatoren. Die Controller-Struktur ist dabei derart gestaltet, dass diese Operatoren einfach verwendet werden können.
In Ausführungsformen wird ein Pfad zu einem gewünschten Knoten also dadurch ange- geben, dass z.B. ausgehend vom Wurzelknoten oder ausgehend von einem seiner Nachfolgeknoten, die aufeinanderfolgenden Knoten bis zum gewünschten Knoten nacheinander angegeben werden, wobei aufeinanderfolgende Knoten jeweils durch einen Punkt getrennt werden. So kann beispielsweise auf den Knoten srcO z.B. durch Angabe des Pfades "root.Renderer.Scene.srcO" oder z.B. durch Angabe des Pfades „Rende- rer.Scene.srcO" zugegriffen werden (wenn beispielsweise klar ist, dass der Wurzelknoten „root" immer der erste Knoten ist). Nur einfach„srcO" zum Zugriff anzugeben, ist, wenn Knotennamen nicht eindeutig sein sollten, nicht ausreichend, denn es kann beispielsweise mehrere Knoten in einer Datenstruktur mit dem Namen„srcO" geben. Außerdem würde hierdurch die Intuitivität der Datenstruktur verlorengehen. So intuitiv die hier beschriebenen Pfade für den Anwendungsentwickler auch sind, so ineffizient sind sie, wenn solche Knoptenzugriffe sehr hochfrequent / sehr häufig ausgeführt werden.
Beispielsweise kann in einer Ausführungsform der Renderer 380 dafür eingerichtet sein, Pegeldaten zu generieren, die entsprechend über OSC Nachrichten an den Renderer- Treiber 330 des UI.FM Servers 300 übermittelt werden. Der Renderer-Treiber 330 setzt die Pegeldaten dann entsprechend in der Controller-Hierarchie 320 und damit im Datenmodell 310. Für 64 Quellen sind dies beispielsweise 64 Informationen, die z.B. 50 mal in der Sekunde aktualisiert werden, d.h. in der Sekunde sind in diesem Beispiel 3.200 Aktu- alisierungen nötig. In anderen Teilen des Systems können weitere hochfrequente Informationen regelmäßig entstehen, die abgearbeitet werden müssen. Zur Positionsaktualisierung wäre dann jedes Mal ein Pfad der Form "root.Renderer.Scene.src0.posXyz(8, 9, 10)" zu adressieren. Ein solcher Befehl würde dabei dann jedes Mal in einer Nachricht vom Client, z.B. dem Arbeitsplatz-PC 350, zum UI.FM Server 300 geschickt werden. Dies ist jedoch ineffizient.
Zur effizienteren Realisierung werden die oben bereits eingeführten IDs verwendet. Dadurch, dass jeder Knoten eine ID besitzt, die eine Art Hash-Wert darstellen, wobei die ID als kurze Adresse fungiert, kann alternativ zu dem langen Pfad, der für den menschli- chen Entwickler gut ist, auch die ID verwendet werden. Ein Beispiel wäre z.B. der Befehl „node[7].setXyz(8, 9, 10)". Hierdurch wird die Funktion ,,setXyz(... )" des Knotens mit der ID7 aufgerufen, also die setXyz(... ) Funktion des Knotens srcO.
Die hier verwendeten IDs stellen somit die Möglichkeit bereit, Elemente sehr kurz zu ad- ressieren, was die Synchronisation effizienter gestalten kann. Wenn bestimmte Informationen sich häufig ändern, z.B. wenn eine Quelle bewegt wird, was sehr viele Aktualisierungen nach sich zieht, wird nicht der oben beschriebene lange Pfad vom Client 350 zum UI.FM Server 300 übertragen, sondern die entsprechende ID. Dies kann auch beispielsweise durch eine kurze Instruktion der Form "7: pos: [8, 9, 10]" erfolgen, die beispielswei- se besagt, dass das der Wert des Attributs„pos" des Knoten mit der ID 7 (also srcO) zu (x, y, z) = (8, 9, 10) geändert werden soll. Die Möglichkeit, Elemente sehr kurz zu adressieren, kann vorteilhaft sein, wenn bestimmte Informationen sich häufig ändern, und ist z.B. bei der Synchronisation hilfreich. So zieht z.B. das Bewegen der Quelle 358 beispielsweise sehr viele Positions-Aktualisierungen nach sich. In diesem Fall wird nicht der lange Pfad vom Client zum Server übertragen, sondern die ID. Z.B. durch Datennachrichten der Form„7: pos: [8, 9, 10]" hat man sehr kurze Datennachrichten. Dies sind dann sehr effizient an den UI.FM Server 300 und alle Clients, z.B. das iPad® 360 übertragbar. Somit hat der lange Pfad den Vorteil, dass er intuitiv ist, insbesondere für den menschlichen Entwickler, während der kurze Pfad, also z.B.„7: pos: [8, 9, 10]", den Vorteil hat, für das System sehr gut verarbeitbar zu sein. Ein Datenübermittlung mithilfe der ID sehr schnell. Ausführungsformen vereinen beide Vorteile, indem sowohl der lange Pfad, als auch die kurze ID Adressierung bereitgestellt wird.
In Ausführungsformen werden beide Adressierungsmöglichkeiten automatisiert vom Sys- tem erzeugt wenn die Controller-Hierarchie und/oder die Datenstruktur definiert wird.
Nachfolgend werden wesentliche Fähigkeiten des Systems beschrieben.
Ausführungsformen weisen Multi-Client-Fähigkeit auf. Multi-Client-Fähigkeit heißt, dass man ein und dieselbe Applikation auf mehreren Clients startet. Beispielsweise kann dieselbe Applikation auf dem Arbeitsplatz-PC 350, auf dem iPad® 360, und beispielsweise auf weiteren Geräten gestartet werden. Jede Änderung, die auf einem Client, z.B. dem Arbeitsplatz-PC 350 getätigt wird, wird an alle anderen Clients 360 übertragen. D.h., die Applikation ist auf mehreren Bildschirmen gleichzeitig präsent und auch gleichzeitig sicht- bar.
In einem weiteren Anwendungsbeispiel kann ein Teil der Anwendung auf einem ersten Client dargestellt werden, z.B. dem Arbeitsplatz-PC 350, während andere Teile der Applikation beispielsweise auf einem zweiten Client, z.B. einem iPad®, 360 dargestellt werden können. So kann z.B. mit der linken Hand eine Quelle auf dem iPad® 360 stumm geschaltet werden, während mit der rechten Hand auf dem Arbeitsplatz-PC 350 eine Klangquelle positioniert wird. Eine solche Funktionalität kann als Multi Device Fähigkeit bezeichnet werden. Vorteilhaft ist des Weiteren eine Web-basierte Realisierung gemäß Ausführungsformen. Ein weiteres wesentliches Merkmal von Ausführungsformen ist deren Fähigkeit, Anfragen verzögerungsarm auszuführen. Wenn z.B. eine Quelle 358 in einem Browser eines Clients, z.B. des Arbeitsplatz-PCs 350 bewegt wird, dann wird diese Quellen-Bewegung fast ohne Zeitverzögerung an die anderen Clients, z.B. das iPad® 360 übertragen, und ist dort fast ohne Zeitverzögerung sichtbar. Das gleiche gilt für Pegeldaten, die z.B. vom Rende- rer 380 kommen. Es zeigt sich also, dass das System so schnell ist, dass es auch sehr hochfrequente Parameteränderungen verarbeiten kann.
Wie bereits angesprochen, hat der Controller 320 verschiedene Aufgaben, wobei eine Aufgabe darin besteht, das Datenmodell 310 zu ändern, wobei eine weitere Aufgabe darin liegt, die Treiber, z.B. den Renderer-Treiber 330, zu informieren, um des Weiteren die Synchronisation durch den Synchronizer 340 auszulösen.
Ferner weist der Controller 320, der in UI.FM 300 implementiert ist, noch eine weitere Fähigkeit auf, nämlich die Fähigkeit, Datenänderungen über die Zeit aufzuzeichnen. D.h. wenn man eine Quelle bewegt 358, kann diese Änderung vom Controller 320 aufgezeichnet werden und später wiedergegeben werden. Dies kann z.B. dazu verwendet werden, Quellbewegungen aufzuzeichnen. Entsprechend können diese aufgezeichneten Quellbewegungen später wiedergegeben bzw. abgespielt werden. Man kann dies als Automati- sierbarkeit beizeichnen.
Weiter unten wird noch beschrieben, wie die Controller-Hierarchie und das Datenmodell, d.h. die baumförmige Struktur ganz konkret aussieht. Ausführungsformen weisen die Eigenschaft der automatischen Codegenerierung auf, dass also die Lese- und Schreib-Funktionen zum entsprechenden Zugriff Knotenattribute automatisch generiert werden. Man spricht hier von dynamischer Codegenerierung.
In Ausführungsformen kann auch der Synchronizer-Code automatisch generiert werden. Nicht nur die Zugriffsroutinen, also die Lese- und Schrieb-Funktionen, sondern auch die Synchronisationsfunktionen können automatisch generiert werden.
Ferner weisen Ausführungsformen die Eigenschaft auf, dass aus der Controller-Definition und/oder aus der Definition der Datenstruktur automatisch der Code generiert werden kann, der die Views 363 benachrichtigt. Im Folgenden wird die Funktionalität von Ausführungsformen erläutert. So wird in einem beispielhaften Anwendungsfall die Beschallungstechnik eines Stadions eingerichtet werden. Zur Einrichtung der Beschallungstechnik können z.B. vier Personen beteiligt sein, also z.B. vier Toningenieure. Jeder der Toningenieure kann z.B. für einen Flügel des Stadions zuständig sein, z.B. einer für den Nordflügel, einer für den Südflügel, einer für den Ostflügel und einer für den Westflügel. Jeder der Toningenieure hat zudem beispielsweise ein iPad® bei sich. Mit diesem iPad® kann dann das zentrale Mischpult und die zentrale Soundeinrichtung gesteuert werden. Eine erste Person beginnt dann den Sound für seine Position optimal einzustellen. Danach beginnt die zweite Person den Klang einzustellen. Die zweite Person benutzt ebenfalls ein iPad®. Dann geht die dritte Person, dann die vierte Person ebenso vor. Der Sound kann auch gleichzeitig eingestellt werden. So kann jeder der Toningenieure gleichzeitig hören, welche Auswirkungen die Einstellungen der anderen Toningenieure haben. Gleichzeitig kann der jeweilige Toningenieure, der eine Änderung wahrnimmt, diese Änderung auch rückgängig machen oder anderweitig eingreifen. D.h., in diesem Beispiel können die vier Toningenieure zu viert gleichzeitig eine optimale Beschallungssituation erreichen. Dies wird dadurch erreicht, dass mit vier unterschiedlichen Mobilgeräten eine zentrale Applikation gesteuert wird. Um solche Applikatio- nen zu realisieren wird UI.FM bereitgestellt, das z.B. als Software Framework implementiert sein kann. UI.FM bezeichnet das sogenannte User Interface Framework. Dieses Framework erlaubt es, solche Applikationen viel schneller und einfacher zu implementieren als dies bisher möglich ist. Alle Applikationen, die von UI.FM entwickelt wurden, sind von Natur aus Multi-Client-fähig. So sieht man z.B. in den Fig. 4a eine Applikation, die auf ein iPad® 410 geladen ist Cli- entseitig ist die Applikation noch auf einen Arbeitsplatz-PC 420 geladen. Ferner ist die Applikation noch auf einen weiteren Client, einen weiteren Arbeitsplatz-PC 430 geladen. Insgesamt liegt die Applikation nun also auf drei verschiedenen Clients 410, 420, 430 vor.
Betrachtet man nun Fig. 4b, so kann auf diesem iPad® z.B. eine der acht Quellen 41 1 , 412, 413, 414, 415, 416, 417, 418 berührt und bewegt werden. Das Berühren und Bewegen einer der Quellen, z.B. mit einem Finger 419, ist beispielsweise in Fig. 4c gezeigt. Gleichzeitig mit dem Bewegen einer Quelle in einem Client 410 bewegt sich die Quelle in allen anderen Clients 420, 430 mit. Man steuert also mit dem Finger 419 auf einem Client 410 eine Quelle 416 und diese Quellpositionsänderung der Quelle 416 wird unmittelbar auf alle anderen Applikationen der anderen Clients 420, 430 übertragen. Statt mit dem Finger 419 kann die Quelle 416 auch mit einer Maus bzw. durch deren Mauszeiger bewegt werden. So kann die Quelle z.B. mit einer Maus auf einem PC bewegt werden und die entsprechende Quelle auf den anderen Clients, z.B. auf einem anderen iPad®, bewegt sich entsprechend mit. D.h. mehrere Leute können gleichzeitig mit einer Applikation arbeiten, und dort die Parameter ändern, wobei die geänderten Parameter werden an die anderen Endgeräte übertragen werden.
Ausführungsformen weisen die Möglichkeit auf, Anwendungen auf mehrere Endgeräte so zu verteilen, dass ein Arbeitsplatz erweitert wird. So ist z.B. in Fig. 4d einerseits der Arbeitsplatz-PC 420 im Hintergrund zu sehen, auf dem die acht verschiedenen Quellen 41 1 , 412, 413, 414, 415, 416, 417, 418 dargestellt sind.
Gleichzeitig wurde der Arbeitsplatz um das iPad® 410 im Vordergrund erweitert. Beide Geräte 410, 420 sind voneinander getrennt. Auf beiden Geräten 410, 420 laufen unterschiedlichen Client-Applikationen. Auf dem PC-Arbeitsplatz 420 befindet sich ein Source Positioning Canvas, mittels dem man die Quellen 41 1 , 412, 413, 414, 415, 416, 417, 418 bewegen kann. Auf dem iPad® 410 befindet sich eine Mute Matrix (Stummschalt Matrix), mit der man einzelne oder alle Quellen 41 1 , 412, 413, 414, 415, 416, 417, 418 stummschalten kann.
So kann mit zwei Händen gleichzeitig der Positioning Canvas und die Mute-Matrix ge- steuert werden. So können z.B. mit der linken Hand ein oder mehrere Quellen stummgeschaltet werden, wie in Fig. 4e zu sehen ist, während die rechte Hand dazu verwendet werden kann, Quellen zu steuern und zu positionieren. Somit hat man einen PC- Arbeitsplatz 420, um eine zweite Applikation, die auf einem mobilen Endgerät 410 läuft, erweitert, und beide arbeiten perfekt zusammen für einen einzelnen Nutzer.
Gemäß Ausführungsformen ist UI.FM Web-basiert. Fig. 5a zeigt die Serverseite von UI.FM gemäß einer Ausführungsform. Nach Anklicken von "Apps" gelangt man auf die App-Seite, dargestellt in Fig. 5b. Beispielsweise kann die Applikation „ProductionApp" angeklickt werden, die auf dem UI.FM Server läuft, wodurch die„ProductionApp" geöffnet wird, wie in Fig. 5c dargestellt. Nun kann mit dieser Applikation („App" - Anwendung) gearbeitet werden. UI.FM läuft verzögerungsarm. Alles was in einer Applikation auf einem Client getan wird, wird schnellstmöglich an die entsprechende Applikation auf dem anderen Client übertragen. So können Realtime-Daten im Webbrowser angezeigt werden. Beispielsweise sind in Fig. 6a bis zu 32 Quellen anzeigbar und steuerbar. Die Pegel dieser bis zu 32 Quellen werden mit 25 Bildern pro Sekunde aktualisiert. Genauso werden auch die bis zu 32 Quellpositionen aktualisiert, und zwar in kürzester Zeit.
In einer Ausführungsform kann die Änderung eines Attributs eines der Knoten des Da- tenmodells aufgezeichnet werden. So sind in UI.FM sind grundsätzlich sämtliche Parameter automatisierbar. Beispielsweise wird in Fig. 6b ein Szenario gezeigt, bei dem man eine Aufzeichnung starten kann, eine Quelle bewegen kann, die Aufzeichnung stoppen kann, und dann die Aufzeichnung starten kann, so dass die Quellbewegung, die zuvor vollzogen wurde, nun abgespielt wird. Ausführungsformen ermöglichen somit das Aufzeichnen von Parametern.
In Ausführungsformen von UI.FM kann der Anwendungsentwickler ein graphenförmiges, z.B. baumförmiges Datenmodell definieren, wie es z.B. in Fig. 7a dargestellt wird. In Fig. 7a ist ein beispielhaftes Datenmodell einer Beispielanwendung dargestellt. Der Wurzelknoten ist in Fig. 7a nicht als„root" sondern als "ssc" bezeichnet, an dessen Bedeutung als Wurzelknoten jedoch, ändert sich nichts. Es existieren verschiedene Unterknoten, wie z.B. "clock", "demoPlayer" und "audio". Unter dem Knoten "audio" existieren verschiedene Unterknoten, z.B. der Unterknoten "scenes". Der Knoten "scenes" umfasst den Unterknoten "sceneO". Der Unterknoten "sceneO" wiederum umfasst die Unterknoten "soloManager", "manage3d" und "sources". Unter dem Knoten "sources" liegt die Quelle "srcO". Des Weiteren liegen unter dem Knoten "audio" die Unterknoten "micSetups", "IsSetups" und "virtualLsSetups". Insgesamt werden also die Daten, die im System vorkommen, graphenförmig, z.B. baum- förmig strukturiert.
Fig. 7b und 7c zeigen ein Beispiel, wie ein Datenmodell ganz konkret formuliert wird. Konkret handelt es sich um die Definition einer Quelle. Hier definiert man zunächst die Attribu- te des Objekts, in einer Quelle z.B. die Position, die Rotation, ob sie gebraucht wird (isUsed), ob es die Quelle ausgewählt ist (isSelected), ob die Quelle gesperrt ist (isLocked), ob die Quelle stummgeschaltet ist (isMuted), oder beispielsweise ob die Quelle eine 3D Quelle ist, usw.
Jedem dieser Attribute wird dabei ein Standardwert zugeordnet. Der Standardwert wird zugleich verwendet, um den Datentyp des Attributs zu bestimmen. Zudem existieren verschiedene Optionen, die spezifizieren, welche dieser Attribute automatisiert werden sollen („automate all attributes except" = automatisiere alle Attribute bis auf).
Ferner wird definiert, wie die Timeline aussehen soll für die Automatisierung (timeline con- figuration = Zeitplan Konfiguration), und wie dicht benachbart Auszeichnungspunkte, also Keyframes, sein sollen. Des Weiteren sollen beispielweise räumliche Benachbarungen, sowie Richtungsänderungen angebbar sein. Eine Optimierung der Datenaufzeichnung / der Automatisierung, die oben beschrieben wurde, wird erreicht. Des Weiteren kann auch noch beschrieben werden, dass nicht alle Attribute unmittelbar in einer Datei gespeichert werden, sondern nur bestimmte. Es bestehen also ganz verschiedenste Kombinationsoptionen.
Eine neue Controller-Untereinheit für einen neuen Knoten kann durch den Aufruf von NewControllerClass im Datenmodell erzeugt werden. Diesem Aufruf werden der Name, die Attribute, die childCreationFunction und Optionen übergeben. Auf diese Weise wird der neue Knoten definiert.
Darüber hinaus sind die einzelnen Knoten noch in eine graphenförmige z.B. baumförmige Hierarchie zu bringen. Die baumförmige Hierarchie wurde bereits in Fig. 7a grafisch dar- gestellt. So befindet sich die Quelle "sourceO" in einem Container "sources", der sich wiederum in einem Container "sceneO" befindet, der seinerseits in einem Container "scenes" liegt.
Für die Gestaltung des in Fig. 7a skizzierten Datenmodells gibt es verschiedene Pro- grammierbefehle, die in Fig. 7d, 7e, 7f illustriert werden. Dabei sind einerseits die Knoten zu definieren, ferner sind die Attribute der Knoten zu definieren und, die Knoten sind über vordefinierte Befehle einem Elternknoten zuzuweisen. Hierdurch kann eine entsprechende Hierarchie aufgebaut werden. Gemäß Ausführungsformen ist UI.FM ist in der Lage, aus der graphenförmigen, beispielsweise baumförmigen Datenstruktur eine Reihe nützlicher Tools abzuleiten, und bei- spielsweise automatisch zu erzeugen. Diese Software-Tools, z.B. Software- Entwicklungstools, werden im Folgenden beschrieben.
Ein erstes Tool realisiert die automatische Erzeugung von Programmierbefehlen zum Er- reichen von Knoten im Datenmodell. So generiert UI.FM automatisch aus der zuvor definierten Baumhierarchie Programmierbefehle. Fig. 8a zeigt hierzu ein Beispiel, bei dem eine JavaScript Konsole 810 geöffnet ist. Eine solche JavaScript Konsole 810 befindet sich z.B. in Browsern, wie Chrome® und Firefox®. Über diese Konsole kann auf das Datenmodel, das im Browser geladen ist, zugegriffen werden.
Gibt man z.B., wie in Fig. 8b gezeigt, die Knotenfolge "ssc.globalController.audio" in die JavaScript Konsole 810 ein, spricht man den„audio"-Knoten an, der zuvor erzeugt wurde. Unter dem Knoten "audio" existiert ein Unterknoten "scenes". Auf diesen Unterknoten "scenes" kann zugegriffen werden, indem hinter "audio." Der Name„scenes" hinzugefügt wird. Nur die ersten beiden Buchstaben von "scenes" müssen eingegeben werden, "sc" wird dann automatisch zu "scenes" ergänzt. Das liegt daran, dass nun automatisch aus der zuvor definieren, beispielsweise baumförmigen Hierarchie der richtige Programmierbefehl angehängt wurde, live und dynamisch. Als nächstes wird der Knotenname "sce- neO" hinzugefügt, dann der Unterknoten "sources" angesprochen werden, und schließlich die Quelle "srcO". Das System bietet beim Eingeben der jeweiligen ersten Buchstaben der Knotennamen jeweils mögliche Ergänzungen an, da das System die entsprechenden Unterknoten bereits kennt, die in Frage kommen. Der vollständige Pfad zu "srcO" ist in Fig. 8c gezeigt. In Fig. 8d ist darüber hinaus spezifiziert, welche Eigenschaft der Quelle geändert werden soll, dort durch den Funktionsaufruf "setXyz". Der Befehl„setXyz" ist automatisch generiert worden. In der Datendefinition wurde hingegen lediglich "xyz: [0,0,0]" eingegeben, wie in Fig. 8d gezeigt. Es wurde also lediglich definiert, dass ein Attribut existieren soll, das xyz heißt, und das den Standardwert [0,0,0] hat. UI.FM hat aus dieser Zeile automa- tisch den Befehl„setXyzQ" generiert.
Fig. 8e zeigt den Befehl, um die Quelle in die Position [-100, -100, 0] zu verschieben. Wird der Befehl durch Drücken von Enter abgesetzt, so wird die Quelle automatisch verschoben, wie in Fig. 8f gezeigt ist. Dies liegt beispielsweise daran, dass innerhalb der automa- tisch erzeugten setXyz-Funktion ein Event (Nachricht) erzeugt wurde. Die Quelldarstellung hat diese Nachricht abonniert und konnte daraufhin ihre Position ändern. Der Anwendungsentwickler kann somit einfach, intuitiv auf die Bestandteile, d.h. auf die Knoten des Datenmodells zugreifen. Neben der setXyzQ-Funktion gibt es auch automatisch eine Funktion zum Lesen, die automatisch generiert wird. Diese Funktion ist in Fig. 8f dargestellt und mit "xyzQ" bezeichnet. Wird der entsprechende Befehl„xyzQ" abgesetzt, so wird die aktuelle Position, "[-100, -100, 0]" ausgegeben. Verschiebt die Position, wie in Fig. 8g gezeigt, und ruft man erneut die Funktion zum Anzeigen der aktuellen Position auf, so wird die aktuelle Position der Quelle ausgegeben. Gemäß Ausführungsformen ist UI.FM in der Lage, automatisch den Synchronisationscode zu erzeugen, um Attribute oder Eigenschaften von einer Quelle A auf dem Client 1 auf die gleiche Quelle A auf dem Client 2 zu übertragen. In Fig. 9a ist eine Programm zu sehen, die zweimal als zwei Applikationen 910, 920 gestartet wurde. Ein neues Attribut kann nun schnell und einfach hinzugefügt werden. So zeigt Fig. 9b in einem weiteren Fenster das Datenmodell einer Quelle, das bereits oben beschrieben wurde. Nun kann, wie in Fig. 9c gezeigt, ein weiteres Attribut einfach hinzugefügt werden.
So wird in Fig. 9c das Attribut "uifm" mit dem Wert 'uifm' hinzugefügt. Das Attribut hat also einen String (eine Zeichenkette) als Wert. Durch die bloße Einfügung einer Zeile unter „attributes" wurde ein neues Attribut eingefügt.
Damit so vorgenommene Neudefinition zum Tragen kommt, kann es beispielsweise erforderlich sein, den Server 300 neu zu starten, wie in Fig. 9d gezeigt. So kann mit einer Ser- verkommandozeile wird der UI.FM Server 300 neu gestartet. Nach dem Neustart des Servers 300 werden auch die beiden Applikationen 910, 920 neu gestartet.
In Fig. 9e ist dargestellt, dass nun dieses neu eingefügte Attribut "uifm" in beiden Applikationen 910, 920 über den automatisch generierten Befehl "uifm()" abgefragt werden kann, und als Rückgabewert den Datenstring "uifm" liefert. Dies funktioniert sowohl im Client als auch im Server.
Ebenso ist es möglich, durch eine automatisch generierte Funktion "setUifmQ" den Wert des Attributs uifm zu ändern. Dies ist in den Fig. 9f und 9g gezeigt. Die so vorgenommene Aktualisierung des uifm Attributs in der ersten Anwendung 910 wird automatisch zur zweiten Anwendung 920, in Fig. 9g rechts, übertragen. Eine Abfrage des uifm Attributs mittels der automatisch generierten Funktion uifm() liefert auch in der rechten Anwendung 920 der Fig. 9g den aktualisierten String "Gabriel Gatzsche".
Genauso kann umgekehrt auch in der rechten Anwendung der Wert des Attributs uifm neu gesetzt werden, z.B. auf "Base camp", wie in Fig. 9h gezeigt. Eine solche Aktualisierung wirkt sich sofort unmittelbar auch auf die linke Applikation 910 in Fig. 9h aus. UI.FM erlaubt also eine schnelle und einfache Erweiterung des Datenmodells und erlaubt die schnelle und einfache Erzeugung von Synchronisationscode. UI.FM erzeugt automatisch Code, mit dem angeschlossene Beobachter (Observer) sich informieren lassen können, wenn ein Wert des Datenmodells sich ändert, (siehe z.B. Pub- lisher-Observer, ein Design-Pattern). Es ist kein menschlicher Beobachter gemeint, sondern ein Programm-Modul, dass eine Änderungsnachricht abonniert und diese automatisch zugestellt bekommt, sobald sich das Datenmodell ändert.
So kann, gemäß einer Ausführungsform, z.B. für eines der Attribute eines der Knoten des Datenmodells, auf eine Nutzereingabe hin, eine Änderungsüberwachung eingerichtet werden. Beispielsweise wird ein Alarm ausgegeben, wenn ein Wert eines der Attribute sich ändert, für das eine Änderungsüberwachung eingerichtet ist. Die Ausgabe eines Alarms ist dabei nur ein Beispiel. Eine andere Möglichkeit ist, z.B. dass die Titelleiste des Browsers aktualisiert wird oder ähnliches.
Dies wird unter Bezugnahme auf Fig. 10a erläutert, wo eine Änderungsüberwachung eingerichtet wird. Durch den in der Konsole eingegebenen Befehl ,,on('change[uifm]', function ()" wird das System veranlasst, die nachfolgend definierte Funktion aufzurufen, wenn der Wert von uifm sich ändert. In der functionQ Definition der Fig. 10a wird definiert, dass in diesem Fall ein Alarm ausgegeben werden soll, der den Wert der Eigenschaft uifm zeigt. Drückt man nun Enter in der Konsole, ist der so definierte Beobachter registriert. In Fig. 10b wird nun der Wert von uifm in 'production app' geändert. Daraufhin erscheint, wie in Fig. 10c gezeigt, ein Alarm, der den neuen Wert von uifm, nämlich "production app" ausgibt. Dies funktioniert auch, wenn ein zweiter Client geöffnet wird.
In Fig. 10d ist das Öffnen eines zweiten Clients gezeigt. Dort wird in einer Konsole der Wert von uifm durch die Funktion "setUifm" geändert. Obwohl der Wert von uifm im zweiten Client geändert wurde, wird auch im ersten Client der Alarm ausgegeben, dass sich der Wert von uifm in "overhead" geändert hat, wie in Fig. 10e zu sehen ist. Im Detail wurde der neue Wert von uifm vom zweiten Client auf den Server übertragen, vom Server wurde der Wert auf den ersten Client übertragen, dort wurde der Wert von uifm entsprechend aktualisiert und der Beobachter wurde informiert, was zur Ausgabe des Alarms, wie in Fig. 10e gezeigt, geführt hat.
Mit UI.FM ist es auch sehr einfach, Timeline Daten aufzuzeichnen. Wie oben beschrieben, wurde das uifm Attribut zum Datenmodell hinzugefügt. In einer Ausführungsform wird aufgrund dieses Attributs auch automatisch Code erzeugt, um Timeline Daten aufzuzeich- nen. Beispielsweise können verschiedene Änderungen des Wertes uifm über die zeitlich aufgezeichnet werden. Ein Drücken auf z.B. eine Playtaste, kann dafür sorgen, dass die Zeit losläuft. Setzt man nun den Wert von uifm zunächst auf "Freitag", dann auf "Samstag", dann auf "Sonntag", so werden diese Datenänderungen in ihrer zeitlichen Reihenfolge im Zeitverlauf aufgezeichnet.
Aktiviert man nun beispielsweise den Lesemodus / Wiedergabemodus, so werden die zuvor aufgezeichneten Daten wieder über die Schreibfunktion aus der Timeline in das Datenmodell geschrieben. Angeschlossene Beobachter (Views) werden informiert und geben beispielsweise automatisch Alarme (englisch:„Alerts") ausgegeben, und zwar je- weils zu dem Zeitpunkt in der Abspielung, zu dem auch der Wert während des Aufnahmemodus geändert wurde. So wird beispielsweise in Fig. 1 1 der Alarm "Sonntag" zu dem Zeitpunkt ausgegeben, zu dem in der Wiederholung der Aufzeichnung auch der Wert "Sonntag" geändert wird. Ausführungsformen erlauben also Aufnahmen des von Eingaben, die bei ihrer Wiedergabe durch das System zeitlich richtig wiedergegeben werden, und beispielsweise zeitlich richtig Alarme entsprechend der Aufnahme ausgeben.
Obwohl manche Aspekte im Zusammenhang mit einer Vorrichtung beschrieben wurden, versteht es sich, dass diese Aspekte auch eine Beschreibung des entsprechenden Verfahrens darstellen, sodass ein Block oder ein Bauelement einer Vorrichtung auch als ein entsprechender Verfahrensschritt oder als ein Merkmal eines Verfahrensschrittes zu verstehen ist. Analog dazu stellen Aspekte, die im Zusammenhang mit einem oder als ein Verfahrensschritt beschrieben wurden, auch eine Beschreibung eines entsprechenden Blocks oder Details oder Merkmals einer entsprechenden Vorrichtung dar. Einige oder alle der Verfahrensschritte können durch einen Hardware-Apparat (oder unter Verwen- dung eines Hardware-Apparats), wie zum Beispiel einen Mikroprozessor, einen programmierbaren Computer oder einer elektronischen Schaltung durchgeführt werden. Bei eini- gen Ausführungsbeispielen können einige oder mehrere der wichtigsten Verfahrensschritte durch einen solchen Apparat ausgeführt werden.
Je nach bestimmten Implementierungsanforderungen können Ausführungsbeispiele der Erfindung in Hardware oder in Software implementiert sein. Die Implementierung kann unter Verwendung eines digitalen Speichermediums, beispielsweise einer Floppy-Disk, einer DVD, einer BluRay Disc, einer CD, eines ROM, eines PROM, eines EPROM, eines EEPROM oder eines FLASH-Speichers, einer Festplatte oder eines anderen magnetischen oder optischen Speichers durchgeführt werden, auf dem elektronisch lesbare Steu- ersignale gespeichert sind, die mit einem programmierbaren Computersystem derart zusammenwirken können oder zusammenwirken, dass das jeweilige Verfahren durchgeführt wird. Deshalb kann das digitale Speichermedium computerlesbar sein.
Manche Ausführungsbeispiele gemäß der Erfindung umfassen also einen Datenträger, der elektronisch lesbare Steuersignale aufweist, die in der Lage sind, mit einem pro- grammier-baren Computersystem derart zusammenzuwirken, dass eines der hierin beschriebenen Verfahren durchgeführt wird.
Allgemein können Ausführungsbeispiele der vorliegenden Erfindung als Computerpro- grammprodukt mit einem Programmcode implementiert sein, wobei der Programmcode dahin gehend wirksam ist, eines der Verfahren durchzuführen, wenn das Computerprogrammprodukt auf einem Computer abläuft.
Der Programmcode kann beispielsweise auch auf einem maschinenlesbaren Träger ge- speichert sein.
Andere Ausführungsbeispiele umfassen das Computerprogramm zum Durchführen eines der hierin beschriebenen Verfahren, wobei das Computerprogramm auf einem maschi- nen-lesbaren Träger gespeichert ist. Mit anderen Worten ist ein Ausführungsbeispiel des erfindungsgemäßen Verfahrens somit ein Computerprogramm, das einen Programmcode zum Durchführen eines der hierin beschriebenen Verfahren aufweist, wenn das Computerprogramm auf einem Computer abläuft.
Ein weiteres Ausführungsbeispiel der erfindungsgemäßen Verfahren ist somit ein Daten- träger (oder ein digitales Speichermedium oder ein computerlesbares Medium), auf dem das Computerprogramm zum Durchführen eines der hierin beschriebenen Verfahren aufgezeichnet ist. Ein weiteres Ausführungsbeispiel des erfindungsgemäßen Verfahrens ist somit ein Datenstrom oder eine Sequenz von Signalen, der bzw. die das Computerprogramm zum Durchführen eines der hierin beschriebenen Verfahren darstellt bzw. darstellen. Der Datenstrom oder die Sequenz von Signalen kann bzw. können beispielsweise dahin gehend konfiguriert sein, über eine Datenkommunikationsverbindung, beispielsweise über das Internet, transferiert zu werden.
Ein weiteres Ausführungsbeispiel umfasst eine Verarbeitungseinrichtung, beispielsweise einen Computer oder ein programmierbares Logikbauelement, die dahin gehend konfigu- riert oder angepasst ist, eines der hierin beschriebenen Verfahren durchzuführen.
Ein weiteres Ausführungsbeispiel umfasst einen Computer, auf dem das Computerprogramm zum Durchführen eines der hierin beschriebenen Verfahren installiert ist. Ein weiteres Ausführungsbeispiel gemäß der Erfindung umfasst eine Vorrichtung oder ein System, die bzw. das ausgelegt ist, um ein Computerprogramm zur Durchführung zumindest eines der hierin beschriebenen Verfahren zu einem Empfänger zu übertragen. Die Übertragung kann beispielsweise elektronisch oder optisch erfolgen. Der Empfänger kann beispielsweise ein Computer, ein Mobilgerät, ein Speichergerät oder eine ähnliche Vor- richtung sein. Die Vorrichtung oder das System kann beispielsweise einen Datei-Server zur Übertragung des Computerprogramms zu dem Empfänger umfassen.
Bei manchen Ausführungsbeispielen kann ein programmierbares Logikbauelement (beispielsweise ein feldprogrammierbares Gatterarray, ein FPGA) dazu verwendet werden, manche oder alle Funktionalitäten der hierin beschriebenen Verfahren durchzuführen. Bei manchen Ausführungsbeispielen kann ein feldprogrammierbares Gatterarray mit einem Mikroprozessor zusammenwirken, um eines der hierin beschriebenen Verfahren durchzuführen. Allgemein werden die Verfahren bei einigen Ausführungsbeispielen seitens einer beliebigen Hardwarevorrichtung durchgeführt. Diese kann eine universell einsetzbare Hardware wie ein Computerprozessor (CPU) sein oder für das Verfahren spezifische Hardware, wie beispielsweise ein ASIC.
Die oben beschriebenen Ausführungsbeispiele stellen lediglich eine Veranschaulichung der Prinzipien der vorliegenden Erfindung dar. Es versteht sich, dass Modifikationen und Variationen der hierin beschriebenen Anordnungen und Einzelheiten anderen Fachleuten einleuchten werden. Deshalb ist beabsichtigt, dass die Erfindung lediglich durch den Schutzumfang der nachstehenden Patentansprüche und nicht durch die spezifischen Ein- zelheiten, die anhand der Beschreibung und der Erläuterung der Ausführungsbeispiele hierin präsentiert wurden, beschränkt sei.

Claims

Patentansprüche
Vorrichtung (160, 170; 300, 350, 360), umfassend, ein Datenmodell (1 10; 310, 351 , 361 ), wobei das Datenmodell (1 10; 310, 351 , 361 ) drei oder mehr Knoten umfasst, wobei einem oder mehr der drei oder mehr Knoten des Datenmodells (1 10; 310, 351 , 361 ) eine ID zugewiesen ist, wobei jeder dieser ein oder mehr Knoten durch seine ID von den anderen Knoten des Datenmodells (1 10; 310, 351 , 361 ) eindeutig unterscheidbar ist, wobei wenigstens zwei der Knoten des Datenmodells (1 10; 310, 351 , 361 ) jeweils ein oder mehrere Attribute aufweisen, wobei jedes der besagten Attribute einen Wert annehmen kann, der in dem Datenmodell (1 10; 310, 351 , 361 ) gespeichert ist, wobei jedem Knoten der besagten wenigstens zwei Knoten eine Pfadangabe zugewiesen ist, wobei die Pfadangabe den jeweiligen Knoten, dem diese Pfadangabe zugewiesen ist, und wenigstens einen weiteren der drei oder mehr Knoten des Datenmodells (1 10; 310, 351 , 361 ) aufweist, und wobei sich die Pfadangabe von jedem Knoten der besagten wenigstens zwei Knoten von der ID des jeweiligen Knotens unterscheidet, ein Controller (120; 320, 352, 362), der zu jedem Attribut von jedem der drei oder mehr Knoten des Datenmodells ( 10; 310, 351 , 361 ), der Attribute aufweist, eine Schreibfunktion umfasst, und wobei der Wert des Attributs mittels der Schreibfunktion änderbar ist, und einen Synchronizer (130; 340, 354, 364), wobei der Synchronizer (130; 340, 354, 364) dafür eingerichtet ist, eine Aktualisierungsmitteilung zu empfangen, die einen der Knoten des Datenmodells (1 10; 310, 351 , 361 ) bezeichnet, wobei die Aktualisierungsmitteilung des Weiteren ein Attribut dieses Knotens bezeichnet, und wobei die Aktualisierungsmitteilung angibt, wie der Wert dieses Attributs zu aktualisieren ist, wobei die Aktualisierungsmitteilung den Knoten mittels der ID des Knotens bezeichnet, und wobei der Controller (120; 320, 352, 362) dafür eingerichtet ist, den Wert dieses Attributs dieses Knotens in Abhängigkeit von der Aktualisierungsmitteilung mittels der Schreibfunktion dieses Attributs zu aktualisieren. Vorrichtung (160, 170; 300, 350, 360) nach Anspruch 1 , wobei jedem der Knoten des Datenmodells (1 10; 310, 351 , 361 ) eine ID zugewiesen ist, und wobei jeder der Knoten des Datenmodells durch seine ID von den anderen Knoten des Datenmodells (1 10; 310, 351 , 361 ) eindeutig unterscheidbar ist.
Vorrichtung (160, 170; 300, 350, 360) nach Anspruch 1 oder 2, wobei der Controller (120; 320, 352, 362) zu jedem Attribut von jedem der drei oder mehr Knoten des Datenmodells (1 10; 310, 351 , 361 ), der Attribute aufweist, eine Lesefunktion umfasst, wobei der Wert des Attributs mittels der Lesefunktion lesbar ist.
Vorrichtung (160, 170; 300, 350, 360) nach einem der vorherigen Ansprüche, wobei die ID jedes der drei oder mehr Knoten des Datenmodells eine Zahl oder eine Zeichenkette oder ein Hashwert ist.
Vorrichtung (160, 170; 300, 350, 360) nach einem der vorherigen Ansprüche, wobei die drei oder mehr Knoten des Datenmodells (1 10; 310, 351 , 361 ) eine gra- phenförmige Struktur aufweisen, so dass jedem Knoten des Datenmodells (1 10; 310, 351 , 361 ) wenigstens einer der Knoten des Datenmodells (1 10; 310, 351 , 361 ) in der graphenförmigen Struktur unmittelbar nachfolgt und/oder einer der Knoten des Datenmodells (1 10; 310, 351 , 361 ) in der graphenförmigen Struktur unmittelbar vorausgeht, wobei wenigstens einem der Knoten des Datenmodells (1 10; 310, 351 , 361 ) zwei Knoten des Datenmodells (1 10; 310, 351 , 361 ) in der graphenförmigen Struktur unmittelbar nachfolgen.
Vorrichtung (160, 170; 300, 350, 360) nach einem der vorherigen Ansprüche, wobei die Vorrichtung (160, 170; 300, 350, 360) ferner eine Schnittstelle aufweist, die dafür eingerichtet ist, Informationen über Änderungen des Datenmodells (1 10; 310, 351 , 361 ) entgegenzunehmen, die einem der Knoten des Datenmodels ein oder mehrere Attribute hinzufügen, wobei die Vorrichtung (160, 170; 300, 350, 360) dafür eigerichtet ist, für jedes dieser hinzugefügten ein oder mehreren Attribute eine Lesefunktion und eine Schreibfunktion automatisch zu erzeugen, wobei der Wert des besagten Attributs mittels der Lesefunktion lesbar ist, und wobei der Wert des Attributs mittels der Schreibfunktion änderbar ist.
7. Vorrichtung (160, 170; 300, 350, 360) nach einem der Ansprüche 1 bis 5, wobei die Vorrichtung (160, 170; 300, 350, 360) ferner eine Schnittstelle aufweist, die dafür eingerichtet ist, Informationen über Änderungen des Datenmodells (1 10; 310, 351 , 361 ) entgegenzunehmen, die einem der Knoten des Datenmodels ein oder mehrere Attribute hinzufügen, wobei die Vorrichtung (160, 170; 300, 350, 360) dafür eigerichtet ist, für jedes dieser hinzugefügten ein oder mehreren Attribute eine Schreibfunktion automatisch zu erzeugen, wobei der Wert des Attributs mittels der Schreibfunktion änderbar ist, wobei die Schreibfunktion dafür eingerichtet ist, den Synchronizer (130; 340, 354, 364) und/oder eine View (213; 330, 353, 363) zu informieren, wenn der Wert des Attributs sich ändert.
8. Vorrichtung (160, 170; 300, 350, 360) nach einem der Ansprüche 1 bis 5 oder nach Anspruch 7, wobei die Vorrichtung (160, 170; 300, 350, 360) ferner eine Schnittstelle aufweist, die dafür eingerichtet ist, Informationen über Änderungen des Datenmodells (1 10; 310, 351 , 361 ) entgegenzunehmen, die einem der Knoten des Datenmodels ein oder mehrere Attribute hinzufügen, wobei die Vorrichtung (160, 170; 300, 350, 360) dafür eigerichtet ist, für jedes dieser hinzugefügten ein oder mehreren Attribute eine Schreibfunktion automatisch zu erzeugen, wobei der Wert des Attributs mittels der Schreibfunktion änderbar ist, wobei die Schreibfunktion dafür eingerichtet ist, Änderungen des Werts des Attributs über die Zeit zum Zwecke der späteren Wiedergabe oder Rückgängigmachung aufzuzeichnen.
9. Vorrichtung (160, 170; 300, 350, 360) nach einem der vorherigen Ansprüche, wobei die Vorrichtung (160, 170; 300, 350, 360) dafür eingerichtet ist, die Lesefunktion und die Schreibfunktion für jedes der Attribute jedes der Knoten des Datenmodells (1 10; 310, 351 , 361 ), der Attribute aufweist, mittels einer Webapplikation bereitzustellen, so dass die besagte Lesefunktion und die besagte Schreibfunktion mittels der Webapplikation nutzbar sind.
10. Vorrichtung (160, 170; 300, 350, 360) nach Anspruch 9, wobei die Webapplikation in JavaScript und/oder HTML implementiert ist.
Vorrichtung (160, 170; 300, 350, 360) nach einem der vorherigen Ansprüche, wobei die Vorrichtung (160, 170; 300, 350, 360) dafür eingerichtet ist, für eines der Attribute eines der Knoten des Datenmodells ( 10; 310, 351 , 361 ), auf eine Nutzereingabe hin, eine Änderungsüberwachung einzurichten.
Vorrichtung (160, 170; 300, 350, 360) nach Anspruch 1 1 , wobei die Vorrichtung (160, 170; 300, 350, 360) dafür eingerichtet ist, einen Alarm auszugeben, wenn ein Wert eines der Attribute sich ändert, für das eine Änderungsüberwachung eingerichtet ist.
Vorrichtung (160, 170; 300, 350, 360) nach einem der vorherigen Ansprüche, wobei die Vorrichtung (160, 170; 300, 350, 360) dafür eingerichtet ist, eine Vornahme einer Änderung eines Attributs eines der Knoten des Datenmodells (1 10; 310, 351 , 361 ) aufzuzeichnen.
Server (170; 300), wobei der Server (170; 300) eine Vorrichtung (160; 310) nach einem der Ansprüche 1 bis 13 ist, wobei der Server (170; 300) dafür eingerichtet ist, eine Anmeldung von ein oder mehreren Clients (160; 350, 360) entgegenzunehmen, wobei der Server (170; 300) dafür eingerichtet ist, den ein oder mehreren Clients (160; 350, 360) auf deren Anmeldung hin, Informationen über das Datenmodell (310) zu übertragen, wobei diese Informationen über das Datenmodell (310) die
Werte der Attribute von allen Knoten oder von zwei oder mehr der Knoten des Datenmodells (310) umfassen, die Attribute aufweisen, und wobei die Informationen über das Datenmodell (310) ferner für jeden Knoten des Datenmodells (310) oder für die wenigstens zwei Knoten des Datenmodells (310) angeben, welche der Kno- ten des Datenmodells (310) diesem Knoten unmittelbar nachfolgen und/oder welche Knoten des Datenmodells (310) diesem Knoten unmittelbar vorausgehen.
15. Server (170; 300) nach Anspruch 14, wobei der Server (170; 300) dafür eingerichtet ist, eine Anmeldung von zwei oder mehreren Clients (160; 350, 360) entgegenzunehmen, wobei der Synchronizer (340) des Servers (170; 300) dafür eingerichtet ist, eine Nachricht von einem der Clients (160; 350, 360) zu empfangen, die angibt, dass ein Wert eines Attributs eines Knotens des Datenmodells (310) sich geändert hat, und wobei der Synchronizer (340) des Servers (170; 300) dafür eingerichtet ist, auf die Nachricht des besagten Clients (160; 350, 360) hin, die anderen zwei oder mehreren Clients (160; 350, 360), die sich beim Server (170; 300) angemeldet haben, davon unterrichtet, dass ein Wert eines Attributs eines Knotens des Datenmodells (310) sich geändert hat.
Server (170; 300) nach Anspruch 14 oder 15, wobei der Server (170; 300) dafür eingerichtet ist, einem Gerät (380, 390) drahtlos oder drahtgebunden eine Nachricht zuzusenden, die dem Gerät (380, 390) mitteilt, dass ein Attribut eines der Knoten des Datenmodells (310) sich geändert hat.
Server (170; 300) nach Anspruch 16, wobei der Server (170; 300) dafür eingerichtet ist, dem Gerät (380, 390) die Nachricht drahtlos zuzusenden.
Server (170; 300) nach Anspruch 16 oder 17, wobei das Gerät (380, 390) ein Renderer (380) zur Erzeugung von ein oder mehreren Lautsprechersignalen ist.
Server nach einem der Ansprüche 14 bis 18, wobei der Server (170; 300) dafür eingerichtet ist, vom Client (160; 350, 360) Informationen über das Datenmodell (351 , 361 ) des Clients (160; 350, 360) zu empfangen, wobei diese Informationen über das Datenmodell (351 , 361 ) des Clients (160; 350, 360) die Werte der Attribute von allen Knoten oder von zwei oder mehr der Knoten des Datenmodells (351 , 361 ) des Clients (160; 350, 360) umfassen, die Attribute aufweisen, und wobei die Informationen über das Datenmodell (351 , 361 ) des Clients (160; 350, 360) ferner für jeden Knoten des Datenmodells (351 , 361 ) des Clients (160; 350, 360) oder für die wenigstens zwei Knoten des Datenmodells (351 , 361 ) des Clients (160; 350, 360) angeben, welche der Knoten des Datenmodells (351 , 361 ) des Clients (160; 350, 360) diesem Knoten unmittelbar nachfolgen und/oder welche Knoten des Da- tenmodells (351 , 361 ) des Clients (160; 350, 360) diesem Knoten unmittelbar vorausgehen.
Server (170; 300) nach einem der Ansprüche 14 bis 19, wobei der Server (170; 300) dafür eingerichtet ist, den ein oder mehreren Clients (160; 350, 360) auf deren Anmeldung hin, die ID von zwei oder mehreren der Knoten des Datenmodells (310) des Servers (170; 300) zu übertragen.
Client (160; 350, 360), wobei der Client (160; 350, 360) eine Vorrichtung (160, 170; 300, 350, 360) nach einem der Ansprüche 1 bis 10 ist, wobei der Client (160; 350, 360) dafür eingerichtet ist, sich bei einem Server (170; 300) nach einem der Ansprüche 14 bis 20 anzumelden, wobei der Client (160; 350, 360) dafür eingerichtet ist, auf die Anmeldung beim Server (170; 300) hin, Informationen über das Datenmodell (310) des Servers (170; 300) zu empfangen, wobei diese Informationen über das Datenmodell (310) des Servers (170; 300) die Werte der Attribute von allen Knoten oder von zwei oder mehr Knoten des Datenmodells (310) des Servers (170; 300) umfassen, die Attribute aufweisen, und wobei die Informationen über das Datenmodell (310) des Servers (170; 300) ferner für jeden Knoten des Datenmodells (310) oder für die zwei oder mehr Knoten des Datenmodells (310) des Servers (170; 300) angeben, welche der Knoten des Datenmodells (310) des Servers (170; 300) diesem Knoten unmittelbar nachfolgen und/oder welche Knoten des Datenmodells (310) des Servers (170; 300) diesem Knoten unmittelbar vorausgehen, und wobei der Client (160; 350, 360) dafür eingerichtet ist, sein Datenmodell (351 , 361 ) abhängig von den Informationen über das Datenmodell (310) des Servers (170; 300) hin zu aktualisieren.
Client (160; 350, 360) nach Anspruch 21 , wobei der Client (160; 350, 360) dafür eingerichtet ist, dem Server (170; 300) Informationen über das Datenmodell (351 , 361 ) des Clients (160; 350, 360) zu übertragen, wobei diese Informationen über das Datenmodell (351 , 361 ) des Clients (160; 350, 360) die Werte der Attribute von allen Knoten oder von zwei oder mehr der Knoten des Datenmodells (351 , 361 ) des Clients (160; 350, 360) umfassen, die Attribute aufweisen, und wobei die Informationen über das Datenmodell (351 , 361 ) des Clients (160; 350, 360) ferner für jeden Knoten des Datenmodells (351 , 361 ) des Clients (160; 350, 360) oder für die wenigstens zwei Knoten des Datenmodells (351 , 361 ) des Clients (160; 350, 360) angeben, welche der Knoten des Datenmodells (351 , 361 ) des Clients (160; 350, 360) diesem Knoten unmittelbar nachfolgen und/oder welche Knoten des Datenmodells (351 , 361 ) des Clients (160; 350, 360) diesem Knoten unmittelbar vorausgehen.
Client (160; 350, 360) nach Anspruch 21 oder 22, wobei der Client (160; 350, 360) dafür eingerichtet ist, in einem Webbrowser zu laufen.
Client (160; 350, 360) nach einem der Ansprüche 21 bis 23, wobei der Client (160; 350, 360) dafür eingerichtet ist, dem Server (170; 300) die ID von zwei oder mehreren der Knoten des Datenmodells (351 , 361 ) des Clients (160; 350, 360) zu übertragen.
System umfassend, einen Server (170; 300) nach einem der Ansprüche 14 bis 20, und einen Client (160; 350, 360) nach einem der Ansprüche 21 bis 24, wobei der Client (160; 350, 360) dafür eingerichtet ist, dem Server eine Aktualisierungsmitteilung zu senden, wobei der Synchronizer (340) des Servers (170; 300) dafür eingerichtet ist, die Aktualisierungsmitteilung zu empfangen, die einen der Knoten des Datenmodells (310) des Servers (170; 300) bezeichnet, die des Weiteren ein Attribut dieses Knotens bezeichnet, und die angibt, wie der Wert dieses Attributs zu aktualisieren ist, und wobei der Controller (320) des Servers (170; 300) dafür eingerichtet ist, den* Wert dieses Attributs dieses Knotens in Abhängigkeit von der Aktualisierungsmitteilung zu aktualisieren, wenn die Aktualisierungsmitteilung die ID des Knotens bezeichnet.
Verfahren, umfassend, Empfangen einer Aktualisierungsmitteilung, die einen Knoten eines Datenmodells mittels einer ID des Knotens bezeichnet, wobei die Aktualisierungsmitteilung des Weiteren ein Attribut dieses Knotens bezeichnet, und wobei die Aktualisierungsmitteilung angibt, wie ein Wert dieses Attributs zu aktualisieren ist, wobei das Datenmodell drei oder mehr Knoten umfasst, wobei einem oder mehr der drei oder mehr Knoten des Datenmodells eine ID zugewiesen ist, wobei jeder dieser ein oder mehr Knoten durch seine ID von den anderen Knoten des Datenmodells eindeutig unterscheidbar ist, wobei wenigstens zwei der Knoten des Datenmodells jeweils ein oder mehrere Attribute aufweisen, wobei jedes der besagten Attribute einen Wert annehmen kann, der in dem Datenmodell gespeichert ist, wobei jedem Knoten der besagten wenigstens zwei Knoten eine Pfadangabe zugewiesen ist, wobei die Pfadangabe den jeweiligen Knoten, dem diese Pfadangabe zugewiesen ist, und wenigstens einen weiteren der drei oder mehr Knoten des Datenmodells aufweist, und wobei sich die Pfadangabe von jedem Knoten der besagten wenigstens zwei Knoten von der ID des jeweiligen Knotens unterscheidet, und
Aktualisieren des Wertes des in der Aktualisierungsmitteilung bezeichneten Attributs mittels der Schreibfunktion dieses Attributs in Abhängigkeit von der Aktualisierungsmitteilung.
Computerprogramm mit einem Programmcode zur Durchführung des Verfahrens nach Anspruch 26.
EP14811795.5A 2013-12-05 2014-12-02 Vorrichtung, system und verfahren zur effizienten und verzögerungsarmen synchronisation graphenförmiger datenstrukturen Withdrawn EP3077924A1 (de)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
DE102013225058.4A DE102013225058A1 (de) 2013-12-05 2013-12-05 Vorrichtung, system und verfahren zur effizienten und verzögerungsarmen synchronisation graphenförmiger datenstrukturen
PCT/EP2014/076273 WO2015082479A1 (de) 2013-12-05 2014-12-02 Vorrichtung, system und verfahren zur effizienten und verzögerungsarmen synchronisation graphenförmiger datenstrukturen

Publications (1)

Publication Number Publication Date
EP3077924A1 true EP3077924A1 (de) 2016-10-12

Family

ID=52023471

Family Applications (1)

Application Number Title Priority Date Filing Date
EP14811795.5A Withdrawn EP3077924A1 (de) 2013-12-05 2014-12-02 Vorrichtung, system und verfahren zur effizienten und verzögerungsarmen synchronisation graphenförmiger datenstrukturen

Country Status (6)

Country Link
US (1) US20160283571A1 (de)
EP (1) EP3077924A1 (de)
JP (1) JP6311022B2 (de)
CN (1) CN105934758A (de)
DE (1) DE102013225058A1 (de)
WO (1) WO2015082479A1 (de)

Families Citing this family (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP3364314B1 (de) * 2017-02-15 2022-10-19 QlikTech International AB Verfahren und systeme zur indexierung unter verwendung von indexlets
CN107145350B (zh) * 2017-04-28 2018-08-21 武汉斗鱼网络科技有限公司 一种软件开发方法及系统
WO2021180304A1 (en) * 2020-03-09 2021-09-16 Siemens Aktiengesellschaft Component and method for synchronizing a graph-based information model
DE102021125498A1 (de) 2021-10-01 2023-04-06 Valeo Schalter Und Sensoren Gmbh Systemvalidierung mit verbesserter Handhabung von Protokollierungsdaten

Family Cites Families (15)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7240094B2 (en) * 1997-07-03 2007-07-03 Centra Software Inc. Method and system for synchronizing and serving multimedia in a distributed network
US6188695B1 (en) * 1997-12-18 2001-02-13 Ericsson Inc. System and method for multi-node data synchronization
US6681383B1 (en) * 2000-04-04 2004-01-20 Sosy, Inc. Automatic software production system
US7334216B2 (en) * 2000-04-04 2008-02-19 Sosy, Inc. Method and apparatus for automatic generation of information system user interfaces
US6880086B2 (en) * 2000-05-20 2005-04-12 Ciena Corporation Signatures for facilitating hot upgrades of modular software components
US20050044145A1 (en) * 2003-08-20 2005-02-24 International Business Machines Corporation Collaboration method and system
US7383289B2 (en) * 2003-12-02 2008-06-03 Sap Aktiengesellschaft Updating and maintaining data in a multi-system network using asynchronous message transfer
US20060031256A1 (en) * 2004-05-20 2006-02-09 Bea Systems, Inc. Template language for mobile client
JP2006163855A (ja) * 2004-12-08 2006-06-22 Hitachi Software Eng Co Ltd Webアプリケーション開発支援装置及び開発支援方法
US8065204B2 (en) * 2005-09-29 2011-11-22 Sony Corporation System and method for software integration and factory deployment
CN100534084C (zh) * 2006-07-10 2009-08-26 北京工业大学 远程xml数据更新方法以及系统
US20090193410A1 (en) * 2007-09-28 2009-07-30 Xcerion Aktiebolag Network operating system
CN101409614B (zh) * 2007-10-12 2011-04-13 华为技术有限公司 一种数据同步方法、系统和设备
JP5356351B2 (ja) * 2010-09-30 2013-12-04 ヤフー株式会社 ストレージサーバ、ファイル同期システム、ファイル衝突処理方法及びプログラム
CN102819585B (zh) * 2012-07-31 2015-04-22 北大方正集团有限公司 一种xml数据库文档控制方法

Non-Patent Citations (2)

* Cited by examiner, † Cited by third party
Title
None *
See also references of WO2015082479A1 *

Also Published As

Publication number Publication date
US20160283571A1 (en) 2016-09-29
CN105934758A (zh) 2016-09-07
DE102013225058A1 (de) 2015-06-11
JP2017504104A (ja) 2017-02-02
JP6311022B2 (ja) 2018-04-11
DE102013225058A8 (de) 2015-08-27
WO2015082479A1 (de) 2015-06-11

Similar Documents

Publication Publication Date Title
DE102004051179B4 (de) Einstellungsvorrichtung für ein Steuerungssystem, Verfahren zum Einstellen eines Steuerungssystems und Einstellungsprogramm
DE60317917T2 (de) Verfahren und vorrichtung zum weiterleiten von sitzungsinformationen von einem portal-server
DE60131683T2 (de) Verfahren und system zur verwaltung von mehreren netzwerk-betriebsmitteln
EP2555489B1 (de) Verfahren und Einrichtung zum Konfigurieren von Endgeräten
DE60314877T2 (de) Verfahren und vorrichtung zur bereitstellung elektronischer post an ein mobiles gerät
DE60006845T2 (de) Verfahren und vorrichtung zur zusammenarbeit bei multimediaerzeugung über einem netzwerk
DE60319962T2 (de) Multimodus-synchronisation
DE102010037702A1 (de) Dynamisch verknüpfte grafische Nachrichten für Prozesssteuerungssysteme
DE10003907A1 (de) Browser für die Anwendung beim Zugriff auf Hypertext-Dokumente in einer Mehrnutzer-Computerumgebung
EP3077924A1 (de) Vorrichtung, system und verfahren zur effizienten und verzögerungsarmen synchronisation graphenförmiger datenstrukturen
US6314453B1 (en) Method for sharing and executing inaccessible dynamic processes for replica consistency among a plurality of existing applications
DE202010018482U1 (de) Bereitstellung eines Zugangs zu einer Unterhaltung in einem gehosteten Unterhaltungssystem
DE60128622T2 (de) Betriebssystem für strukturierte Verarbeitung von Information
DE10161115A1 (de) Transformation von Objektbäumen, insbesondere in MES-Systemen
DE60105994T2 (de) Verfahren und system zum schieben von informationen
WO2002067141A2 (de) System und verfahren zum speicherplatzoptimierten abspeichern und generieren von webseiten
DE10161111A1 (de) System und Verfahren zur Projektierung von Transformationen von Objektbäumen
DE602005005954T2 (de) Verfahren und System zur Serverfernadministration
DE19943453A1 (de) System und Verfahren zur Unterstützung der Gruppeninteraktion (GIA) in hypermedialen Informationsräumen
DE60034218T2 (de) Verfahren und system zur eigenschaftsbenachrichtigung
EP2620868A1 (de) Arbeitsfluss-Management-System für Computernetze
DE10055168A1 (de) Industrielle Steuerung auf der Basis verteilbarer Technologischer Objekte
DE69535478T2 (de) Informationsverarbeitungssystem
DE102004039633B4 (de) Verfahren und Vorrichtung zum Austauschen fahrzeugoriginärer Informationen
DE10142378A1 (de) Datenverarbeitungsanlage, Ressourcensteuergerät und Verfahren zur Fernverwaltung von Ressourcen

Legal Events

Date Code Title Description
PUAI Public reference made under article 153(3) epc to a published international application that has entered the european phase

Free format text: ORIGINAL CODE: 0009012

17P Request for examination filed

Effective date: 20160603

AK Designated contracting states

Kind code of ref document: A1

Designated state(s): AL AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC MK MT NL NO PL PT RO RS SE SI SK SM TR

AX Request for extension of the european patent

Extension state: BA ME

DAX Request for extension of the european patent (deleted)
REG Reference to a national code

Ref country code: HK

Ref legal event code: DE

Ref document number: 1228664

Country of ref document: HK

17Q First examination report despatched

Effective date: 20190515

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: THE APPLICATION IS DEEMED TO BE WITHDRAWN

18D Application deemed to be withdrawn

Effective date: 20200701

REG Reference to a national code

Ref country code: HK

Ref legal event code: WD

Ref document number: 1228664

Country of ref document: HK