The purpose of Yate's design is to provide an extensible telephony engine. Holding the base code as simple as possible and adding functionality as needed allows one to find the best balance between desired functionality, performance and stability.
The architecture of Yate is based on a message passing system. The architecture can be divided into four main parts as you can see bellow:
- Core - generic classes like String, Thread, Socket, Mutex
- Message Engine - message related classes Message, Engine, Plugin
- Telephony Engine - telephony related classes like Driver, Channel
- Yate Modules - modules of Yate are equal no matter if they are telephony or routing or anything else related, because of the message passing system.
The most important aspect of Yate is its message-passing system. Modules are passing around messages among them. This allows us to have a bigger flexibility than with plain functions, mainly because messages in Yate can have an arbitrary number of parameters, and can be sent to more than one module by changing the priority.
The Core where encapsulations for sockets, threads and others primitives can be found.
The engine holds the base C++ classes of Yate and connects together all components. See the C++ API here.
Most real functionality is provided by modules loaded at runtime. Modules are dynamic libraries loaded as plugins in the engine or external applications started by a specific module (extmodule) that allows them to talk to the engine and other modules.
The signaling between Yate modules (either plugins or external modules) is performed by using messages. They provide extensibility, customization and technology independence. Each module that needs something from another or tries to notify about some event creates and emits a message. The message flows through the Engine which tries to deliver it to the proper target.