Add full ElkSmart subtype support and fix RC5/RC6 protocol handling

Author: Kame

.flutter-plugins-dependencies

@@ -165,8 +165,8 @@ The Signal Tester is designed to help discover unknown working IR commands.
 | 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 | up to 3 hex | 36,000 | Manchester coding, unit ≈889µs; start bits + toggle bit (flips each encode); 11-bit payload MSB-first; frame padded/replaced to 114,000µs | Toggle bit maintained internally (repeat detection depends on toggle changes) |
-| RC6 | hex (last 4 hex used → 16-bit payload) | 36,000 | Leader 2664/888; Manchester-like with mode bits + toggle field (toggle is double-time); payload uses T=444 timing pairs; overall layout is start+mode+toggle+addr+cmd | Uses last 4 hex digits as payload; internal toggle flips each encode |
+| 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 |

README.md

@@ -32,6 +32,7 @@
 
     <!-- IR transmission permission -->
     <uses-permission android:name="android.permission.TRANSMIT_IR" />
+    <uses-permission android:name="android.permission.VIBRATE" />
 
     <!-- Legacy storage permissions for Android 9 and below.
          Not requested on Android 10+ due to maxSdkVersion. -->

android/app/src/main/AndroidManifest.xml

@@ -9,9 +9,14 @@ import android.content.pm.PackageManager
 import android.hardware.ConsumerIrManager
 import android.hardware.usb.UsbDevice
 import android.hardware.usb.UsbManager
+import android.os.Build
 import android.os.Handler
 import android.os.Looper
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.os.VibratorManager
 import android.util.Log
+import android.view.HapticFeedbackConstants
 import androidx.annotation.NonNull
 import io.flutter.embedding.android.FlutterActivity
 import io.flutter.embedding.engine.FlutterEngine
@@ -439,6 +444,7 @@ class MainActivity : FlutterActivity() {
                     "transmit" -> handleTransmit(call, result)
                     "transmitRaw" -> handleTransmitRaw(call, result)
                     "transmitRawCycles" -> handleTransmitRawCycles(call, result)
+                    "performHaptic" -> handlePerformHaptic(call, result)
                     "hasIrEmitter" -> handleHasAnyEmitter(result)
                     "getTransmitterCapabilities" -> handleGetTxCaps(result)
                     "setTransmitterType" -> handleSetTxType(call, result)
@@ -472,6 +478,105 @@ class MainActivity : FlutterActivity() {
         emitTxStatusDelayed("startup_done_delayed", 350L)
     }
 
+    private fun handlePerformHaptic(call: MethodCall, result: MethodChannel.Result) {
+        val type = call.argument<String>("type") ?: "selection"
+        val intensity = (call.argument<Int>("intensity") ?: 2).coerceIn(1, 3)
+        runOnUiThread {
+            try {
+                result.success(performNativeHaptic(type, intensity))
+            } catch (t: Throwable) {
+                Log.w(TAG, "performNativeHaptic failed: ${t.message}")
+                result.error("HAPTIC_FAILED", t.message, null)
+            }
+        }
+    }
+
+    private fun performNativeHaptic(type: String, intensity: Int): Boolean {
+        val decorView = window?.decorView
+        val constant = when (type) {
+            "selection" -> {
+                if (Build.VERSION.SDK_INT >= 34) {
+                    HapticFeedbackConstants.SEGMENT_TICK
+                } else {
+                    HapticFeedbackConstants.CLOCK_TICK
+                }
+            }
+            "light" -> HapticFeedbackConstants.VIRTUAL_KEY
+            "medium" -> HapticFeedbackConstants.KEYBOARD_TAP
+            "heavy" -> {
+                if (Build.VERSION.SDK_INT >= 23) {
+                    HapticFeedbackConstants.CONTEXT_CLICK
+                } else {
+                    HapticFeedbackConstants.LONG_PRESS
+                }
+            }
+            else -> HapticFeedbackConstants.CLOCK_TICK
+        }
+
+        val viewOk = try {
+            if (decorView != null) {
+                decorView.isHapticFeedbackEnabled = true
+                decorView.performHapticFeedback(constant)
+            } else {
+                false
+            }
+        } catch (_: Throwable) {
+            false
+        }
+        if (viewOk) return true
+
+        return performVibratorFallback(type, intensity)
+    }
+
+    private fun performVibratorFallback(type: String, intensity: Int): Boolean {
+        val vibrator = getAppVibrator() ?: return false
+        if (!vibrator.hasVibrator()) return false
+        return try {
+            when {
+                Build.VERSION.SDK_INT >= 29 -> {
+                    val effectId = when (type) {
+                        "selection" -> VibrationEffect.EFFECT_TICK
+                        "light" -> VibrationEffect.EFFECT_CLICK
+                        "medium" -> VibrationEffect.EFFECT_CLICK
+                        "heavy" -> VibrationEffect.EFFECT_HEAVY_CLICK
+                        else -> VibrationEffect.EFFECT_CLICK
+                    }
+                    vibrator.vibrate(VibrationEffect.createPredefined(effectId))
+                }
+                Build.VERSION.SDK_INT >= 26 -> {
+                    val (duration, amplitude) = fallbackOneShotFor(intensity)
+                    vibrator.vibrate(VibrationEffect.createOneShot(duration, amplitude))
+                }
+                else -> {
+                    val (duration, _) = fallbackOneShotFor(intensity)
+                    @Suppress("DEPRECATION")
+                    vibrator.vibrate(duration)
+                }
+            }
+            true
+        } catch (_: Throwable) {
+            false
+        }
+    }
+
+    private fun getAppVibrator(): Vibrator? {
+        return if (Build.VERSION.SDK_INT >= 31) {
+            val mgr = getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as? VibratorManager
+            mgr?.defaultVibrator
+        } else {
+            @Suppress("DEPRECATION")
+            getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
+        }
+    }
+
+    private fun fallbackOneShotFor(intensity: Int): Pair<Long, Int> {
+        return when (intensity.coerceIn(1, 3)) {
+            1 -> 12L to 60
+            2 -> 18L to 140
+            else -> 24L to 255
+        }
+    }
+
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
         handleControlIntent(intent)

android/app/src/main/kotlin/org/nslabs/irblaster/MainActivity.kt

@@ -7,12 +7,29 @@ import android.util.Log
 import kotlin.math.min
 import kotlin.math.roundToLong
 
-object ElkSmartUsbProtocolFormatter : UsbWireProtocol {
+class ElkSmartUsbProtocolFormatter : UsbWireProtocol {
     override val name: String = "elksmart_bulk"
     override val strictHandshake: Boolean = true
     override val wantsBackgroundReader: Boolean = false
     override val interFrameDelayMs: Long = 2L
 
+    private enum class Subtype {
+        D552,
+        D226,
+    }
+
+    private var subtype: Subtype? = null
+
+    companion object {
+        private const val TAG = "ElkSmartUsbProtocol"
+        private const val IDENT_PREFIX = 0xFC
+        private const val TYPE_D552_HI = 0x70
+        private const val TYPE_D552_LO = 0x01
+        private const val TYPE_D226_HI = 0x02
+        private const val TYPE_D226_LO = 0xAA
+        private const val ODD_PATTERN_TRAILING_GAP_US = 10_000
+    }
+
     override fun openHandshake(
         connection: UsbDeviceConnection,
         inEndpoint: UsbEndpoint,
@@ -26,10 +43,10 @@ object ElkSmartUsbProtocolFormatter : UsbWireProtocol {
             }
 
             val identify = byteArrayOf(
-                0xFC.toByte(),
-                0xFC.toByte(),
-                0xFC.toByte(),
-                0xFC.toByte()
+                IDENT_PREFIX.toByte(),
+                IDENT_PREFIX.toByte(),
+                IDENT_PREFIX.toByte(),
+                IDENT_PREFIX.toByte()
             )
 
             val w = connection.bulkTransfer(outEndpoint, identify, identify.size, 200)
@@ -48,21 +65,51 @@ object ElkSmartUsbProtocolFormatter : UsbWireProtocol {
 
             if (got < 6) return false
 
-            resp[0] == 0xFC.toByte() &&
-                resp[1] == 0xFC.toByte() &&
-                resp[2] == 0xFC.toByte() &&
-                resp[3] == 0xFC.toByte() &&
-                (resp[4].toInt() and 0xFF) == 0x70 &&
-                (resp[5].toInt() and 0xFF) == 0x01
+            val identified = identifySubtype(resp, got)
+            if (identified == null) {
+                Log.w(TAG, "Unexpected identify response: ${resp.copyOf(got).toHexString()}")
+                return false
+            }
+            subtype = identified
+            true
         } catch (t: Throwable) {
-            Log.w("ElkSmartUsbProtocol", "openHandshake failed: ${t.message}")
+            Log.w(TAG, "openHandshake failed: ${t.message}")
             false
         }
     }
 
+    private fun identifySubtype(resp: ByteArray, size: Int): Subtype? {
+        if (size < 6) return null
+        if (resp[0] != IDENT_PREFIX.toByte() ||
+            resp[1] != IDENT_PREFIX.toByte() ||
+            resp[2] != IDENT_PREFIX.toByte() ||
+            resp[3] != IDENT_PREFIX.toByte()
+        ) {
+            return null
+        }
+
+        val typeHi = resp[4].toInt() and 0xFF
+        val typeLo = resp[5].toInt() and 0xFF
+        return when {
+            typeHi == TYPE_D552_HI && typeLo == TYPE_D552_LO -> {
+                Log.i(TAG, "Identified ElkSmart subtype 70 01")
+                Subtype.D552
+            }
+            typeHi == TYPE_D226_HI && typeLo == TYPE_D226_LO -> {
+                Log.i(TAG, "Identified ElkSmart subtype 02 AA")
+                Subtype.D226
+            }
+            else -> null
+        }
+    }
+
     override fun encode(frequencyHz: Int, patternUs: IntArray): List<ByteArray> {
         val pulses = toPulses(patternUs)
-        val payload = compressPulses(pulses)
+        val rawCompressed = compressPulses(pulses)
+        val payload = when (subtype ?: Subtype.D552) {
+            Subtype.D552 -> rawCompressed
+            Subtype.D226 -> encodeD226Payload(rawCompressed)
+        }
 
         val f = (frequencyHz + 0x7FFFF)
         val len = payload.size
@@ -122,7 +169,6 @@ object ElkSmartUsbProtocolFormatter : UsbWireProtocol {
     }
 
     private data class Pulse(val onUs: Int, val offUs: Int)
-    private const val ODD_PATTERN_TRAILING_GAP_US = 10_000
 
     private fun toPulses(patternUs: IntArray): List<Pulse> {
         if (patternUs.isEmpty()) return emptyList()
@@ -176,9 +222,90 @@ object ElkSmartUsbProtocolFormatter : UsbWireProtocol {
         return out.toByteArray()
     }
 
+    private fun encodeD226Payload(rawCompressed: ByteArray): ByteArray {
+        if (rawCompressed.isEmpty()) return rawCompressed
+
+        val freq = IntArray(256)
+        for (b in rawCompressed) {
+            freq[b.toInt() and 0xFF]++
+        }
+
+        val pq = java.util.PriorityQueue<Node>(compareBy<Node> { it.weight })
+        for (symbol in 0..0xFF) {
+            val weight = freq[symbol]
+            if (weight > 0) {
+                pq.offer(Leaf(weight, symbol))
+            }
+        }
+        if (pq.isEmpty()) return rawCompressed
+
+        while (pq.size > 1) {
+            val left = pq.poll()
+            val right = pq.poll()
+            pq.offer(Branch(left, right))
+        }
+
+        val codes = ArrayList<CodeEntry>()
+        buildCodes(pq.poll(), StringBuilder(), codes)
+        codes.sortBy { it.symbol }
+
+        val codeBySymbol = HashMap<Int, String>(codes.size)
+        val out = ByteArrayOutput()
+        out.write((codes.size ushr 8) and 0xFF)
+        out.write(codes.size and 0xFF)
+
+        for (entry in codes) {
+            codeBySymbol[entry.symbol] = entry.bits
+            out.write(entry.symbol and 0xFF)
+            out.write((entry.weight ushr 8) and 0xFF)
+            out.write(entry.weight and 0xFF)
+        }
+
+        val bitString = StringBuilder()
+        for (b in rawCompressed) {
+            bitString.append(codeBySymbol[b.toInt() and 0xFF] ?: "")
+        }
+
+        var tailBits = bitString.length % 8
+        if (tailBits > 0) {
+            repeat(8 - tailBits) { bitString.append('0') }
+        }
+        out.write(tailBits and 0xFF)
+
+        var i = 0
+        while (i < bitString.length) {
+            val chunk = bitString.substring(i, i + 8)
+            out.write(chunk.toInt(2) and 0xFF)
+            i += 8
+        }
+        return out.toByteArray()
+    }
+
+    private sealed class Node(val weight: Int)
+    private class Leaf(weight: Int, val symbol: Int) : Node(weight)
+    private class Branch(val left: Node, val right: Node) : Node(left.weight + right.weight)
+    private data class CodeEntry(val symbol: Int, val weight: Int, val bits: String)
+
+    private fun buildCodes(node: Node, prefix: StringBuilder, out: MutableList<CodeEntry>) {
+        when (node) {
+            is Leaf -> {
+                val bits = if (prefix.isEmpty()) "0" else prefix.toString()
+                out.add(CodeEntry(node.symbol, node.weight, bits))
+            }
+            is Branch -> {
+                prefix.append('0')
+                buildCodes(node.left, prefix, out)
+                prefix.deleteCharAt(prefix.lastIndex)
+                prefix.append('1')
+                buildCodes(node.right, prefix, out)
+                prefix.deleteCharAt(prefix.lastIndex)
+            }
+        }
+    }
+
     private fun compressValueUs(valueUs: Int, out: ByteArrayOutput) {
         if (valueUs <= 2032) {
-            val q = ((valueUs + 8) / 16).coerceAtLeast(2)
+            val q = if (valueUs == 0 || valueUs == 1) valueUs else ((valueUs / 16.0) + 0.5).toInt()
             out.write(q and 0xFF)
             return
         }
@@ -187,6 +314,7 @@ object ElkSmartUsbProtocolFormatter : UsbWireProtocol {
             var b = v and 0x7F
             v = v ushr 7
             if (v != 0) b = b or 0x80
+            if ((b and 0xFF) == 0xFF) b = 0xFE
             out.write(b and 0xFF)
             if (v == 0) break
         }
@@ -227,4 +355,8 @@ object ElkSmartUsbProtocolFormatter : UsbWireProtocol {
             buf = buf.copyOf(newCap)
         }
     }
+
+    private fun ByteArray.toHexString(): String = joinToString(" ") { b ->
+        (b.toInt() and 0xFF).toString(16).padStart(2, '0').uppercase()
+    }
 }

android/app/src/main/kotlin/org/nslabs/irblaster/usb/ElkSmartUsbProtocolFormatter.kt

@@ -8,15 +8,13 @@ object UsbDeviceFilter {
   private const val TIQIAA_PID = 0x8468
 
   private const val ELKSMART_VID = 0x045C
-  private val ELKSMART_PIDS = setOf(0x0132, 0x0184, 0x0195, 0x02AA)
-
-  private val OTHER_KNOWN_ELKSMART_PIDS = setOf(0x014A)
+  private val ELKSMART_PIDS = setOf(0x0132, 0x014A, 0x0184, 0x0195, 0x02AA)
 
   fun hasKnownVidPid(device: UsbDevice): Boolean {
     val vid = device.vendorId
     val pid = device.productId
     return isTiqiaaTviewFamily(device) ||
-      (vid == ELKSMART_VID && (pid in ELKSMART_PIDS || pid in OTHER_KNOWN_ELKSMART_PIDS))
+      (vid == ELKSMART_VID && pid in ELKSMART_PIDS)
   }
 
   fun isSupported(device: UsbDevice): Boolean = hasKnownVidPid(device)

android/app/src/main/kotlin/org/nslabs/irblaster/usb/UsbDeviceFilter.kt

@@ -42,7 +42,7 @@ class UsbDiscoveryManager(
     }
 
     val protocol: UsbWireProtocol = when {
-      UsbDeviceFilter.isElkSmart(device) -> ElkSmartUsbProtocolFormatter
+      UsbDeviceFilter.isElkSmart(device) -> ElkSmartUsbProtocolFormatter()
       UsbDeviceFilter.isZaZaRemoteFamily(device) -> UsbProtocolFormatter
       UsbDeviceFilter.isTiqiaaTviewFamily(device) -> UsbProtocolFormatter
       else -> UsbProtocolFormatter