RDK Resources
[*RDK Preferred*]
Code Management Facility
RDK Forums
[RDK Conferences]
RDK Support
Archives
Papers & Presentations Archive
Ripple is derived from Firebolt Reference implementation, it is a Rust-based Application gateway that provides support for System, Native, and 3rd party applications for Video-based devices. Ripple will provide a Firebolt Gateway which will be used by Distributors and App Developers to interact with the Application platform to discover, launch, and manage video streaming applications.
Standardization: Ripple provides a secure and standardized Firebolt API gateway for 3rd party applications to communicate with the underlying platform.
Certification: Ripple versions are certified using a stringent set of Firebolt Certification suites and it can be tested across multiple platforms. This offers increased quality control which can be scaled across devices and operators.
Abstraction: Ripple abstracts the applications from the underlying platform such that the platform can be upgraded or changed altogether.
Extensible: Ripple can extend to multiple device types and platforms through Extensions more about it here. // insert link
Configurable: Ripple uses Manifests, RFC(thunder), Contracts, and best of all Extensions to offer configurations for Operators and App developers.
Secure: Ripple uses Firebolt capabilities and defines multiple layers of checks like Supported, Availablity, Permitted, and User Grants to ensure Consumer Privacy and App Security.
Portable: Ripple is small in size and can be easily bundled into the device. App Platform developers can build Extensions by fulfilling the contracts defined in the Ripple SDK.
Video Accelerator device uses Navigator UI to offer a Video Platform experience on these devices.
Video Accelerator UI version 4 will use Ripple to offer support for Firebolt applications which are part of the catalog.
Ripple can be found in Github Repo https://github.com/rdkcentral/Ripple
The preferred developer environment would include
More instructions here
Pre-commit is the preferred tool used for setting up the git hook for local development.
Ripple uses Clippy for local git hooks to do format and static analysis on the code before it is committed. So always run precommit install
on a new workspace.
Detailed instructions are provided here
Rust was chosen as the programming language for Ripple for mainly below reasons
Rust in itself offers many idiomatic principles which makes it unique
Match
pattern syntax which places Arms for a given value. It can use regular datatypes(str, u32, bool), Result, and Options making it more readable for even complex conditions.Extensions in Ripple offer extensibility and faster migration. Below are some of the good use cases where an extension is necessary
Each of these use cases expects something more from each platform when we try to scale across other global partners.
Extensions offer that extra leverage to easily migrate and offer support for these platforms as they try to fully adopt to the Firebolt Architecture.
A contract is a concrete unit of work expected to be fulfilled by a Ripple extension.
Each contract maps to a Request, Response, or Event structure or enumeration defined mostly by Firebolt Openrpc Schema.
An Extension implements a request processor based on the Request structure thereby providing fulfillment of the given contract.
Ripple Main uses the contract definition in the Extn manifest to create a map for Inter Extension Communication.
Standardization: Similar to Ripple offering Firebolt capabilities contracts offer definition and control over the extensions. This provides a layer of abstraction that can be configured by each operator.
Below are some examples
Mapping: Each extension contains a list of contracts that it is expected to fulfill these are clearly defined in the Extension Manifests. Main uses this mapping to redirect the incoming Extn requests to the right extension so they can be correctly processed.
Authorization: Each extension can only fulfill a listed contract in the manifest, this part is a critical component in making sure extensions do not even register a processor for which a contract is not expected to be fulfilled by the manifest.
Permissions: Manifests also has the uses
field for each extension which decides the permissions for each extension in terms of calling other contracts.
TBA