RDK Resources
[*RDK Preferred*]
Code Management Facility
RDK Forums
[RDK Conferences]
RDK Support
Archives
Papers & Presentations Archive
Expand | ||
---|---|---|
| ||
|
This page explains how you as AppDeveloper can create/, compile your native (c/c++) application using DAC SDK and how to publish it to RDK-M staging DAC-Appstore in the cloud staging area.
When your application meets the DAC App contract for binary compatibility it will allow you as AppDeveloper
This video from TechSummit2024 nicely explains bigger picture
Here is overview of DAC solution and following video made by ConsultRed at TechSummit2024 nicely explains that bigger picture dac_overview Multimedia
View file | ||||
---|---|---|---|---|
|
// TO REMOVE This page will guide you through publishing your DAC app to the RDK ASMS cloud as an AppDeveloper, then installing and running it on a Raspberry Pi (RPI). More detailed documentation of all the components used is available on their respective pages.
Table of Contents | ||
---|---|---|
|
Above credentials are one time request per App developer entity. Once you have above credentials, you can reuse them for publishing other apps under your entity. At this moment requesting these credentials is still manual process, a point to improve in future
...
As an Appdeveloper you want to test and run your DAC Application on a set of real hardware reference devices. RDK-M created the Video Accelerators for that.
...
To get your hands on other Video Accelerator HWs and their RDK6.1 SW images, we refer you to RDK-M
Download and install https://www.balena.io/etcher/ tool
sqdsd
Multimedia | ||
---|---|---|
|
Is available on Youtube
'https://www.youtube.com/watch?v=Ie7fQy5HTlc
There are two ways to publish a new application in ASMS:
But before publishing the new app into ASMS, you need to publish the oci compliant container image of your DAC application into a container registry that supports the OCI standard format. In next section we explain how to do that.
You can either publish your oci container image to
Depending on the oci registry product, there are various login/access credential procedures.
We provide the instructions for Amazon Elastic Container Registry. The private container registry setup RDK-M DAC team is also such type.
You need to have the following util programs installed: aws cli tools and skopeo.
Assuming your host is linux, configure your aws profile ~/.aws/credentials file as per below
Code Block | ||
---|---|---|
| ||
//Obviously you need to fill in your credentials below iso xxxxx and yyyyy. If you want to use the private OCI container registry from RDK-M, request piotr.serafin@consult.red for credentials
[s3dacrdk]
aws_access_key_id = xxxxx
aws_secret_access_key = yyyyyy |
Login, create new container repository and publish the OCI image in there:
Code Block | ||
---|---|---|
| ||
# login into private RDK-M OCI container registry
aws --profile s3dacrdk ecr-public get-login-password --region us-east-1 | skopeo login --username AWS --password-stdin public.ecr.aws/a0v6o9z7
# create repo for your application, in which you can publish different versions, example below creates "cobalt" one for Youtube/cobalt application
aws --profile s3dacrdk --region us-east-1 ecr-public create-repository --repository-name cobalt
# list repos
aws --profile s3dacrdk --region us-east-1 ecr-public describe-repositories
# The actual command that uploads/publishes your local version of a oci image associated with your application to the RDK-M oci-registry
# within repo named "cobalt" with the version tag "latest" standing for latest version
skopeo copy oci-archive:dac-image-cobalt.tar docker://public.ecr.aws/a0v6o9z7/cobalt:latest
# with following command you can download your oci image from RDK-M registry to your local host
skopeo copy docker://public.ecr.aws/a0v6o9z7/cobalt:latest oci:cobalttest
# command to double check if uploaded container is oci image type
skopeo inspect --raw docker://public.ecr.aws/a0v6o9z7/cobalt:latest
{
"schemaVersion": 2,
"config": {
"mediaType": "application/vnd.oci.image.config.v1+json",
"size": 548,
"digest": "sha256:0bc2f756fc781b015769230b207c6b227b788023a5c3d599504407cc1619110e"
},
[...]
} |
Obviously, you have to remember the OCI image URL of your application, which in this example is docker://public.ecr.aws/a0v6o9z7/cobalt:latest. Because you will have to specify it when publishing the DAC app to the ASMS (AppStore Metdata service).
You can access the swagger UI here: http://rdkm-asms-external-1156877020.eu-central-1.elb.amazonaws.com:8080/swagger-ui/index.html?configUrl=/v3/api-docs/swagger-config
You can use the POST /maintainers/{maintainerCode/apps RPC call to add an ASMS dac app. dactest.py uses "rdk" as maintainerCode. You will need to provide a POST body with the required contents.
As part of the DAC project, an SDK has been created to make it easier to develop and build oci and DAC compliant containerized applications. The SDK is public, fully open source and uses standard Yocto 3.1 Dunfel Poky environment.
It is available on https://github.com/rdkcentral/meta-dac-sdk
The DAC SDK consists of
build instructions as per https://github.com/rdkcentral/meta-dac-sdk/blob/master/README.md They are copies here but it is best to read the instructions there to be sure they are up to date.
This is the one time "setup" part of the SDK.
Code Block |
---|
# make sure that your Linux host has required packages needed for Yocto.
# These are defined in https://docs.yoctoproject.org/3.1.33/ref-manual/ref-system-requirements.html#required-packages-for-the-build-host
# Create build directory
mkdir build; cd build
# Install 'repo' tool from: https://android.googlesource.com/tools/repo
# following repo commands will download Yocto poky environment and other required meta-layers see manifest of https://github.com/rdkcentral/meta-dac-sdk/blob/master/manifests/dac-dunfell-manifest.xml
repo init -u https://github.com/rdkcentral/meta-dac-sdk/ -m manifests/dac-dunfell-manifest.xml
repo sync --no-clone-bundle -v -j$(getconf _NPROCESSORS_ONLN)
. ./oe-init-build-env
cp ../.repo/manifests/manifests/bblayers.conf conf/
# to build for ARM 32bit
echo 'MACHINE = "raspberrypi4"' >> conf/local.conf |
If everything worked, the SDK is now set up and ready for use. You only need to run above steps the first time you set up the SDK. For subsequent uses, you only need to run the following command to configure the build environment:
Code Block |
---|
cd build
. ./oe-init-build-env |
Now you can proceed with building your AppContainer image
You ask Yocto to build specific DAC AppContainer image by invoking "bitbake <Recipename_AppContainer> "
Before making your own AppContainer image, you can try out the SDK by building one of existing example AppContainer images coming with the SDK and usually already available on RDK-M DAC cloud
Code Block |
---|
# Now you can build the "DAC AppContainer image" of your choice.
# Note that you need to have associated yocto image recipe defined in meta-layer and use that as <your yocto image target>
# as per example image recipes in https://github.com/rdkcentral/meta-dac-sdk/tree/master/recipes-example/images
# use bitbake <your yocto image target> to build the associated dac AppContainer.
# below commands build dac AppContainer examples coming with SDK
bitbake dac-image-wayland-egl-test
bitbake dac-image-wayland-egl-test-input
bitbake dac-image-essos-sample
bitbake dac-image-essos-egl
bitbake dac-image-qt-test
bitbake dac-image-shell
bitbake dac-image-flutter-slide-puzzle
bitbake dac-image-chocolate-doom
bitbake dac-image-cobalt
bitbake dac-image-glmark2
# Or build them all at once
bitbake dac-image-wayland-egl-test dac-image-wayland-egl-test-input dac-image-essos-sample dac-image-essos-egl dac-image-qt-test dac-image-shell dac-image-flutter-slide-puzzle dac-image-glmark2 |
Once the build has succeed you can find your AppContainer image in yocto deploy directory. You will find several files there. The files with symbolic links to files with "oci-image.tar" suffix in the name are the real oci, dobby, dac compliant AppContainer images. Those are the ones you will then need to use in next step (upload to Container registry in cloud)
Code Block |
---|
# AppContainer image is located in deploy dir within yocto build dir (as any other yocto target images)
$cd build/tmp/deploy/images/raspberrypi4/
$ls -lsa | grep oci
35612 -rw-rw-r-- 2 sverkoyen sverkoyen 36464640 Apr 10 11:14 dac-image-cobalt-raspberrypi4-20240410084211.rootfs-oci-latest-arm-linux.oci-image.tar
4 lrwxrwxrwx 2 sverkoyen sverkoyen 86 Apr 10 11:14 dac-image-cobalt.tar -> dac-image-cobalt-raspberrypi4-20240410084211.rootfs-oci-latest-arm-linux.oci-image.tar
9352 -rw-rw-r-- 2 sverkoyen sverkoyen 9574400 Apr 17 15:42 dac-image-glmark2-raspberrypi4-20240417134132.rootfs-oci-latest-arm-linux.oci-image.tar
4 lrwxrwxrwx 2 sverkoyen sverkoyen 87 Apr 17 15:42 dac-image-glmark2.tar -> dac-image-glmark2-raspberrypi4-20240417134132.rootfs-oci-latest-arm-linux.oci-image.tar
# so in this example "dac-image-cobalt.tar" and "dac-image-glmark2.tar" are the oci, dobby, dac compliant AppContainer images |
Below video is a demonstration on how you use the SDK to build Youtube-cobalt as DAC application
Multimedia | ||
---|---|---|
|
same video is also available on Youtube 'https://www.youtube.com/watch?v=Ie7fQy5HTlc
Next section explains how you can create your own AppContainer image
To create and build your own oci, dobby, dac complaint AppContainer image as Appdeveloper, you need to create the following necessary yocto recipes and files :
This is visualized in the diagram below
draw.io Diagram | ||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
To ease integration and life of Appdeveloper meta-dac-sdk layer defined several types of dac-image bbclasses
These bbclasses automatically arrange that the necessary dependent libraries are installed in the AppContainer image and that AppContainer image is formatted according to Open Container OCI Image Format Specification.
As App developer you must inherit the appropriate dac-image bbclass in its own AppContainer image recipe.
Following dac-image bbclasses types are defined, choose the one appropriate for your use case:
dac-image-essos - for DAC application that are using OpenGLES2 as Graphics rendering API and Firebolt ® Essos to setup EGL graphics surface and for key-input
The classes themselves have certain hierarchy. Diagram below visualizes that and has links to their source code.
draw.io Diagram | ||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
Once you have built your oci, dobby, dac compliant AppContainer image with DAC SDK, you can publish it to RDK-M DAC cloud.
There are 2 separate publish steps to take for 1 application :
First Step:
Publish your oci, dobby, dac compliant AppContainer image to an oci container registry in the cloud. This is a standard cloud component that allows to upload container images (docker push), store them there persistently and download them (docker pull). This oci-registry is the binary exchange point to share your application binary with RDK-M and various RDK operators.
Second Step:
Register your application with appropriate metadata in RDK-M DAC cloud system setup for RDK Video Accelerators either via AppStore Admin Portal or directly via REST APIs. There is microservice called ASMS (AppStore Metadata Service) that offers API that allows Application Maintainers to register their app with appropriate metadata. Once registered this will add you app to the DAC App catalog for RDK-M Video Accelerators (VA) and you will be able to discover your App in the Resident UI of all RDK6.1 Video Accelerators and as user/tester of VA you can then choose to install it on any RDK6.1 VA and once installed you can run it. In the background the RDK-M instance of the DAC cloud system will automatically fetch your oci-AppContainer image, create bundle of it for the specific Video Accelerator Hardware (SoC/OEM), encrypt (optionally) and make it available for Video Accelerator to download and store securely.
In next sections we provide detailed howto for each step.
With step2 you will make your DAC native applciation discoverable to Video Accelerators with RDK-M RDK6.1 image but just to be clear and avoid misunderstandings, this will NOT distribute, deploy or make your app available to Appstore of the various RDK operators (Liberty Global, Comcast, Sky). For that you would need to start a discussion with each operator. But this DAC architecture gives you the big benefit that you can now share your Application binary as AppContainer in step1 and when it meets the DAC App contract for binary compatibility it will be binary compatible and technically much easier/quick for the operator to run and test your app on their boxes for first time, get familiar with it. No significant technical integration work should be needed just to get the app running on the operator box. With the DAC cloud for the RDK-M Video Accelerator you as App developer get staging platform where you and others from RDK community can run, test your same application binary across the various supported RDK SoC reference devices (the VA's) and share it with RDK community.
You can either publish your oci container image to
Depending on the oci registry product, there are various login/access credential procedures.
We provide the instructions for Amazon Elastic Container Registry. The private container registry setup RDK-M DAC team is also such type.
You need to have the following util programs installed: aws cli tools and skopeo.
Code Block | ||
---|---|---|
| ||
//Obviously you need to fill in your credentials below iso xxxxx and yyyyy. If you want to use the private OCI container registry from RDK-M, request piotr.serafin@consult.red for credentials
[s3dacrdk]
aws_access_key_id = xxxxx
aws_secret_access_key = yyyyyy |
Assuming your host is linux, configure your aws profile ~/.aws/credentials file as per below
Login, create new container repository and publish the OCI image in there:
Code Block | ||
---|---|---|
| ||
# login into private RDK-M OCI container registry
aws --profile s3dacrdk ecr-public get-login-password --region us-east-1 | skopeo login --username AWS --password-stdin public.ecr.aws/a0v6o9z7
# create repo for your application, in which you can publish different versions, example below creates "cobalt" one for Youtube/cobalt application
aws --profile s3dacrdk --region us-east-1 ecr-public create-repository --repository-name cobalt
# list repos
aws --profile s3dacrdk --region us-east-1 ecr-public describe-repositories
# The actual command that uploads/publishes your local version of a oci image associated with your application to the RDK-M oci-registry
# within repo named "cobalt" with the version tag "latest" standing for latest version
skopeo copy oci-archive:dac-image-cobalt.tar docker://public.ecr.aws/a0v6o9z7/cobalt:latest
# with following command you can download your oci image from RDK-M registry to your local host
skopeo copy docker://public.ecr.aws/a0v6o9z7/cobalt:latest oci:cobalttest
# command to double check if uploaded container is oci image type
skopeo inspect --raw docker://public.ecr.aws/a0v6o9z7/cobalt:latest
{
"schemaVersion": 2,
"config": {
"mediaType": "application/vnd.oci.image.config.v1+json",
"size": 548,
"digest": "sha256:0bc2f756fc781b015769230b207c6b227b788023a5c3d599504407cc1619110e"
},
[...]
} |
You have to remember the OCI image URL of your application, which in this example is docker://public.ecr.aws/a0v6o9z7/cobalt:latest. Because you will have to specify it when publishing the DAC app to the ASMS (AppStore Metdata service).
Note |
---|
Keep in mind that DAC Backend is licensed under DAC Warehouse Service End-User Evaluation License Agreement. and by accessing or using the service, user accepts on Terms of Use. |
ASMS (AppStore Metadata Service) offers API that allows Application Maintainers to register their app with appropriate metadata. There are various ways to publish a new application to ASMS in DAC Cloud:
All above require credentials please contact dac-info@consult.red for assistance.
Please use following template if possible:
...
Subject: Request for Credentials - DAC AppStore Services Access
Dear DAC AppStore Support Team,
I am writing to request credentials for accessing the following DAC AppStore Services:
AppStore Metadata Service REST API
URL: https://asms.rdkm.consult-red.net
Swagger UI: https://asms.rdkm.consult-red.net/swagger-ui/index.html?configUrl=/v3/api-docs/swagger-config
AppStore Admin Portal
URL: https://ui.rdkm.consult-red.net/login
Please find my details below for authentication purposes:
I would appreciate it if you could provide the necessary credentials at your earliest convenience. If any further information is required, please do not hesitate to contact me.
Thank you for your assistance.
...
The AppStore Admin Portal is a user-friendly, intuitive management interface designed by Consult Red for efficient control and administration of your applications and platform configurations. This portal empowers administrators with robust tools to streamline various processes, ensuring smooth operations and optimal performance.
Key features of the AppStore Admin Portal include:
Application Management (DAC Applications):
Platform Configuration Management:
Platform Bundles:
The AppStore Admin Portal is designed to simplify complex administrative tasks, enabling users to efficiently manage and optimize their platform and application landscape.
Access to the Admin Portal requires credentials (contact dac-info@consult.red) and acceptance of Terms of Use during first login.
Note |
---|
Keep in mind that DAC Backend is licensed under DAC Warehouse Service End-User Evaluation License Agreement. and by accessing or using the service, user accepts on Terms of Use. |
You can access the swagger UI with the API documentation here:
see screenshot
As you can see in screenshot the ASMS API is divided in "STB" en "Maintainer" part.
The "Maintainer" part is there for creating, getting, deleting apps belonging to specific App Developer entity/company, hereafter called maintainer, as well as for creating/listing Maintainers.
At this moment we don't have many different App Developer entities using this yet since and most apps created so far as registered under the Maintainer with "rdk" as maintainerCode (also dactest.py uses that)
as per API, to see the apps created by "rdk" maintainer GET /maintainers/rdk/apps which is https://asms.rdkm.consult-red.net/maintainers/rdk/apps
To insert/create new DAC application into ASMS, you need to use POST /maintainers/{maintainerCode}/apps call with specific body
You can use swagger UI with example body for doing this, see https://asms.rdkm.consult-red.net/swagger-ui/index.html?configUrl=/v3/api-docs/swagger-config#/Maintainer/createMaintainerApplication
and screenshot below
example POST body with only the minimum required parameters
As ociImageUrl, use full path to container registry with "docker://" transport and ending with version tag, as in example screenshot below
Code Block | ||
---|---|---|
| ||
{
"header": {
"icon": "https://posterserver.com/s/apps/com.company.app.awesome/1.2.3/image/1920x1080/icon.png",
"name": "Awesome Application",
"description": "This is Awesome App",
"type": "application/dac.native",
"category": "application",
"id": "com.company.app.awesome",
"version": "1.2.3",
"visible": true,
"ociImageUrl": "docker://public.ecr.aws/a0v6o9z7/company/awesome:latest"
},
"requirements": {
"platform": {
"architecture": "arm",
"os": "linux"
},
} |
another example POST body that includes optional metadata parameters, Additionally Example POST body. Additionally you can check how dactest.py is doing it.
Code Block | ||||
---|---|---|---|---|
| ||||
{ "header": { "icon": "https://280222515084-default-apps-resources.s3.eu-central-1.amazonaws.com/images/apps/com.rdk.app.chocolate-doom.png", "name": "Chocolate Doom", "description": "Chocolate Doom aims to accurately reproduce the original DOS version of Doom and other games based on the Doom engine in a form that can be run on modern computers.", "type": "application/dac.native", "size": 10000000, "category": "application", "localization": [ { "languageCode": "nld", "name": "Geweldige applicatie", "description": "Dit is een geweldige applicatie" } ], "id": "com.rdk.app.chocolate-doom", "version": "1.0.0", "visible": true, "encryption": false, "preferred": false, "ociImageUrl": "docker://public.ecr.aws/a0v6o9z7/chocolate-doom:latest" }, "requirements": { "dependencies": [ { "id": "com.libertyglobal.service.voice", "version": "1.0.0" } ], "platform": { "architecture": "arm", "variant": "v7", "os": "linux" }, "hardware": { "ram": "512M", "dmips": "2000", "persistent": "60M", "cache": "200M" }, "features": [ { "name": "rdk.api.awc", "version": "2", "required": false } ] }, "maintainer": { "code": "rdk", "name": "RDK", "address": "RDK Management, LLC", "homepage": "https://rdkcentral.com", "email": "support@rdkcentral.com" }, "versions": [ { "version": "1.0.0", "visible": true, "preferred": false, "encryption": false } ] } |
Note |
---|
Keep in mind that DAC Backend is licensed under DAC Warehouse Service End-User Evaluation License Agreement. and by accessing or using the service, user accepts on Terms of Use. |
Among other things, dactest.py can be used list ASMS apps, add entries and remove entries.
...
We explain here 2 ways to download your DAC application from Staging RDK-M DAC Appstore and install it on the video Accelerator :
Anchor | ||||
---|---|---|---|---|
|
...
In the resident UI go to the icon with the 9 small squares (left bottom) to navigate to the DAC menu. There you will see three submenu items:
dactest.py can be used list, install, uninstall, start and stop DAC apps. It also connects to RDK ASMS to list available DAC apps in the cloud. The DAC apps downloaded from the cloud are generated to bundles inside that cloud and cached there. Sometimes the download can take a while if the bundle still needs to be generated for a specific platform and/or version.
...