Library / SDK
pedroSG94/RootEncoder avatar
pedroSG94/RootEncoder

RootEncoder documents three permissions for a library that advertises background and screen streaming

RootEncoder for Android (rtmp-rtsp-stream-client-java) is a stream encoder to push video/audio to media servers using protocols RTMP, RTSP, SRT and UDP with all code written in Java/Kotlin

3,067 stars954 forksKotlinApache-2.0

At a glance

What is it?
A streaming encoder for Android covering five protocols across two published modules, distributed through a build service rather than a package repository. Its permission list is three entries long, its module was renamed without a compatibility note, and the one unchecked box in its entire feature list is authentication on the protocol with the least support.
Who is it for?
RootEncoder suits an Android application that needs to push camera, screen or file sources to a media server and wants five protocol families in one library rather than five libraries. Before adopting it, check five things.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 8 days ago.
What is it written in?
Mainly Kotlin, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • pedroSG94/RootEncoder3,067 ★ · +25
Star history
Repository2026-09-252026-11-21
pedroSG94/RootEncoder3k3.1k

25 Stars in the last 57 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The rename is documented but applied unevenly

The project was renamed, and the readme explains why in one sentence: the library was renamed after a third protocol was added, because the old name no longer made sense. The old name named two protocols; the new one does not.

That is a good reason, and it is stated plainly. What is uneven is the renaming itself.

The sentence immediately describing the library still uses the old name in parentheses, so the first line a reader meets is the pre-rename identity. The sponsorship block above it carries tracking parameters whose source and campaign reference the old repository path, meaning the sponsor's click-through links still point at the name that was abandoned. And the third-party projects section lists a repository whose name is built on the old one and never will change, because it belongs to someone else.

Meanwhile the badge, the Gradle coordinates and the folder names all use the new name. So the new name is authoritative for anything you type into a build file and the old name survives in three descriptive places.

None of this breaks a build. It does mean a reader who searches for the library will find both identities, and a reader who copies the sponsorship tracking URL will send traffic to a repository path that is no longer the one being advertised.

The module was renamed, so a pinned coordinate stops resolving

The compile section gives two sets of instructions, one for the current version and one labelled as covering old versions at or below a specific release. Both are worth reading together.

The current instruction adds a repository pointing at a build service, then declares two dependencies. One is the main library at the current version. The second is an optional module, commented as being needed to use two of the newer camera sources, and it is declared at the same version.

The old instruction declares a single dependency whose module name is not the current one. The module is called the RTMP library; the current module is simply called the library. So the module was renamed as well as the project.

That is a breaking change for every existing build file, and the readme presents it as a version difference rather than as a rename. There is no note saying the old module name is kept as an alias, and no transition guidance beyond the two separate snippets. A developer upgrading from an old version finds their coordinate stops resolving and has to work out from the snippet that the name changed and that an optional module now has to be added.

The two snippets also differ in quoting style, single quotes in the old one and double in the new, which is cosmetic but is the kind of thing that makes a reader assume the two are from different eras of the same file rather than deliberately maintained together.

The current instruction in full is:

gradle
allprojects {
  repositories {
    maven { url 'https://jitpack.io' }
  }
}
dependencies {
  implementation "com.github.pedroSG94.RootEncoder:library:2.8.1"
  //Optional, allow use CameraXSource and CameraUvcSource
  implementation "com.github.pedroSG94.RootEncoder:extra-sources:2.8.1"
}

The optional module is commented in place, with a note that it is what allows the two newer camera sources.

One more version-related note sits further down: a filter system was refactored in a specific release, with a wiki link for migrating your implementation. So there are two independent breaking changes to absorb, at two different versions.

Three permissions for a library that streams in the background

The readme has a permissions section, and it lists exactly three: internet access, audio recording and camera.

For a library whose feature list includes background streaming, device screen capture and a separate example directory whose description says it streams using a service that runs in the background, that list is short. There is no foreground-service permission, no notification permission, no wake-lock permission, no audio-routing permission, and nothing corresponding to the screen capture the feature list advertises.

It is entirely normal for a library to document the permissions it declares in its own manifest rather than the ones the application must add, and this list may be exactly that. But it is placed under a heading that reads as the setup instructions, immediately after the wiki link and before the compile section, so a reader will take it as the permission set for the whole feature list.

The gap is not academic. A background stream on modern Android needs a foreground service declared and a notification posted, and screen capture needs a media projection permission requested at runtime with the user's consent. None of that appears here.

The honest reading is that the three permissions are the ones the library itself declares, and that the application is responsible for the rest. That is a defensible division, and it would be a much better document if the section said so in a sentence.

The RTSP section documents RTMP auth and the reverse

The feature list is organised one section per protocol, and each section lists its own capabilities. Two sections have their authentication lines transposed.

The section for the real-time messaging protocol lists authentication for the streaming protocol, naming two server implementations. The section for the streaming protocol lists authentication for the messaging protocol, naming two schemes.

Read literally, each protocol claims to authenticate the other one. A reader cross-referencing the two can work out the intent, since the protocols are named elsewhere, but the lines are in each other's sections.

Away from that, the per-protocol detail is unusually thorough and is where the library's real differentiation sits. The messaging protocol has a secure variant under TLS, two tunneled variants with and without TLS, and support for version zero of the data format used to carry metadata. The streaming protocol offers both TCP and UDP transports plus a secure variant. The reliable-transport protocol resends lost packets and offers encryption at three key sizes, and then has one unchecked box: authentication. The datagram protocol covers unicast, multicast and broadcast, and adds a television streaming container format. The web-based ingest protocol carries a bearer token and is the only one marked beta.

So authentication coverage is uneven across the set: one protocol has token auth, one has a documented auth line, one has none, and one is beta.

The minimum platform is 16 for the core and 21 for the extra sources

Two minimum versions appear at the top of the feature list, and they are nine versions apart.

The core library declares a minimum of API 16. The extra video sources, which are the bitmap, the camera support library and the USB camera source, declare a minimum of API 21. So a project on API 16 to 20 can use the core library and cannot use the optional module at all.

API 16 is a platform version from 2012. Declaring it means the core library is buildable and runnable on very old hardware, which is consistent with a project that ships a Windows Gradle wrapper, a separate example directory for low-version devices, and support for both the old and the current camera APIs.

The same commitment shows up throughout the feature list as per-item minimums. Changing the video bitrate while streaming needs API 19. Recording a file while streaming needs API 18. Streaming the device screen needs API 21. So a single streaming session on an old device silently loses capabilities depending on which features you enable, and the list is where you find out.

That is a defensible engineering position and the readme is honest about it. What it does not offer is a compatibility table mapping the common use cases onto version floors, so a developer targeting a minimum of, say, 19 has to read every line rather than deduce that screen capture is unavailable and on-the-fly bitrate changes are available.

The feature list also includes an explicit warning against one option: forcing the video or audio codec to use a particular encoder path is marked as not recommended, which is the only place in the list where a feature is discouraged rather than offered.

The package comes from a build service, and the licence file has a suffix

There is no repository of published artefacts in the readme. Both compile snippets add a repository pointing at a build service that constructs the library from the Git repository on demand, and the coordinates follow that service's naming convention, which encodes the hosting site, the account and the repository name into the group identifier.

The root of the repository contains a configuration file for that build service, which confirms it is the intended distribution path rather than a workaround.

The practical consequence is that resolving this dependency involves a third party compiling the source. If the build service is unavailable, slow, or building a different commit than expected, that failure appears at dependency-resolution time rather than as a missing jar. It also means the version you request is a tag on a repository rather than an immutable published artefact, and that a force-push to a tag would change what that version resolves to.

Two smaller packaging notes. The licence file carries a suffix rather than being named plainly, which some licence scanners and some automated audits do not recognise without being told. And the three badges at the top are a third-party app directory listing, the build service, and the project's own documentation site, with no build status, no test coverage figure and no licence badge among them.

For a library that has been renamed once already and has946 forks, the absence of a conventional published artefact is the packaging decision most worth examining.

The author says the library needs sponsors to buy devices and pay for test platforms

The sponsorship section is unusually specific about what the money is for, and the specificity is to the project's credit.

It says the library needs sponsors in order to acquire new devices, and in order to pay platforms on which to test and debug errors. That is the real cost structure of a streaming library: to verify behaviour against a receiver you either own the receiver or rent access to someone else's.

Two commercial blocks sit above the project description. One is a paid placement for a chat and feeds service, and the other recommends a hosted recording service for anyone who wants an API rather than a library. Both carry campaign parameters identifying this project, so they are sponsorship rather than editorial.

The second one is framed as a redirect. It says that if you are looking for a hosted recording API, consider that instead, which is an honest admission that some readers want the service rather than the code.

Set against the feature list, the sponsorship section explains something the rest of the readme does not: why there are four separate worked examples rather than one, why each protocol has its own section with its own capability list, and why a small library supports five protocol families, a third transport marked beta and an optional module with three camera sources. Each of those is a receiver or a device someone had to test against.

The donation routes are a sponsorship page, an email address, and a payment link, all named.

Editorial conclusion

RootEncoder suits an Android application that needs to push camera, screen or file sources to a media server and wants five protocol families in one library rather than five libraries. Before adopting it, check five things. Treat the permission list as incomplete rather than authoritative, because three entries cannot cover the background streaming and screen capture the feature list advertises. Pin the module name carefully, since it was renamed and the old coordinate is shown for older versions rather than as a shim. Know that authentication coverage is uneven: one protocol has it, one protocol's own authentication is the only unchecked item in the list, and one transport is marked beta. Expect to obtain the package from a build service rather than a conventional repository, and plan for that build to be part of your dependency resolution. And check the minimum platform versions, because the core and the extra sources declare different floors.

Frequently asked questions

Which streaming protocols does RootEncoder support?

Five families: RTMP, RTSP, SRT, UDP and WHIP, the last marked beta. The repository description names the first four, while the readme's own summary sentence names only the first three, even though the readme has a full section on the datagram protocol.

What permissions does RootEncoder need on Android?

The readme documents three: internet access, audio recording and camera. It does not list a foreground service permission, a notification permission or a screen capture permission, so the list cannot be the full set needed for the background streaming and screen capture the feature list advertises.

How do I add RootEncoder to an Android project?

Add the build service's repository to your repositories block, then declare a dependency on the library module at the version you want. If you need the bitmap, camera support library or USB camera sources, add the optional extra-sources module at the same version.

What are the minimum Android versions for RootEncoder?

API 16 for the core library, and API 21 for the optional extra video sources. Individual features carry their own floors: changing bitrate while streaming needs API 19, recording while streaming needs API 18, and streaming the device screen needs API 21.

Does RootEncoder support SRT authentication?

Not yet. It is the single unchecked item in the feature list, under a section that does document lost-packet resending and encryption at three key sizes. The web-based ingest protocol, by contrast, does list bearer token authentication, and it is the one marked beta.

Official sources

  1. Issues
  2. License: Apache-2.0
  3. pedroSG94/RootEncoder on GitHub
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/pedrosg94-rootencoder.svg)](https://hysenlabs.com/projects/pedrosg94-rootencoder)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/pedrosg94-rootencoder.svg)](https://hysenlabs.com/projects/pedrosg94-rootencoder)

Was this useful?