Android IR Blaster

IR Blaster Remote

Universal IR Remote for Android
IR Blaster is an Android application for creating, managing, and transmitting infrared (IR) signals through multiple output methods, including a device’s built-in IR emitter, supported USB IR dongles, and audio-to-IR LED adapters.

The app enables users to build fully custom remotes, discover unknown IR codes through guided brute-force tools, and seamlessly manage IR configurations. It also supports importing IR signals from Flipper Zero .ir files, IRPLUS .irplus / XML files, and LIRC .conf / .cfg / .lirc files, making it easy to reuse and adapt existing IR libraries across devices.

It also includes a GitHub Store for browsing compatible IR files directly from GitHub repositories and importing them into the app without manually downloading and moving files first. For supported USB learning dongles, Learning Mode can capture a signal from a physical remote, preview it, and save it into a new or existing remote.

IR Blaster is designed to be flexible, hardware-agnostic, and user-friendly, while remaining powerful enough for advanced users who need precise control over IR protocols and signal timing.

Overview

• Multiple transmit paths (no built‑in IR required):
  • Internal (ConsumerIrManager) when the device has a hardware IR emitter
  • USB IR dongle (with discovery, permission, and bulk transfers)
  • Audio IR (mono 1‑LED or stereo anti‑phase 2‑LED adapters)
• Rich protocol support and a raw‑signal mode for precise mark/space patterns
• Import/export of remotes, including Flipper Zero .ir, IRPLUS .irplus / XML, LIRC .conf / .cfg / .lirc files, JSON backups, and direct GitHub browsing/import
• Learning Mode for supported USB learning dongles, with capture, preview, replay, and save flows

Tip: At least one transmit path must be available (Internal, USB, or Audio). A built‑in IR blaster is not required if you use a USB dongle or audio adapter.

Features

• Custom Remote Commands: Create and manage remotes using protocol encoders or raw IR patterns.
• Signal Tester (IR Finder / Infrared Bruteforcer): Systematically try protocol/code variations to discover working signals.
• Transmitter Selection & Auto Switch:
  • Choose Internal, USB, Audio (1 LED), or Audio (2 LEDs) under Settings > IR Transmitter.
  • Optional Auto Switch uses USB when a supported dongle is attached, otherwise Internal (disabled if Audio is selected).
• Import/Export & Maintenance (Settings > Remotes):
  • Import JSON backups, Flipper Zero .ir, IRPLUS .irplus / XML (beta), and LIRC .conf / .cfg / .lirc (beta) files
  • Browse compatible files from GitHub repositories in GitHub Store and import them directly into the app
  • Export remotes to Downloads
  • Restore the built‑in demo remote
  • Delete all remotes
• Learning Mode (Settings > Learning Mode):
  • Use a supported USB learning dongle to capture a button from a physical remote
  • Preview the learned signal, replay it, and save it into a new or existing remote
• GitHub Store for browsing GitHub repositories and importing compatible IR files directly.

User‑facing

• Transmitter selection card with live capability updates and USB permission request flow.
• Learning Mode for supported USB learning dongles, with guided capture and save flow.
• GitHub Store for browsing GitHub repositories and importing compatible IR files directly.
• Signal Tester promoted as an IR bruteforcer (IR Finder) to help discover unknown codes.
• Expanded import/export options and maintenance actions for remotes.

Technical/architectural

• Multi‑transmitter architecture:
  • Internal: Android ConsumerIrManager
  • USB: Discovery, permission, endpoint selection, and framed/bulk protocol with RLE payloads
  • Audio: AudioTrack at 48 kHz with mono or stereo anti‑phase synthesis
• Platform channels:
  • Method channel: org.nslabs/irtransmitter
  • Event channel: org.nslabs/irtransmitter_events
  • Methods: transmit, transmitRaw, hasIrEmitter, getTransmitterCapabilities, setTransmitterType, getTransmitterType, getPreferredTransmitterType, setPreferredTransmitterType, getAutoSwitchEnabled, setAutoSwitchEnabled, usbScanAndRequest, usbDescribe, getSupportedFrequencies
• Protocol framework: IrProtocolDefinition + IrFieldDef drive UI/validation; encoders return frequency + microsecond patterns.
• Raw signal encoder: Strict parsing, bounds checking, and safe trailing‑gap handling.
• Persistent settings via SharedPreferences: active type, preferred UI type, auto‑switch flag.

Transmitters and Hardware Support

Configure under Settings > IR Transmitter.

• Internal IR (built‑in)
  • Uses ConsumerIrManager when available, with optional carrier frequency range reporting.
• USB IR Dongle
  • Supported device filter: Vendor IDs 0x10C4 or 0x045E, Product ID 0x8468; requires one interface with bulk IN/OUT endpoints.
  • Permission & discovery: Scans supported devices, requests permission via a mutable PendingIntent (Android 12+), reacts to attach/detach.
  • Framing & transfer: Handshake on open, RLE‑encoded mark/space payloads fragmented into 56‑byte chunks over bulk OUT; background reader drains bulk IN briefly.
  • Tail safety: Adjusts the last gap for even‑length patterns to accommodate device expectations.
• Audio IR
  • Modes: Audio (1 LED, mono) and Audio (2 LEDs, stereo anti‑phase).
  • Implementation: 48 kHz PCM (16‑bit). Marks are synthesized tone windows; spaces are silence.
  • Usage: Requires a compatible audio‑to‑IR LED adapter and maximum media volume.

Auto Switch

• When enabled and if the device has Internal IR, the app prefers USB when a permitted dongle is attached, otherwise Internal.
• Selecting either Audio mode or changing type manually disables Auto Switch.

Signal Tester (IR Finder / Infrared Bruteforcer)

The Signal Tester is designed to help discover unknown working IR commands.

What it does

• Iterates over valid protocol/code combinations to discover a working signal for your target device.
• Sends test patterns using the currently selected transmitter path (Internal, USB, or Audio).
• Surfaces parsing errors and invalid inputs early to avoid spurious transmissions.

Inputs & constraints

• Protocol selection and parameter fields are derived from IrProtocolDefinition and IrFieldDef.
• Hex prefix constraints are parsed and normalized via lib/ir_finder/ir_prefix.dart:
  • Accepts inputs like AA, AA BB, 0xAABB, AA:BB:CC (spaces/colons allowed; case‑insensitive).
  • Enforces even number of hex digits; clamps to a maximum byte count; returns normalized uppercase hex.
  • Provides structured error messages when parsing fails.

How it works (high‑level)

• Builds candidate payloads within protocol‑specific bounds, honoring any prefix constraint.
• Encodes each candidate using the selected protocol encoder into a (frequency, mark/space) pattern.
• Transmits the pattern through the active transmitter (Internal, USB, or Audio).
• Provides progress/run status in the UI and allows the session to be stopped.
• Input validation: Every protocol encoder checks hex length/format and throws on invalid values.
• Raw signal guardrails (when testing raw):
  • Limits entries (4096), enforces positive durations, clamps frequency (10–100 kHz),
  • Auto‑pads a trailing space if the pattern ends with a mark (odd length) to complete the frame.
• USB path normalizes the final tail gap for even‑length patterns to improve dongle compatibility.

Practical tips

• Start with the correct protocol family if known (e.g., NEC/Sony) and add a narrow hex prefix to reduce the search space.
• Prefer Internal or USB for consistent timing; use Audio with max media volume and a known‑good adapter.
• Stop the run as soon as your device reacts and save that code into a remote button.

Implementation references: lib/widgets/ir_finder_screen.dart, lib/ir_finder/ir_prefix.dart, lib/ir_finder/irblaster_db.dart, lib/ir_finder/ir_finder_models.dart.

Remotes Management

• Import remotes: JSON backups and Flipper Zero .ir files (Settings > Remotes > Import remotes).
• GitHub Store: Browse GitHub repositories, preview supported files, and import them directly into your remote library.
• Export remotes: Save a JSON backup to Downloads.
• Restore Demo Remote: Reset to a built‑in demo configuration.
• Delete all remotes: Clear the entire list from this device.

Learning Mode

• Open Settings > Learning Mode to capture a button from a physical remote with a supported USB learning dongle.
• Review the learned signal, replay it to confirm the target device reacts, then save it into a new or existing remote.
• Learning Mode is designed for compatible USB learning receivers such as supported Tiqiaa, ZaZa, or ElkSmart-style dongles.

Supported Infrared Protocols

Protocol	Input format	Carrier (Hz)	Frame structure / timing summary	Notes
Raw Signal	pattern (µs), optional frequencyHz	10,000–100,000 (default 38,000)	Alternating mark/space durations starting with mark; tokens can be decimal/hex; comments supported; auto-append 45ms trailing space if odd length	Max 4096 entries, positive durations only; strict parsing and bounds
Denon	4 hex	38,000	Build 13 bits = nib0(4)+nib1(4)+nib2(4)+nib3(1); duplicate to 26; encode bits with mark=280, space 860/1720; sequence = first13 + pre (c+b+[280, 43560]) + second13 + post (b+c+[280, 43560])	Strict 4 hex digits
F12_relaxed	hex → first 12 bits	38,000	Map 0 → [422,1266], 1 → [1266,422]; adjust last slot to make total 54,000µs	Uses full hex string but only first 12 bits
JVC	4 hex (16 bits LSB-first)	38,000	Preamble 8400/4200; each bit mark=525, space=525 (0) or 1575 (1); trailing 525 + 21000 gap	Strict 4 hex digits
NEC	up to 8 hex (left-padded) → 32 bits	38,222	Preamble 9000/4500; bit mark=562 + space 562 (0) or 1687 (1); trailing mark 562; pad final gap to 108,800µs	Accepts 1–8 hex; normalized to 8
NEC2	up to 8 hex (left-padded) → 32 bits	38,222	Same construction as NEC in this implementation	Accepts 1–8 hex; normalized to 8
NECx1	up to 8 hex (left-padded) → 32 bits	38,400	Preamble 4500/4500; bit mark=562 + space 562/1687; trailing 562; pad to 108,800µs	Optional helper for toggle frame
NECx2	up to 8 hex (left-padded) → 32 bits	38,400	Single NECx-like frame padded to 108,800µs; then duplicate the whole frame back-to-back	Output is two identical frames
NRC17	4 hex (CCAS)	38,000	Pre-pulse 500/2500; start bit fixed to 1; then command(8) + address(4) + subcode(4), all LSB-first, encoded as 1ms bi-phase cells where 1=burst first half and 0=burst second half	Packed as command(2 hex) + address(1 hex) + subcode(1 hex)
Pioneer	8 hex → 32 bits (4 bytes MSB-first)	40,000	Preamble ~8500/4225; each bit mark≈500 + space≈500 (0) or ≈1500 (1); stop bit is implicit; trailing silence ≈26000; full frame sent twice	Typical 4-byte payload layout is Address + ~Address + Command + ~Command
Proton	4 hex (16 bits)	38,500	Header 8000/4000; send last 8 bits; separator 500/8000; then first 8 bits; final 500; pad to 63,000µs	Bit mark=500; 0=500; 1=1500; strict 4 hex
RC5	2+2 hex (AA CC)	36,000	RC5 bi-phase coding, unit ≈889µs; fixed start bits 11, then toggle bit, then address(5) + command(6) MSB-first; encoded as 0 = mark/space, 1 = space/mark, with the implicit leading half-bit of the first start bit skipped; rapid same-key repeats keep the same toggle, new presses flip it; frame gap padded to 114,000µs	UI exposes Address and Command separately; legacy packed 3-hex payloads are still accepted internally for compatibility
RC6	hex (last 4 hex used → 16-bit payload)	36,000	Leader 2664/888; 1 = mark/space, 0 = space/mark; Mode 0 layout is start 1 + mode 000 + double-width toggle + 16-bit payload (addr+cmd) MSB-first using T=444; includes the required 6t trailing silence	Uses last 4 hex digits as payload; rapid same-key repeats keep the same toggle, new presses flip it
RCA_38	3 hex → 12 bits (address nibble + command byte)	56,000	Preamble 4000/4000; payload = address(4) + command(8) + ~address(4) + ~command(8), sent MSB-first; each bit mark=500 and space=1000 (0) or 2000 (1); trailer 500/8000	Strict 3 hex digits
RCC0082	3 hex (nibbles)	30,300	Prefix 22 ints [BIT=528,GAP=2640,BIT×19,END=21120], then [BIT,GAP,BIT,BIT]; build 10-bit: "0" + n0(last3) + n1(all4) + n2(first2); transition-based emission; parity-based tail then suffix (same 22)	Tail even=111,408, odd=110,880
RCC2026	11 hex → 42 bits (from 44 padded)	38,222	Header 8800/4400; bit mark=550 + space 550 (0) or 1650 (1); final mark 550 + 23100; then tail [8800, 4400, 550, 90750]	Strict 11 hex; takes last 42 bits
REC80	12 hex → 48 bits (32 + 16)	37,000	Header 3456/1728; bit1 432/1296; bit0 432/432; tail 432/74736	Strict 12 hex
RECS80	3 hex	38,000	Toggle flips each encode; bit string: "1" + toggle + n0(first3) + n0(last1) + n1(all4) + n2(first1); each bit mark=158 + space 7426 (1) or 4898 (0); end 158/45000	Internal toggle maintained
RECS80_L	3 hex	33,300	Same bit string as RECS80; bit1 180/8460; bit0 180/5580; end is 180 then pad to 138,000µs	Low-frequency variant; fixed frame length
Samsung32	4 hex (AA CC) → 32 bits	38,000	Preamble 4500/4500; each bit mark≈550 + space≈550 (0) or ≈1650 (1); standard 32-bit layout with checksum byte	Payload layout is Address + Address + Command + ~Command
Samsung36	7 hex → 36 bits (A8+B8+C4+D8+~D8)	38,000	Start 4500/4500; first 16 bits (500/500	1500); 500/4500 separator; last 20 bits same; final 500/59000
Sharp	4 hex packed as address(5) + command(8)	38,000	First 13 bits send address(5) + command(8), LSB-first; second 13 bits repeat address and invert command; timing uses 280/860 for 0 and 280/1720 for 1 with protocol tail blocks between messages	Strict 4 hex; packed 13-bit payload
SONY12	3 hex → 12 bits	40,000	Header 2400/600; 0=600/600; 1=1200/600; remove last duration; pad to 45,000µs; duplicate frame	Strict 3 hex
SONY15	4 hex → 15 bits (from 16 padded)	40,000	Same timings as SONY12; remove last duration; pad to 45,000µs; duplicate frame	Strict 4 hex
SONY20	5 hex → 20 bits	40,000	Same timings as SONY12; remove last duration; pad to 45,000µs; duplicate frame	Strict 5 hex
Thomson7	3 hex (int)	33,000	Mask 0xF7F; 12 bits = last4 + toggle + first7; 0=[460,2000]; 1=[460,4600]; append 460; pad to 80,000µs; duplicate frame	Toggle maintained; hex int input with min/max
XSAT (Mitsubishi)	4 hex (AA CC)	38,000	Header 8000/4000; address(8) then command(8), both LSB-first; each bit mark=526 + space=474 (0) or 1474 (1); inserts 4000µs separator between address and command; trailing gap sized for ~60ms repeat cadence	Packed as address byte + command byte
Kaseikyo (Panasonic)	6 hex → 24 bits (Address12 + Command8 + VendorParity/ignored)	37,000	Header 3456/1728; bit mark 432, space 432 (0) or 1296 (1); this finder uses a 24-bit payload (address:12 + command:8 + low vendor nibble) to search; production encoder computes full 48-bit frame with vendor parity and 8-bit XOR parity	Use vendor defaults or provide vendor/address/command when creating a button in remotes

Notes:

• Protocol identifiers and display names are maintained in lib/ir/ir_protocol_registry.dart.
• Encoders validate inputs and produce an explicit frequency (Hz) and alternating mark/space durations (µs).

Developer Notes

Platform channels

• Method Channel: org.nslabs/irtransmitter
  • transmit: Send encoder‑generated patterns at the encoder’s frequency.
  • transmitRaw: Send a raw microsecond pattern at a specified frequency.
  • hasIrEmitter: True if any path is available (internal, USB present, or audio available).
  • getTransmitterCapabilities: Returns hasInternal, hasUsb, usbOpened, hasAudio, currentType, usbDevices[], autoSwitchEnabled.
  • setTransmitterType / getTransmitterType
  • getPreferredTransmitterType / setPreferredTransmitterType
  • getAutoSwitchEnabled / setAutoSwitchEnabled
  • usbScanAndRequest
  • getSupportedFrequencies
  • usbDescribe
• Event Channel: org.nslabs/irtransmitter_events
  • Emits capability snapshots on attach/detach, permission responses, and type changes.

Audio path

• AudioIrTransmitter + AudioPcmBuilder synthesize PCM from mark/space patterns (mono or stereo anti‑phase).

USB path

• UsbDiscoveryManager filters, opens, and claims interfaces; UsbProtocolFormatter handles handshake, RLE body, fragmentation, and tail adjustments; UsbIrTransmitter performs bulk I/O and runs a short‑lived background reader.

Persistence

• tx_type, ui_tx_type, auto_switch in SharedPreferences persist user choices and auto behavior.

Requirements

• One of the following transmit paths:
  • Built‑in IR blaster (Internal)
  • Supported USB IR dongle (VID 0x10C4 or 0x045E, PID 0x8468)
  • Audio‑to‑IR LED adapter (Audio modes)
• Android 11+

Installation

1. Download the APK:

Or download the latest APK from the Releases Section.

2. Install the Application:

   • Enable installation from unknown sources if needed.
   • Follow the on‑screen instructions.

3. Launch and Configure:

   • Open IR Blaster.
   • Choose your transmitter (Settings > IR Transmitter).
   • Create remotes or import a Flipper Zero .ir file.

Usage

Creating Custom Remotes

1. Open the Remotes tab.
2. Create a remote and add buttons using protocol encoders, raw patterns, GitHub Store imports, or buttons imported from existing remotes and the database.
3. Save and test your buttons from the Remote view.

Using the GitHub Store

1. Open Settings > GitHub Store.
2. Enter a GitHub repository or folder URL, then load the repository when you want to browse it.
3. Open a supported file to preview how it will be parsed.
4. Import it into a new remote or add compatible buttons to an existing remote.

Using the Signal Tester (IR Finder)

1. Open the "Signal Tester" tab.
2. Provide protocol parameters and optional hex prefix constraints.
3. Start testing; the bruteforcer will try variations to identify working signals via your selected transmitter.

Using Learning Mode

1. Connect a supported USB learning dongle and grant USB permission if Android asks.
2. Open Settings > Learning Mode.
3. Capture one button from the original remote, replay it if needed, then save it into your library.

USB Notes

• When a supported USB dongle is attached, use "Request USB permission" if prompted.
• Auto Switch prefers USB when available; disable it for manual selection or Audio use.

Audio Notes

• Use maximum media volume when transmitting via audio.
• Requires a compatible audio‑to‑IR LED adapter (mono or stereo anti‑phase).

ScreenShots

Contributing

Contributions are welcome! If you'd like to help improve IR Blaster: Please do not submit pull requests that only modify translation or localization files in lib/l10n/*.arb. Translation contributions are not being accepted through PRs.

1. Fork the repository.
2. Create a new branch for your feature or bug fix.
3. Submit a pull request with your proposed changes.

License

This project is licensed under the GNU GPLv3 License.

Support

If you encounter any issues or have questions, please open an issue on the GitHub repository or contact the maintainer.

Acknowledgments

IR Blaster is originally a fork of osram-remote. Special thanks to TalkingPanda0 for his foundational work.

More Apps by KaijinLab!

App	What it does
IR Blaster	Control and test infrared functionality for compatible devices.
USBDevInfo	Inspect USB device details and behavior to understand what's really connected.
GadgetFS	Experiment with USB gadget functionality (hardware-adjacent, low-level).
TapDucky	A security/testing tool for controlled keystroke injection workflows.
HIDWiggle	A mouse jiggler built with USB gadget functionalities.
AKTune (Android Kernel Tweaker)	Adaptive Android kernel auto-tuner for CPU/GPU/scheduler/memory/I-O. (Magisk Module).