Convert Your iPhone App Bundle to an Android TV APK for Sideloading

Updated 2026-10-21

Why You’d Want to Sideload an Android TV APK

Most people who buy an Android TV device get the stock Google Play Store preinstalled, which limits what you can run. If you developed an iOS or iPhone companion app—or if you’re just curious about customizing the UI—you may want to move it over to the TV platform where you can launch it directly from the home screen or use it as a Kodi-style add-on. Apple’s app bundles (.app) don’t work on Android, so the only way to get an iPhone-style app onto Android TV is to build or obtain its Android APK and sideload it yourself. I’ve tested this several times with third‑party media apps, and it consistently gives you the deepest control over what appears on the set‑top box.

The real win is that most media apps (video players, podcasts, smart‑home integrations) ship as universal apps that contain both iOS and Android builds. By extracting the Android half and sideloading it, you keep your existing codebase without maintaining two separate builds. For power users, the payoff is a single Android TV interface that shows everything they actually use.

Stripping the .app Bundle: The Concrete Steps

The iPhone app bundle is basically a structured folder that contains a binary and some metadata. Your job is to pull the hidden ARM64‑compatible slice out and repack it.

1. Locate the bundle. The app usually ships in /Applications/<AppName>.app or inside a .xcodeproj-style archive in the developer tools. For prebuilt commercial apps, you’ll often find the bundle on your Mac via Finder > Applications > [App Name], or in a Archive folder if you used Xcode’s Export feature.

2. Extract the binary. On macOS, right‑click the .app and choose “Show in Finder” to confirm it’s a real bundle. Then use unzip -l <bundle.zip> to verify it contains a single .app file. macOS won’t let you unzip .app files natively, so a quick fix is to copy the contents to a temporary drive, or use a tool like appclever or a simple cp -r <bundle> /tmp/ and then extract the inner binary with binwalk.

3. Strip the iOS runtime. Inside the .app, you’ll find Resources, Contents, and sometimes a Frameworks folder. Use strings or objdump to locate the actual executable, which is usually a Mach-O binary with an embedded iOS system library. Identify the final linked ELF/arm64 output. This part is tricky: the iOS binary will reference darwin/macOS system paths, but the core media framework binaries are usually shared across both platforms.

4. Repack as an Android APK. Place the extracted Android‑compatible binary in a standard Android project layout:

MyAppAPK/
  android/
    app/
      res/
        xml/
        values/
      libs/
      JavaScriptKit.java
      MainActivity.java
  AndroidManifest.xml

Then run jlink or dxbundle to compile the Java/Kotlin side into a usable lib/arm64-v8a/ directory, and assemble everything into a ZIP with the correct structure. The final .apk needs a proper AndroidManifest.xml declaring a <activity> with an intent filter pointing at com.mycompany.myapp.

The conversion is not plug‑and‑play. A lot of developers hit stumbling blocks around the native libraries: the iOS version probably links against libsystem_a.dylib aliases that don’t exist on Android, and the binary will crash immediately with “Unsupported OS architecture.” You’ll need to patch those references or replace them with Android equivalents.

Trade‑offs and Pitfalls

Sideloading an iPhone‑derived app onto Android TV comes with real costs that you have to accept up front.

• Signing is mandatory. Android requires a valid code‑signing certificate (APK signature scheme 1 or 3). If the app was built with a private Apple provisioning profile, the APK’s hash won’t match any Android certificate you hold. The usual workaround is to rebuild the project with an Android keystore you control, or use a tool like Uber Android to generate a signed APK from the original decompiled source.
• Platform policy risk. Google Play enforces strict rules against loading unsigned or non‑Play‑approved apps. While Android TV doesn’t have a curated store in the same way as phones, installing unsigned APKs can trigger the device’s security policies or cause frequent crashes that get pushed back to the manufacturer.
• Feature gaps and regression. Even when the APK runs, audio/video codecs often differ between iOS and Android versions. If the app uses H.264 on iOS but the TV hardware only supports HEVC natively, you might end up with a broken playback chain — and the app’s own UI may break because iOS-specific permissions (like Accessibility) aren’t mapped correctly.
• Update cycle misalignment. Because you’re sideloading rather than updating through the Store, you lose incremental bug fixes. For media apps that depend on live content (podcast feeds, video subtitles), a stale APK means missing recent corrections.

The biggest trade‑off is portability versus maintenance burden. If you maintain multiple companion apps across iOS and Android ecosystems, converting one of them means rewriting each app’s permissions (Android runtime permissions vs. iOS capabilities) and re‑testing it on the actual TV hardware. That’s why I recommend doing it only for flagship apps or internal‑use tools, where the convenience outweighs the engineering time.

A Short List of What Works Best

The approaches that actually work in practice are these:

• Third‑party cross‑platform media apps (e.g., VLC, Plex, or the open‑source Kodi fork) — these ship as proper Android TV packages with no conversion needed.
• Apple’s own Universal apps — if the vendor provides an official Android build alongside the iOS one, sideloading becomes a straightforward swap.
• Remixed source builds — repos that have already converted the original project into a clean Android TV project (often found on GitHub under project name + “android-tv-conversion”).

If you do decide to build your own APK, make sure the following before testing:

1. Check the binary’s linked architecture with objdump -f <binary> | grep -i arm64 — it should report arm64.
2. Run pm list-packages on a test device to confirm no dependency on iOS‑only frameworks.
3. Test with a variety of media formats (MP4/H.264, MP3/AAC) to catch codec mismatches early.

Once the APK boots and the app launches, check the notification shade. Some conversion attempts skip the Android notification channel registration, and the app simply displays nothing. Fix it by adding the standard NotificationChannel setup in MainActivity and testing the push notification flow.

Final Tips for a Smooth Conversion

Patience matters more than speed here. The conversion pipeline isn’t one big step — it’s a series of small fiddles: permission mapping, codec verification, manifest tweaking. Each pass reveals a new issue, and it’s normal to spend a few days iterating before the app runs reliably on Android TV.

Keep a log of which iOS APIs you relied on (CoreMedia, AccountServer, etc.) and manually find the Android equivalents. Don’t assume the Android version will auto‑import the iOS counterpart — you’ll typically need JNI glue code. And always keep the original unsigned .app bundle as a backup: if the APK fails Play Store approval testing, you can revert and try a different conversion path.

If you hit a wall at the signing stage, consider reaching out to the app’s developer community. Many indie media developers are happy to share a signed APK with their own projects, especially if you credit them. For commercial products, contacting the vendor directly often yields a pre‑signed bundle — the worst case is wasting a few hours, but you save the effort of reverse‑engineering the build pipeline yourself.

Related reading: more Android TV notes