{"id":9848,"date":"2022-06-21T09:10:23","date_gmt":"2022-06-21T09:10:23","guid":{"rendered":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/documentation\/rdk_video_documentation\/components\/open-sourced_components\/iarm_bus\/"},"modified":"2026-07-30T10:51:31","modified_gmt":"2026-07-30T10:51:31","slug":"iarm_bus","status":"publish","type":"page","link":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/","title":{"rendered":"IARM Bus"},"content":{"rendered":"\n<p>IARM Bus (Inter-Application Resource Manager Bus) is a platform-agnostic Inter-Process Communication (IPC) interface for the RDK middleware stack. It allows processes to communicate with each other by sending events or invoking Remote Procedure Calls (RPC). The programming API is independent of the operating system or the underlying IPC mechanism, making it usable across a variety of platforms. Two processes connected to the same bus instance can exchange events and RPC calls; processes on different bus instances cannot communicate with each other.<\/p>\n\n\n\n<p>IARM Bus operates as a system-level service, launched early in the boot sequence before other RDK middleware daemons. Its core function is to provide a named, well-known message bus over which middleware components \u2014 such as the device settings manager, power manager, and display service manager \u2014 register, publish events, and invoke methods in other processes. All bus members are uniquely identified by a string name registered at connection time.<\/p>\n\n\n\n<p>At the module level, IARM Bus provides a client library (<code>libIARMBus<\/code>) that middleware components link against, and a daemon (<code>IARMDaemonMain<\/code>) that acts as the central coordinator for member registration, resource ownership arbitration, and system-wide pre-change notifications. The daemon maintains the list of registered members and dispatches coordinated lifecycle calls (power pre-change, resolution pre-change, deep-sleep wakeup, and system-mode change) to all registered members before the corresponding state transition occurs.<\/p>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">flowchart LR\n\n%% Styles\nclassDef Apps stroke:#00B9F1,fill:#E6F7FD,stroke-width:2px;\nclassDef RDKMW stroke:#75D701,fill:#F1FFE6,stroke-width:2px;\nclassDef VL stroke:#808080,fill:#F2F2F2,stroke-width:2px;\n\n%% Apps Layer\n    subgraph Apps[\"Apps &amp; Runtimes\"]\n        RDKUI[\"UI\"]\n        FBApps[\"Firebolt Apps\"]\n        WPE_RT[\"WPE Runtime\"]\n    end\n\n%% Middleware\n    subgraph RDKMW[\"RDK Core Middleware\"]\n        AM[\"App Manager\"]\n        Rialto[\"Rialto\"]\n        Westeros[\"Westeros\"]\n        Thunder[\"WPE Framework (Thunder)\"]\n        IARMBUS[\"IARM Bus Daemon\\n(IARMDaemonMain)\"]\n        MW_Clients[\"Middleware Clients\\n(dsMgr, pwrMgr, etc.)\"]\n    end\n\n%% Vendor Layer\n    subgraph VL[\"Vendor Layer\"]\n        HAL[\"Component HAL\"]\n        BSP[\"BSP\"]\n        DBUS[\"D-Bus (system bus)\"]\n    end\n\n    %% External connections\n    Apps -->|Firebolt APIs| RDKMW\n    MW_Clients -->|IARM_Bus_Init \/ Connect\\nBroadcastEvent \/ Call| IARMBUS\n    IARMBUS -->|D-Bus IPC| DBUS\n    RDKMW -->|HAL APIs| VL<\/pre><\/div>\n\n\n\n<p><strong>Key Features &amp; Responsibilities:<\/strong><\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Event Publishing and Subscription<\/strong>: Provides <code>IARM_Bus_BroadcastEvent()<\/code> and <code>IARM_Bus_RegisterEventHandler()<\/code> APIs so any middleware process can publish system-wide asynchronous events and any other process can register to receive them.<\/li>\n\n\n\n<li><strong>Remote Procedure Calls<\/strong>: Exposes <code>IARM_Bus_RegisterCall()<\/code> and <code>IARM_Bus_Call()<\/code> \/ <code>IARM_Bus_Call_with_IPCTimeout()<\/code> APIs allowing one process to invoke a named function implemented in another process, with optional timeout control.<\/li>\n\n\n\n<li><strong>Member Registration and Discovery<\/strong>: Maintains a list of all connected processes via <code>IARM_Bus_Init()<\/code> and <code>IARM_Bus_Connect()<\/code>, and provides <code>IARM_Bus_IsConnected()<\/code> for processes to check whether a named member is currently registered on the bus.<\/li>\n\n\n\n<li><strong>Resource Ownership Management<\/strong>: Arbitrates exclusive access to shared device resources (decoder planes, focus, power, resolution) through <code>IARM_BusDaemon_RequestOwnership()<\/code> and <code>IARM_BusDaemon_ReleaseOwnership()<\/code>, broadcasting a resource-available event when a resource is freed.<\/li>\n\n\n\n<li><strong>Coordinated Pre-Change Notifications<\/strong>: Before system-state transitions (power change, resolution change, deep-sleep wakeup, system-mode change), the daemon iterates all registered members and sequentially calls each member&#8217;s registered pre-change handler, ensuring orderly preparation across the stack.<\/li>\n\n\n\n<li><strong>Memory Management<\/strong>: Provides typed memory allocation (<code>IARM_Malloc<\/code> \/ <code>IARM_Free<\/code>) for process-local memory. Arguments and event data are serialized by value across process boundaries, with each allocation prefixed by a size field to support D-Bus byte-array transfer.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\">Design<\/h2>\n\n\n\n<p>IARM Bus is designed around a daemon-centric hub-and-spoke model where a single long-running daemon process (<code>IARMDaemonMain<\/code>) acts as the coordinator, and all middleware clients link a shared library (<code>libIARMBus<\/code>) to connect to it. The underlying transport uses D-Bus as the IPC mechanism, selected at build time via the <code>_USE_DBUS<\/code> flag. The library abstracts all D-Bus message construction, dispatch, and filtering so that client code interacts only with the IARM API rather than D-Bus primitives. The daemon and client both share the same <code>libIARMBus<\/code>, meaning the daemon is itself a bus member registered under the name <code>\"Daemon\"<\/code>. The maximum string length for all member and method names on the bus is 64 characters (<code>IARM_MAX_NAME_LEN<\/code>), enforced throughout the API.<\/p>\n\n\n\n<p>Northbound, the API surface (<code>libIBus.h<\/code>) exposes a lifecycle sequence: <code>IARM_Bus_Init()<\/code> \u2192 <code>IARM_Bus_Connect()<\/code> \u2192 use APIs \u2192 <code>IARM_Bus_Disconnect()<\/code> \u2192 <code>IARM_Bus_Term()<\/code>. Clients register event handlers and RPC methods only after connecting. Southbound, the D-Bus layer (<code>libIARM-dbus.c<\/code>) creates three <code>DBusConnection<\/code> handles per process \u2014 <code>conn<\/code> for incoming message dispatch, <code>connEvent<\/code> for outgoing event signals, and <code>connMethodCall<\/code> for outgoing blocking RPC calls \u2014 and spawns two dedicated dispatch threads each running a D-Bus read-write-dispatch loop. Method calls are serialized by a recursive <code>pthread_mutex<\/code> (<code>m_Lock<\/code>), which protects the registered call list and event handler list.<\/p>\n\n\n\n<p>IPC is implemented exclusively over D-Bus. Method calls use <code>dbus_message_is_method_call()<\/code> against the <code>iarm.method.Type<\/code> interface, and events are dispatched as D-Bus signals on the <code>iarm.signal.Type<\/code> interface. Event data and RPC arguments are passed by value using a <code>memcpy<\/code>-equivalent byte-array serialization, which is why the API explicitly prohibits pointer members inside argument structures. The memory allocation layer prefixes each allocation with a <code>size_t<\/code> length field so the D-Bus serializer can determine the byte count without an additional parameter.<\/p>\n\n\n\n<p>Membership information is maintained entirely in the daemon&#8217;s in-memory <code>m_registeredList<\/code> (a GLib <code>GList<\/code>), and resource ownership is tracked in the <code>m_resourceOwner[]<\/code> array. Both structures are initialized fresh on each daemon startup. Log output is routed to <code>uimgr_log.txt<\/code> via the syslog-ng filter configured in the bb file.<\/p>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">graph TD\n    subgraph IARMBusDaemon [\"IARMDaemonMain (iarmbusd)\"]\n        subgraph DaemonCore [\"Daemon Core (libIBusDaemon-dbus.c)\"]\n            MemberReg[\"Member Registry\\n(m_registeredList)\"]\n            ResOwnership[\"Resource Ownership\\n(m_resourceOwner[])\"]\n            PreChangeList[\"Pre-Change Handler List\\n(m_preChangeRpcList)\"]\n        end\n\n        subgraph ClientLib [\"Client Library (libIARMBus)\"]\n            BusAPI[\"Bus API\\n(libIBus-dbus.c)\"]\n            CoreLayer[\"Core \/ D-Bus Layer\\n(libIARM-dbus.c)\"]\n        end\n\n        subgraph DispatchThread [\"Dispatch Thread\"]\n            DBusLoop[\"D-Bus Main Loop\\n(DBusConnection dispatch)\"]\n        end\n    end\n\n    subgraph MiddlewareClient [\"Middleware Client Process\"]\n        ClientAPI[\"libIARMBus\\n(IARM_Bus_Init \/ Connect)\"]\n        EventHandlers[\"Registered Event Handlers\"]\n        RPCHandlers[\"Registered RPC Methods\"]\n    end\n\n    ClientAPI -->|D-Bus method call| BusAPI\n    BusAPI --> CoreLayer\n    CoreLayer --> DBusLoop\n    DBusLoop -->|Signal dispatch| EventHandlers\n    DBusLoop -->|Method call dispatch| RPCHandlers\n    BusAPI --> MemberReg\n    BusAPI --> ResOwnership\n    BusAPI --> PreChangeList<\/pre><\/div>\n\n\n\n<h3 class=\"wp-block-heading\">Threading Model<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Threading Architecture<\/strong>: Multi-threaded; each connected process has a dedicated dispatch thread in addition to the calling thread.<\/li>\n\n\n\n<li><strong>Main Thread<\/strong>: Handles <code>IARM_Bus_Init<\/code>, <code>IARM_Bus_Connect<\/code>, <code>IARM_Bus_RegisterCall<\/code>, <code>IARM_Bus_RegisterEventHandler<\/code>, and all outgoing <code>IARM_Bus_BroadcastEvent<\/code> \/ <code>IARM_Bus_Call<\/code> invocations.<\/li>\n\n\n\n<li><strong>Worker Threads<\/strong>:<\/li>\n\n\n\n<li><em>Dispatch thread<\/em> (<code>&lt;memberName>_IARMD<\/code>): Runs the D-Bus connection&#8217;s main loop for a member, invoking registered event listeners and RPC handlers when messages arrive. The thread name is set via <code>prctl(PR_SET_NAME, ...)<\/code> using a suffix <code>_IARMD<\/code> appended to the member name, confirmed in <code>libIARM-dbus.c<\/code>.<\/li>\n\n\n\n<li><em>Method-call dispatch thread<\/em>: Runs <code>dbus_connection_read_write_dispatch()<\/code> on <code>connMethodCall<\/code>. Outgoing blocking RPC calls via <code>IARM_CallWithTimeout<\/code> also use <code>connMethodCall<\/code>, keeping outgoing calls off the main <code>conn<\/code> dispatch loop to avoid deadlock.<\/li>\n\n\n\n<li><strong>Synchronization<\/strong>: A process-wide recursive <code>pthread_mutex_t m_Lock<\/code> (initialized as <code>PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP<\/code>) serializes access to the registered call list (<code>m_registeredCallList<\/code>) and event handler list (<code>m_eventHandlerList<\/code>).<\/li>\n\n\n\n<li><strong>Async \/ Event Dispatch<\/strong>: Event callbacks are invoked from the dispatch thread. The <code>IARM_Bus_BroadcastEvent()<\/code> caller is unblocked immediately after the D-Bus signal is sent; listeners are notified asynchronously on their own dispatch threads.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">RDK-V Platform and Integration Requirements<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Build Dependencies<\/strong>: <code>libxml2<\/code>, <code>dbus<\/code>, <code>glib-2.0<\/code>, <code>safec-common-wrapper<\/code>. Conditionally depends on <code>directfb<\/code> (when the <code>directfb<\/code> distro feature is enabled) and <code>systemd<\/code> (when the <code>systemd<\/code> distro feature is enabled), as declared in the bb file.<\/li>\n\n\n\n<li><strong>Systemd Services<\/strong>: The D-Bus system daemon (<code>dbus.service<\/code>) must be running before <code>iarmbusd<\/code> starts, as declared by <code>After=dbus.service<\/code> in the service unit.<\/li>\n\n\n\n<li><strong>Startup Order<\/strong>: <code>iarmbusd.service<\/code> is ordered after <code>dbus.service<\/code> and is part of <code>multi-user.target<\/code>. All other RDK middleware services that use IARM Bus must start after <code>iarmbusd<\/code> is active.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h3 class=\"wp-block-heading\">Component State Flow<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\">Initialization to Active State<\/h4>\n\n\n\n<p>The daemon transitions through the following states: <strong>Starting<\/strong> (signal handlers registered, logger initialized) \u2192 <strong>DaemonInit<\/strong> (<code>IARM_Bus_DaemonStart<\/code>: <code>IARM_Bus_Init<\/code> + <code>IARM_Bus_Connect<\/code>) \u2192 <strong>RPC Registration<\/strong> (all daemon RPC methods registered with <code>IARM_Bus_RegisterCall<\/code>) \u2192 <strong>Active<\/strong> (heartbeat loop; accepting member registrations, events, and RPC calls) \u2192 <strong>Shutdown<\/strong> (<code>IARM_Bus_DaemonStop<\/code>: <code>Disconnect<\/code> + <code>Term<\/code>).<\/p>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">sequenceDiagram\n    participant System as systemd\n    participant Main as IARMDaemonMain\n    participant DaemonLib as libIBusDaemon\n    participant Bus as libIARMBus\n\n    System->>Main: Start IARMDaemonMain\n    Main->>Main: signals_register SIGINT SIGTERM\n    Main->>Main: rdk_logger_init (when RDK_LOGGER_ENABLED)\n    Main->>DaemonLib: IARM_Bus_DaemonStart()\n    DaemonLib->>Bus: IARM_Bus_Init(Daemon)\n    Bus-->>DaemonLib: Initialized\n    DaemonLib->>Bus: IARM_Bus_Connect()\n    Bus-->>DaemonLib: Connected, dispatch thread started\n    DaemonLib->>Bus: IARM_Bus_RegisterEvent(IARM_BUS_SIGNAL_MAX)\n    DaemonLib->>Bus: IARM_Bus_RegisterCall(RequestOwnership)\n    DaemonLib->>Bus: IARM_Bus_RegisterCall(ReleaseOwnership)\n    DaemonLib->>Bus: IARM_Bus_RegisterCall(RegisterMember)\n    DaemonLib->>Bus: IARM_Bus_RegisterCall(UnRegisterMember)\n    DaemonLib->>Bus: IARM_Bus_RegisterCall(PowerPreChange)\n    DaemonLib->>Bus: IARM_Bus_RegisterCall(CheckRegistration)\n    DaemonLib->>Bus: IARM_Bus_RegisterCall(ResolutionPreChange)\n    DaemonLib->>Bus: IARM_Bus_RegisterCall(ResolutionPostChange)\n    DaemonLib->>Bus: IARM_Bus_RegisterCall(SysModeChange)\n    DaemonLib->>Bus: IARM_Bus_RegisterCall(DeepSleepWakeup)\n    DaemonLib-->>Main: DaemonStart returns SUCCESS\n    Main->>System: sd_notifyf(READY=1) when ENABLE_SD_NOTIFY\n\n    loop Heartbeat (every 300s)\n        Main->>Main: Log heartbeat ping\n    end\n\n    System->>Main: SIGTERM or SIGINT\n    Main->>Main: g_running = 0\n    Main->>DaemonLib: IARM_Bus_DaemonStop()\n    DaemonLib->>Bus: IARM_Bus_Disconnect()\n    DaemonLib->>Bus: IARM_Bus_Term()<\/pre><\/div>\n\n\n\n<h4 class=\"wp-block-heading\">Runtime State Changes<\/h4>\n\n\n\n<p>The daemon&#8217;s primary runtime role is processing incoming RPC calls from members. The key runtime state managed by the daemon is the member registry and resource ownership table, both held entirely in memory.<\/p>\n\n\n\n<p><strong>State Change Triggers:<\/strong><\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>A middleware client calling <code>IARM_Bus_Connect()<\/code> triggers a <code>RegisterMember<\/code> RPC to the daemon, adding the member to <code>m_registeredList<\/code>. Disconnection triggers <code>UnRegisterMember<\/code>, which also force-releases any resources still owned by that member.<\/li>\n\n\n\n<li>A power manager or equivalent component calling <code>IARM_BusDaemon_RequestOwnership()<\/code> for a resource type triggers <code>_RequestOwnership<\/code> in the daemon; if the resource is currently held by another member, the daemon calls <code>IARM_Bus_Call(..., IARM_BUS_COMMON_API_ReleaseOwnership, ...)<\/code> on the current owner before transferring ownership.<\/li>\n\n\n\n<li>When a resource is released via <code>_ReleaseOwnership<\/code>, the daemon broadcasts <code>IARM_BUS_EVENT_RESOURCEAVAILABLE<\/code> so interested members can re-request the resource.<\/li>\n<\/ul>\n\n\n\n<p><strong>Context Switching Scenarios:<\/strong><\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Before a power state transition, the component managing the power change calls <code>IARM_BusDaemon_PowerPrechange()<\/code>, which causes the daemon to iterate all registered members and invoke each member&#8217;s <code>IARM_BUS_COMMON_API_PowerPreChange<\/code> handler in sequence.<\/li>\n\n\n\n<li>Before and after a display resolution change, coordinated calls to <code>IARM_BusDaemon_ResolutionPrechange()<\/code> and <code>IARM_BusDaemon_ResolutionPostchange()<\/code> distribute the new width\/height to all registered pre-change handlers.<\/li>\n\n\n\n<li>On deep-sleep wakeup, <code>IARM_BusDaemon_DeepSleepWakeup()<\/code> is called, triggering the equivalent pre-change iteration for all handlers registered for <code>IARM_BUS_COMMON_API_DeepSleepWakeup<\/code>.<\/li>\n\n\n\n<li>On system-mode change (Normal \/ EAS \/ Warehouse), the daemon dispatches to all members with a registered <code>IARM_BUS_COMMON_API_SysModeChange<\/code> handler.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h3 class=\"wp-block-heading\">Call Flows<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\">Initialization Call Flow<\/h4>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">sequenceDiagram\n    participant ClientApp as CecDaemonMain\n    participant LibBus as libIARMBus\n    participant DBus as D-Bus\n    participant Daemon as IARMDaemonMain\n\n    ClientApp->>LibBus: IARM_Bus_Init(CecDaemonMain)\n    LibBus->>LibBus: IARM_Init(IARM_BUS_NAME, CecDaemonMain)\n    LibBus->>LibBus: IARM_Malloc(PROCESSLOCAL, sizeof(IARM_Bus_Member_t))\n    LibBus-->>ClientApp: IARM_RESULT_SUCCESS, m_initialized=1\n\n    ClientApp->>LibBus: IARM_Bus_Connect()\n    LibBus->>DBus: dbus_bus_get_private() - acquire system bus connections\n    LibBus->>LibBus: Spawn dispatch thread (CecDaemonMain_IARMD)\n    LibBus->>Daemon: IARM_Bus_Call(Daemon, RegisterMember, member_info)\n    Daemon->>Daemon: _RegisterMember() - add to m_registeredList\n    Daemon-->>LibBus: IARM_RESULT_SUCCESS\n    LibBus-->>ClientApp: IARM_RESULT_SUCCESS, m_connected=1<\/pre><\/div>\n\n\n\n<h4 class=\"wp-block-heading\">Request Processing Call Flow \u2014 Event Broadcast<\/h4>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">sequenceDiagram\n    participant Publisher as Publisher Process\n    participant LibBus as libIARMBus\n    participant DBus as D-Bus\n    participant Subscriber as Subscriber Process\n\n    Publisher->>LibBus: IARM_Bus_BroadcastEvent('OwnerName', eventId, data, len)\n    LibBus->>DBus: dbus_message_new_signal(iarm.signal.Type)\n    LibBus->>DBus: Append eventId, ownerName, size, data bytes\n    DBus-->>Publisher: Signal sent, returns to caller\n\n    DBus->>Subscriber: D-Bus signal delivered to dispatch thread\n    Subscriber->>Subscriber: dbusCallHandler() filters by eventId + ownerName\n    Subscriber->>Subscriber: eventInfo.listener() callback invoked<\/pre><\/div>\n\n\n\n<h4 class=\"wp-block-heading\">Request Processing Call Flow \u2014 RPC Method Call<\/h4>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">sequenceDiagram\n    participant Caller as Caller Process\n    participant LibBus as libIARMBus\n    participant DBus as D-Bus\n    participant Callee as Callee Process\n\n    Caller->>LibBus: IARM_Bus_Call('OwnerName', 'MethodName', arg, argLen)\n    LibBus->>DBus: dbus_message_new_method_call(iarm.method.Type, MethodName)\n    LibBus->>DBus: Append size + arg[] as byte array\n    DBus->>Callee: Method call delivered to dispatch thread\n    Callee->>Callee: dbusCallHandler() dispatches to registered handler\n    Callee->>Callee: callInfo.handler() executes, writes result into arg\n    DBus-->>LibBus: Method reply received\n    LibBus-->>Caller: IARM_RESULT_SUCCESS, arg contains output<\/pre><\/div>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\">Internal Modules<\/h2>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Module \/ Class<\/th><th>Description<\/th><th>Key Files<\/th><\/tr><\/thead><tbody><tr><td><code>IARMDaemonMain<\/code><\/td><td>Entry point for the bus daemon. Registers signal handlers (SIGINT, SIGTERM), initializes the logger, calls <code>IARM_Bus_DaemonStart()<\/code>, sends systemd readiness notification (when <code>ENABLE_SD_NOTIFY<\/code> is defined), and runs the heartbeat loop until shutdown.<\/td><td><code>IARMDaemonMain-dbus.c<\/code><\/td><\/tr><tr><td><code>libIBusDaemon<\/code><\/td><td>Daemon-side logic. Implements all daemon RPC handlers (<code>_RegisterMember<\/code>, <code>_UnRegisterMember<\/code>, <code>_RequestOwnership<\/code>, <code>_ReleaseOwnership<\/code>, <code>_CheckRegistration<\/code>, <code>_PowerPreChange<\/code>, <code>_DeepSleepWakeup<\/code>, <code>_ResolutionPreChange<\/code>, <code>_ResolutionPostChange<\/code>, <code>_SysModeChange<\/code>, <code>_RegisterPreChange<\/code>). Maintains the member registry (<code>m_registeredList<\/code>) and resource ownership table (<code>m_resourceOwner[]<\/code>).<\/td><td><code>libIBusDaemon-dbus.c<\/code><\/td><\/tr><tr><td><code>libIBus<\/code><\/td><td>Client-facing Bus API layer. Implements <code>IARM_Bus_Init<\/code>, <code>IARM_Bus_Term<\/code>, <code>IARM_Bus_Connect<\/code>, <code>IARM_Bus_Disconnect<\/code>, <code>IARM_Bus_BroadcastEvent<\/code>, <code>IARM_Bus_RegisterEventHandler<\/code>, <code>IARM_Bus_UnRegisterEventHandler<\/code>, <code>IARM_Bus_RemoveEventHandler<\/code>, <code>IARM_Bus_RegisterCall<\/code>, <code>IARM_Bus_Call<\/code>, <code>IARM_Bus_Call_with_IPCTimeout<\/code>, <code>IARM_Bus_RegisterEvent<\/code>, and <code>IARM_Bus_IsConnected<\/code>. Wraps the core layer and manages the per-process call and event handler lists protected by <code>m_Lock<\/code>.<\/td><td><code>libIBus-dbus.c<\/code><\/td><\/tr><tr><td><code>libIARMCore<\/code><\/td><td>Core D-Bus transport layer. Manages <code>IARM_Ctx_t<\/code> per-process context holding three <code>DBusConnection<\/code> handles (<code>conn<\/code>, <code>connEvent<\/code>, <code>connMethodCall<\/code>) and two dispatch threads. Implements <code>IARM_Init<\/code>, <code>IARM_Malloc<\/code>, <code>IARM_Free<\/code>, <code>IARM_RegisterCall<\/code>, <code>IARM_Call<\/code>, <code>IARM_CallWithTimeout<\/code>, <code>IARM_RegisterListner<\/code>. Handles D-Bus message construction, filtering (<code>dbusCallHandler<\/code>), and memory size-prefixing for argument serialization.<\/td><td><code>libIARM-dbus.c<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\">Component Interactions<\/h2>\n\n\n\n<p>IARM Bus operates as an infrastructure component, providing the IPC fabric that other middleware components use to communicate. Its interactions span the D-Bus transport layer, the systemd service manager, and the middleware clients that connect to the bus.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Interaction Matrix<\/h3>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Target Component \/ Layer<\/th><th>Interaction Purpose<\/th><th>Key APIs \/ Topics<\/th><\/tr><\/thead><tbody><tr><td><strong>D-Bus System Bus<\/strong><\/td><td>Underlying transport for all IARM messages<\/td><td><code>dbus_bus_get_private()<\/code>, <code>dbus_message_new_method_call()<\/code>, <code>dbus_message_new_signal()<\/code>, <code>dbus_connection_send_with_reply_and_block()<\/code>, <code>dbus_connection_send()<\/code><\/td><\/tr><tr><td><strong>systemd<\/strong><\/td><td>Daemon readiness signaling and service lifecycle<\/td><td><code>sd_notifyf(READY=1, ...)<\/code> (when <code>ENABLE_SD_NOTIFY<\/code> is defined)<\/td><\/tr><tr><td><strong>All IARM Bus members<\/strong><\/td><td>Member registration and deregistration on connect\/disconnect<\/td><td><code>IARM_BUS_DAEMON_API_RegisterMember<\/code>, <code>IARM_BUS_DAEMON_API_UnRegisterMember<\/code><\/td><\/tr><tr><td><strong>All IARM Bus members<\/strong><\/td><td>Coordinated pre-change notification before power, resolution, and mode transitions<\/td><td><code>IARM_BUS_COMMON_API_PowerPreChange<\/code>, <code>IARM_BUS_COMMON_API_ResolutionPreChange<\/code>, <code>IARM_BUS_COMMON_API_ResolutionPostChange<\/code>, <code>IARM_BUS_COMMON_API_DeepSleepWakeup<\/code>, <code>IARM_BUS_COMMON_API_SysModeChange<\/code><\/td><\/tr><tr><td><strong>Resource-owning members<\/strong><\/td><td>Exclusive resource arbitration<\/td><td><code>IARM_BUS_DAEMON_API_RequestOwnership<\/code>, <code>IARM_BUS_DAEMON_API_ReleaseOwnership<\/code>, <code>IARM_BUS_COMMON_API_ReleaseOwnership<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\">Events Published<\/h3>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Event Name<\/th><th>IARM Topic<\/th><th>Trigger Condition<\/th><th>Subscriber Components<\/th><\/tr><\/thead><tbody><tr><td><code>IARM_BUS_EVENT_RESOURCEAVAILABLE<\/code><\/td><td><code>Daemon<\/code> \/ <code>IARM_BUS_EVENT_RESOURCEAVAILABLE<\/code><\/td><td>A registered member releases ownership of a shared resource via <code>_ReleaseOwnership<\/code><\/td><td>Any member that previously requested the resource and was denied, or that monitors resource availability<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\">IPC Flow Patterns<\/h3>\n\n\n\n<p><strong>Primary Request \/ Response Flow (RPC):<\/strong><\/p>\n\n\n\n<p>When a caller invokes <code>IARM_Bus_Call()<\/code>, the client library serializes the argument structure into a D-Bus byte-array method call and blocks on the reply. The callee&#8217;s dispatch thread receives the D-Bus method call in <code>dbusCallHandler()<\/code>, extracts the argument buffer, invokes the registered <code>IARM_BusCall_t<\/code> handler, and the reply is sent back through the D-Bus connection. The result is written into the shared argument buffer and returned to the caller.<\/p>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">sequenceDiagram\n    participant Caller as Caller Process\n    participant Bus as libIARMBus\n    participant Callee as Callee Process\n\n    Caller->>Bus: IARM_Bus_Call(ownerName, methodName, arg, argLen)\n    Bus->>Callee: D-Bus method call on iarm.method.Type\n    Callee->>Callee: dbusCallHandler() invokes registered IARM_BusCall_t handler(arg)\n    Callee-->>Bus: D-Bus method reply\n    Bus-->>Caller: IARM_RESULT_SUCCESS, output in arg<\/pre><\/div>\n\n\n\n<p><strong>Event Notification Flow:<\/strong><\/p>\n\n\n\n<p>When a process calls <code>IARM_Bus_BroadcastEvent()<\/code>, the library constructs a D-Bus signal carrying the event ID, owner name, data size, and data bytes, and sends it on the session bus. Each subscriber process&#8217;s dispatch thread receives the signal, and <code>dbusCallHandler()<\/code> filters it by event ID and owner name before invoking the registered <code>IARM_EventHandler_t<\/code> callback.<\/p>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">sequenceDiagram\n    participant Publisher as Event Publisher\n    participant Bus as D-Bus\n    participant Sub1 as Subscriber 1\n    participant Sub2 as Subscriber 2\n\n    Publisher->>Bus: IARM_Bus_BroadcastEvent(ownerName, eventId, data, len)\n    Bus->>Sub1: D-Bus signal (iarm.signal.Type)\n    Bus->>Sub2: D-Bus signal (iarm.signal.Type)\n    Sub1->>Sub1: dbusCallHandler() invokes IARM_EventHandler_t callback\n    Sub2->>Sub2: dbusCallHandler() invokes IARM_EventHandler_t callback<\/pre><\/div>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\">Implementation Details<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Major HAL APIs Integration<\/h3>\n\n\n\n<p>The following D-Bus library and system functions are called directly by the IARM Bus implementation.<\/p>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>API<\/th><th>Purpose<\/th><th>Implementation File<\/th><\/tr><\/thead><tbody><tr><td><code>dbus_bus_get_private()<\/code><\/td><td>Acquire private connections to the D-Bus system bus<\/td><td><code>libIARM-dbus.c<\/code><\/td><\/tr><tr><td><code>dbus_message_new_method_call()<\/code><\/td><td>Construct an outgoing RPC method call message<\/td><td><code>libIARM-dbus.c<\/code><\/td><\/tr><tr><td><code>dbus_message_new_signal()<\/code><\/td><td>Construct an outgoing event (signal) message<\/td><td><code>libIARM-dbus.c<\/code><\/td><\/tr><tr><td><code>dbus_connection_send_with_reply_and_block()<\/code><\/td><td>Send a method call and block for the reply<\/td><td><code>libIARM-dbus.c<\/code><\/td><\/tr><tr><td><code>dbus_connection_send()<\/code><\/td><td>Send a signal without waiting for reply<\/td><td><code>libIARM-dbus.c<\/code><\/td><\/tr><tr><td><code>dbus_connection_add_filter()<\/code><\/td><td>Register <code>dbusCallHandler<\/code> as the message filter for a connection<\/td><td><code>libIARM-dbus.c<\/code><\/td><\/tr><tr><td><code>sd_notifyf()<\/code><\/td><td>Send systemd service-readiness notification<\/td><td><code>IARMDaemonMain-dbus.c<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\">Key Implementation Logic<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>State \/ Lifecycle Management<\/strong>: Process state is tracked with two <code>volatile int<\/code> flags \u2014 <code>m_initialized<\/code> and <code>m_connected<\/code> \u2014 guarded by the recursive <code>m_Lock<\/code> mutex. Both must be in the correct state for any API call to proceed; otherwise <code>IARM_RESULT_INVALID_STATE<\/code> or <code>IARM_RESULT_INVALID_PARAM<\/code> is returned.<\/li>\n\n\n\n<li>Core init\/term logic: <code>libIBus-dbus.c<\/code>, <code>libIARM-dbus.c<\/code><\/li>\n\n\n\n<li>Daemon member-list management: <code>libIBusDaemon-dbus.c<\/code><\/li>\n\n\n\n<li><strong>Event Processing<\/strong>: Events are dispatched by the per-process dispatch thread running the D-Bus main loop. The <code>dbusCallHandler<\/code> function is registered as a connection filter and distinguishes between incoming signals (<code>iarm.signal.Type<\/code>) and method calls (<code>iarm.method.Type<\/code>) by interface name. Event filtering by <code>eventId<\/code> and <code>ownerName<\/code> is applied before invoking the registered handler; mismatched messages fall through to <code>DBUS_HANDLER_RESULT_NOT_YET_HANDLED<\/code>.<\/li>\n\n\n\n<li>Message filter and dispatch: <code>libIARM-dbus.c<\/code> (<code>dbusCallHandler<\/code>)<\/li>\n\n\n\n<li>Handler registration list: <code>libIBus-dbus.c<\/code> (<code>m_eventHandlerList<\/code>)<\/li>\n\n\n\n<li><strong>Error Handling Strategy<\/strong>: Each IARM API returns an <code>IARM_Result_t<\/code> code. Errors from the D-Bus layer are mapped to <code>IARM_RESULT_IPCCORE_FAIL<\/code>. Null or out-of-range parameters map to <code>IARM_RESULT_INVALID_PARAM<\/code>. Memory allocation failures return <code>IARM_RESULT_OOM<\/code>. The daemon&#8217;s pre-change dispatchers (<code>_PowerPreChange<\/code>, <code>_ResolutionPreChange<\/code>, etc.) continue iterating through all registered members regardless of individual call outcomes, ensuring every member receives the notification.<\/li>\n\n\n\n<li><strong>Logging &amp; Diagnostics<\/strong>: When <code>RDK_LOGGER_ENABLED<\/code> is defined, log output is routed through <code>RDK_LOG(RDK_LOG_DEBUG, \"LOG.RDK.IARMBUS\", ...)<\/code>. When the flag is absent, output falls back to <code>printf<\/code>. The <code>IARM_Bus_RegisterForLog()<\/code> API allows a caller to inject a custom log callback (<code>IARM_Bus_LogCb<\/code>). Each log message is prefixed with the thread ID using <code>syscall(SYS_gettid)<\/code>. Log output is routed to <code>uimgr_log.txt<\/code> via the syslog-ng filter configured in the bb file.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\">Configuration<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Key Configuration Files<\/h3>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Configuration File<\/th><th>Purpose<\/th><th>Override Mechanism<\/th><\/tr><\/thead><tbody><tr><td><code>conf\/iarmbusd.service<\/code><\/td><td>systemd unit that starts <code>IARMDaemonMain<\/code>, sets log output path, declares <code>After=dbus.service<\/code>, and marks the service type as <code>notify<\/code><\/td><td>Replaced or masked via standard systemd override mechanisms<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\">Key Configuration Parameters<\/h3>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Parameter<\/th><th>Type<\/th><th>Default<\/th><th>Description<\/th><\/tr><\/thead><tbody><tr><td><code>ENABLE_SD_NOTIFY<\/code><\/td><td>Compile-time flag<\/td><td>Enabled (set in bb file)<\/td><td>When defined, the daemon calls <code>sd_notifyf(READY=1, ...)<\/code> after <code>IARM_Bus_DaemonStart()<\/code> completes, enabling systemd to track service readiness.<\/td><\/tr><tr><td><code>_USE_DBUS<\/code><\/td><td>Compile-time flag<\/td><td>Enabled (set in <code>core\/Makefile.am<\/code>)<\/td><td>Selects the D-Bus-backed implementation files (<code>libIARM-dbus.c<\/code>, <code>libIBus-dbus.c<\/code>, <code>libIBusDaemon-dbus.c<\/code>) for compilation.<\/td><\/tr><tr><td><code>RDK_LOGGER_ENABLED<\/code><\/td><td>Compile-time flag<\/td><td>Platform-dependent<\/td><td>When defined, routes diagnostic output through the RDK logger (<code>LOG.RDK.IARMBUS<\/code>) instead of <code>printf<\/code>.<\/td><\/tr><tr><td><code>SAFEC_DUMMY_API<\/code><\/td><td>Compile-time flag<\/td><td>Set when <code>safec<\/code> is omitted from <code>DISTRO_FEATURES<\/code><\/td><td>Activates stub implementations of safe-C string and memory functions, substituting standard library equivalents on platforms that build without the <code>safec<\/code> library.<\/td><\/tr><tr><td><code>PID_FILE_PATH<\/code><\/td><td>Compile-time path<\/td><td>Not set by default<\/td><td>When defined, the daemon writes a PID file at <code>&lt;PID_FILE_PATH&gt;\/iarmbusd.pid<\/code> after startup, providing a readiness indicator for container environments that rely on PID files rather than <code>sd_notify<\/code>.<\/td><\/tr><\/tbody><\/table><\/figure>\n","protected":false},"excerpt":{"rendered":"<p>IARM Bus (Inter-Application Resource Manager Bus) is a platform-agnostic Inter-Process Communication (IPC) interface for the [&hellip;]<\/p>\n","protected":false},"author":28,"featured_media":0,"parent":9844,"menu_order":0,"comment_status":"open","ping_status":"closed","template":"","meta":{"_bbp_topic_count":0,"_bbp_reply_count":0,"_bbp_total_topic_count":0,"_bbp_total_reply_count":0,"_bbp_voice_count":0,"_bbp_anonymous_reply_count":0,"_bbp_topic_count_hidden":0,"_bbp_reply_count_hidden":0,"_bbp_forum_subforum_count":0,"footnotes":""},"class_list":["post-9848","page","type-page","status-publish","hentry"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v24.9 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>IARM Bus - RDK Documentation Portal | Documentation<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"IARM Bus - RDK Documentation Portal | Documentation\" \/>\n<meta property=\"og:description\" content=\"IARM Bus (Inter-Application Resource Manager Bus) is a platform-agnostic Inter-Process Communication (IPC) interface for the [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/\" \/>\n<meta property=\"og:site_name\" content=\"RDK Documentation Portal | Documentation\" \/>\n<meta property=\"article:modified_time\" content=\"2026-07-30T10:51:31+00:00\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"9 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/\",\"url\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/\",\"name\":\"IARM Bus - RDK Documentation Portal | Documentation\",\"isPartOf\":{\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/#website\"},\"datePublished\":\"2022-06-21T09:10:23+00:00\",\"dateModified\":\"2026-07-30T10:51:31+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Documentation\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"RDK Video\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Components\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/\"},{\"@type\":\"ListItem\",\"position\":5,\"name\":\"IARM Bus\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/#website\",\"url\":\"https:\/\/developer.rdkcentral.com\/documentation\/\",\"name\":\"RDK Documentation Portal | Documentation\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/developer.rdkcentral.com\/documentation\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"IARM Bus - RDK Documentation Portal | Documentation","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/","og_locale":"en_US","og_type":"article","og_title":"IARM Bus - RDK Documentation Portal | Documentation","og_description":"IARM Bus (Inter-Application Resource Manager Bus) is a platform-agnostic Inter-Process Communication (IPC) interface for the [&hellip;]","og_url":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/","og_site_name":"RDK Documentation Portal | Documentation","article_modified_time":"2026-07-30T10:51:31+00:00","twitter_card":"summary_large_image","twitter_misc":{"Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/","url":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/","name":"IARM Bus - RDK Documentation Portal | Documentation","isPartOf":{"@id":"https:\/\/developer.rdkcentral.com\/documentation\/#website"},"datePublished":"2022-06-21T09:10:23+00:00","dateModified":"2026-07-30T10:51:31+00:00","breadcrumb":{"@id":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/iarm_bus\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/developer.rdkcentral.com\/documentation\/"},{"@type":"ListItem","position":2,"name":"Documentation","item":"https:\/\/developer.rdkcentral.com\/documentation\/"},{"@type":"ListItem","position":3,"name":"RDK Video","item":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/"},{"@type":"ListItem","position":4,"name":"Components","item":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/"},{"@type":"ListItem","position":5,"name":"IARM Bus"}]},{"@type":"WebSite","@id":"https:\/\/developer.rdkcentral.com\/documentation\/#website","url":"https:\/\/developer.rdkcentral.com\/documentation\/","name":"RDK Documentation Portal | Documentation","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/developer.rdkcentral.com\/documentation\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"}]}},"_links":{"self":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/9848","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/users\/28"}],"replies":[{"embeddable":true,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/comments?post=9848"}],"version-history":[{"count":10,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/9848\/revisions"}],"predecessor-version":[{"id":12996,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/9848\/revisions\/12996"}],"up":[{"embeddable":true,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/9844"}],"wp:attachment":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/media?parent=9848"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}