US Trends

one of receiver_exported or receiver_not_exported should be specified when a receiver isn't being registered exclusively for system broadcasts_2

The phrase “one of receiver_exported or receiver_not_exported should be specified when a receiver isn't being registered exclusively for system broadcasts” is the core Android 14+ error message about how you must register broadcast receivers in newer SDKs.

Below is a “Quick Scoop”-style explainer of what it means, why it’s suddenly everywhere in late 2024–2025 Android dev discussions, and how people on forums are fixing it.

One of RECEIVER_EXPORTED or RECEIVER_NOT_EXPORTED…

Quick Scoop

Android 14 and targetSdkVersion 34 changed how you register broadcast receivers, and many apps, SDKs, and even sample projects now crash with this error unless they explicitly set an exported flag when calling registerReceiver.

In short: every non-system-only dynamic broadcast receiver now needs a security stance: either “I can receive from other apps” (RECEIVER_EXPORTED) or “I can’t” (RECEIVER_NOT_EXPORTED).

What the error actually means

When you see:

One of RECEIVER_EXPORTED or RECEIVER_NOT_EXPORTED should be specified when a receiver isn't being registered exclusively for system broadcasts

Android is telling you:

  • You called some form of registerReceiver(...) for a BroadcastReceiver.
  • The registration isn’t clearly “system-only”.
  • You didn’t specify whether this receiver is exported (can receive broadcasts from other apps) or not.

Google made this mandatory in Android 14 to tighten broadcast security; if you don’t comply, you get a crash instead of a silent security risk.

Where devs are hitting this (latest forum chatter)

Public forums show this error popping up in many contexts once apps move to targetSdkVersion 34:

  • Payment and checkout SDKs (e.g., Razorpay) start crashing when target is bumped to 34, even in vendor sample apps.
  • React Native projects upgrading targets run into it for dev-support or other internal receivers.
  • Xamarin / .NET Android apps integrating RFID or other hardware libraries get the crash even if they never wrote a receiver themselves (the issue is in the library).
  • Tuya / IoT, BillingClient, in-app update, and other 3rd‑party libs also surface the crash until they’re updated to Android‑14‑aware versions.
  • Classic Java/Kotlin projects see it on any registerReceiver call that wasn’t updated for Android 14.

In other words, this is not just “your code broke”: it’s a platform rule change that ripples through all your dependencies.

The core fix: specify exported vs not exported

The modern, platform-aligned pattern is:

  • If the receiver may get broadcasts from other apps (including some system broadcasts): use RECEIVER_EXPORTED.
  • If you want it strictly internal to your app: use RECEIVER_NOT_EXPORTED.

Example in Kotlin/Java (simple version, no permissions):

kotlin

// Receiver CAN receive from other apps/system → exported
context.registerReceiver(
    myReceiver,
    IntentFilter("your.action"),
    Context.RECEIVER_EXPORTED
)

// Receiver is app-internal only → not exported
context.registerReceiver(
    myReceiver,
    IntentFilter("your.action"),
    Context.RECEIVER_NOT_EXPORTED
)

Android docs and community answers emphasize that if you skip this on Android 14 with target 34, you’ll get a SecurityException and the crash you’re seeing.

Dynamic vs manifest receivers: what changed?

Manifest receivers

  • Before Android 13/14, you mostly controlled export with android:exported="true|false" in the manifest.
  • That still matters for manifest-declared receivers, especially for system or external broadcasts.
  • But this new error is about dynamic registration at runtime, not just manifest entries.

Dynamic receivers (the main culprit)

When using something like:

kotlin

registerReceiver(myReceiver, IntentFilter("action"))

that’s now incomplete on Android 14+ if the broadcast isn’t exclusively system-only. You must add one of:

  • Context.RECEIVER_EXPORTED
  • Context.RECEIVER_NOT_EXPORTED

This is why many older code snippets and tutorials suddenly fail once you bump targetSdkVersion to 34.

Typical real-world fixes from forums

Here’s how developers are actually solving it in different stacks.

1. Plain Android (Java/Kotlin)

For common cases, people simply add the flag on registration:

kotlin

// app-internal
context.registerReceiver(
    myReceiver,
    intentFilter,
    Context.RECEIVER_NOT_EXPORTED
)

Or, if the receiver should accept system/external broadcasts:

kotlin

context.registerReceiver(
    myReceiver,
    intentFilter,
    Context.RECEIVER_EXPORTED
)

Some examples also use ContextCompat.registerReceiver with the same flags as a backwards‑compatible helper.

2. React Native apps

React Native projects often run into this when upgrading, because React Native and its dev/support tooling register internal broadcast receivers.

Community answers show:

  • Adding explicit registerReceiver code with the proper flags in MainApplication.java or MainActivity.java for certain receivers.
  • For newer RN versions using Kotlin, similar snippets go into MainApplication.kt or MainActivity.kt.
  • Some devs also fix the issue by updating React Native itself or particular RN libraries that handle broadcasts internally.

3. Third‑party SDKs (Razorpay, Tuya, Billing, uGrokit, etc.)

A lot of devs report they “don’t use broadcast receivers at all”, yet still see the crash. That usually means:

  • The SDK they use registers a BroadcastReceiver internally without specifying the new flags.
  • Once you target 34, that triggers the crash on Android 14 devices, even if your own code is clean.

What people are doing:

  • Updating the SDK to a version that explicitly supports Android 14 and target 34.
* Example: updating Google Play Billing or app-update libraries to newer versions that internally handle `RECEIVER_EXPORTED`/`RECEIVER_NOT_EXPORTED`.
  • When no fixed version exists yet, some devs:
    • Open issues or GitHub tickets (as seen with Razorpay and other vendors).
* Temporarily avoid targeting 34 in production builds, or gate the problematic feature for Android 14 devices until the SDK is patched.

Why “system-only” matters in the message

The error’s last part:

“when a receiver isn’t being registered exclusively for system broadcasts”

means: if your receiver is truly only for inside-the-system broadcasts (never from other apps), there is a special case path that doesn’t require these flags.

But in practice:

  • Many app and SDK receivers don’t qualify as “system-only”.
  • So Android forces you to state your intent explicitly.
  • Developers are generally advised to always specify the flag to avoid guessing whether the system will treat it as “exclusively system-only”.

Why this is trending now

A few reasons this topic is all over forums and Q&A sites from late 2023 through 2025:

  • Android 14 rollout on real devices means more end users running into crashes.
  • Play Store policy pressure nudges apps to target newer SDKs, so more projects jump from 31/32/33 to 34 and suddenly break.
  • Popular libraries (payments, IoT, updates, billing) needed time to catch up, leaving many apps stuck with crashing builds until updates landed.

So the error message you’re quoting is essentially the “headline” for this broader platform migration: Android tightening broadcast security, and the ecosystem updating to comply.

Mini checklist to fix this in your project

Use this quick checklist when you see the error:

  1. Search your codebase forregisterReceiver
    • Ensure every non-system-only registration has either RECEIVER_EXPORTED or RECEIVER_NOT_EXPORTED.
  1. Check your dependencies / SDKs
    • If the crash stack trace points into a third‑party library, see if there’s an Android 14–compatible update.
  1. Update common Google libs
    • Google Play Billing, in-app updates, and related libraries have versions that incorporate the new flags internally; updating those has resolved the error for many devs.
  1. React Native / Xamarin / Capacitor / Ionic
    • Look for platform-specific guidance or snippets that add the proper flags in the main application/activity, and make sure you’re on a version that advertises Android 14 support.
  1. Re-test on Android 14 with target 34
    • Confirm that the crash is gone and that your receivers behave as intended in terms of exposure to other apps.

SEO corner: key phrase usage

If you are crafting content around this error, the main focus keyword:

“one of receiver_exported or receiver_not_exported should be specified when a receiver isn't being registered exclusively for system broadcasts_2”

naturally coexists with:

  • “Android 14 broadcast receiver error”
  • “RECEIVER_EXPORTED vs RECEIVER_NOT_EXPORTED”
  • “Android 14 targetSdkVersion 34 crash”
  • “latest news” on Android 14 migration issues
  • “forum discussion” and “trending topic” around this broadcast change

Short, clear paragraphs with code snippets, bullet lists of fixes, and references to recent Android 14 platform changes tend to keep readability high for developers following this trend.

If you tell me which stack you’re working with (pure Android, React Native, Xamarin, Capacitor, etc.) and whether the stack trace points inside your code or a library, I can outline the exact registration snippet or upgrade path you likely need.