Add Tasker action to buzz the whoop, and ability to subscribe to double-tap from Tasker

.gitignore

@@ -1,3 +1,5 @@
+.fvm
+.fvmrc
 # Miscellaneous
 *.class
 *.log

android/app/src/main/AndroidManifest.xml

@@ -144,6 +144,17 @@
             </intent-filter>
         </receiver>
 
+        <!-- Tasker integration: receive Broadcast intents from Tasker (or any app)
+             to buzz the WHOOP strap. Optional int extra "pattern" (default 2). -->
+        <receiver
+            android:name=".TaskerReceiver"
+            android:exported="true"
+            android:enabled="true">
+            <intent-filter>
+                <action android:name="wtf.openstrap.openstrap_edge.BUZZ_STRAP" />
+            </intent-filter>
+        </receiver>
+
         <!-- Notification relay (notification_listener_service plugin). The system binds
              this to deliver posted notifications; gated behind the user granting
              "Notification access" in system settings. Class lives in the plugin. -->

android/app/src/main/kotlin/wtf/openstrap/openstrap_edge/NativeChannels.kt

@@ -29,6 +29,7 @@ object NativeChannels {
     private const val EDGE_TRACKING_CHANNEL = "openstrap/edge_tracking"
     private const val DEVICE_ACTIONS_CHANNEL = "openstrap/device_actions"
     private const val ANDROID_BG_CHANNEL = "openstrap/android_background"
+    const val ACTION_DOUBLE_TAP = "wtf.openstrap.openstrap_edge.DOUBLE_TAP"
 
     private var torchOn = false
 
@@ -107,7 +108,8 @@ object NativeChannels {
                     "capabilities" -> result.success(
                         listOf(
                             "media_play_pause", "media_next", "media_prev",
-                            "volume_up", "volume_down", "ring_phone", "torch"
+                            "volume_up", "volume_down", "ring_phone", "torch",
+                            "broadcast_to_tasker"
                         )
                     )
                     "perform" -> result.success(perform(app, call.argument<String>("action") ?: ""))
@@ -126,6 +128,7 @@ object NativeChannels {
                 "volume_down" -> adjustVolume(ctx, AudioManager.ADJUST_LOWER)
                 "ring_phone" -> ringPhone(ctx)
                 "torch" -> toggleTorch(ctx)
+                "broadcast_to_tasker" -> sendTaskerBroadcast(ctx)
                 else -> return false
             }
             true
@@ -321,4 +324,17 @@ object NativeChannels {
             vibrator.vibrate(500)
         }
     }
+
+    /** Send a broadcast intent so Tasker (or any automation app) can subscribe
+     * to band double-taps. The intent action is
+     * `wtf.openstrap.openstrap_edge.DOUBLE_TAP`; Tasker listens via
+     * Event → Intent Received.
+     */
+    private fun sendTaskerBroadcast(ctx: Context) {
+        val intent = Intent(ACTION_DOUBLE_TAP).apply {
+            addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES)
+        }
+        ctx.sendBroadcast(intent)
+    }
+
 }

android/app/src/main/kotlin/wtf/openstrap/openstrap_edge/TaskerReceiver.kt

@@ -0,0 +1,62 @@
+package wtf.openstrap.openstrap_edge
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import io.flutter.embedding.engine.FlutterEngineCache
+import io.flutter.plugin.common.MethodChannel
+
+class TaskerReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val action = intent.action
+        Log.i(TAG, "onReceive: action=$action")
+        if (action != ACTION_BUZZ_STRAP) return
+
+        val pattern = intent.getIntExtra(EXTRA_PATTERN, DEFAULT_PATTERN)
+        Log.i(TAG, "pattern=$pattern")
+
+        val engine = FlutterEngineCache.getInstance()
+            .get(EdgeApplication.ENGINE_ID)
+
+        if (engine != null) {
+            Log.i(TAG, "engine alive, invoking method channel")
+            val args = java.util.HashMap<String, Any>()
+            args["pattern"] = pattern
+            MethodChannel(
+                engine.dartExecutor.binaryMessenger,
+                CHANNEL
+            ).invokeMethod("buzz_strap", args)
+            return
+        }
+
+        Log.i(TAG, "engine dead, persisting pending flag")
+        val prefs = context.getSharedPreferences(
+            "openstrap_runtime",
+            Context.MODE_PRIVATE
+        )
+        prefs.edit()
+            .putBoolean(PENDING_BUZZ_KEY, true)
+            .putInt(PENDING_PATTERN_KEY, pattern)
+            .apply()
+
+        val svcIntent = Intent(context, EdgeTrackingService::class.java)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            context.startForegroundService(svcIntent)
+        } else {
+            context.startService(svcIntent)
+        }
+    }
+
+    companion object {
+        const val TAG = "TaskerReceiver"
+        const val ACTION_BUZZ_STRAP =
+            "wtf.openstrap.openstrap_edge.BUZZ_STRAP"
+        const val EXTRA_PATTERN = "pattern"
+        const val PENDING_BUZZ_KEY = "pending_tasker_buzz"
+        const val PENDING_PATTERN_KEY = "pending_tasker_buzz_pattern"
+        const val DEFAULT_PATTERN = 2
+        private const val CHANNEL = "openstrap/tasker"
+    }
+}

guides/BUZZ_MEANINGS.md

@@ -0,0 +1,8 @@
+* `0`: A quick buzz of the device
+* `1`: An alarm, buzzes until acked by tapping the device
+* `2`: A quick double buzz
+* `3`: Nothing
+* `4`: Nothing
+* `5`: Nothing
+* `6`: Nothing
+* `7`: Nothing

lib/ble/ble_engine.dart

@@ -2508,8 +2508,10 @@ class BleEngine {
 
   Future<void> getBattery() => _send(Cmd.getBatteryLevel, const []);
   Future<void> getHello() => _send(Cmd.getHelloHarvard, const [0x00]);
-  Future<void> buzz() =>
-      _send(Cmd.runHapticsPattern, const [hapticShortPulse, 0, 0, 0, 0]);
+  Future<void> buzz() => buzzPattern(hapticShortPulse);
+
+  Future<void> buzzPattern(int pattern) =>
+      _send(Cmd.runHapticsPattern, [pattern, 0, 0, 0, 0]);
 
   /// Enable live foreground streams (makes the band emit live R10/R11 + optical).
   /// Optical stays WRIST-GATED (0x6B only). This sends the toggle commands but

lib/gestures/device_action.dart

@@ -24,6 +24,9 @@ enum DeviceAction {
   // (iOS can't reach other apps, but it can always do these).
   markMoment,
   workoutToggle,
+  // Native broadcast — sends an Android broadcast intent for Tasker to subscribe
+  // to (see NativeChannels.kt). Only offered on Android.
+  broadcastToTasker,
 }
 
 extension DeviceActionX on DeviceAction {
@@ -51,6 +54,8 @@ extension DeviceActionX on DeviceAction {
         return 'mark_moment';
       case DeviceAction.workoutToggle:
         return 'workout_toggle';
+      case DeviceAction.broadcastToTasker:
+        return 'broadcast_to_tasker';
     }
   }
 
@@ -77,6 +82,8 @@ extension DeviceActionX on DeviceAction {
         return 'Mark a moment';
       case DeviceAction.workoutToggle:
         return 'Start / stop workout';
+      case DeviceAction.broadcastToTasker:
+        return 'Broadcast to Tasker';
     }
   }
 
@@ -103,6 +110,8 @@ extension DeviceActionX on DeviceAction {
         return 'Tag the current moment in your journal.';
       case DeviceAction.workoutToggle:
         return 'Begin or end a workout from your wrist.';
+      case DeviceAction.broadcastToTasker:
+        return 'Fire a broadcast intent so Tasker can trigger any automation.';
     }
   }
 

lib/platform/tasker_bridge.dart

@@ -0,0 +1,40 @@
+import 'package:flutter/foundation.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:flutter/services.dart';
+
+class TaskerBridge {
+  static const _ch = MethodChannel('openstrap/tasker');
+  static const _pendingKey = 'pending_tasker_buzz';
+  static const _pendingPatternKey = 'pending_tasker_buzz_pattern';
+
+  final Future<void> Function(int pattern) buzzPattern;
+
+  TaskerBridge({required this.buzzPattern}) {
+    _ch.setMethodCallHandler(_onMethodCall);
+  }
+
+  Future<void> _onMethodCall(MethodCall call) async {
+    if (call.method == 'buzz_strap') {
+      try {
+        final args = call.arguments;
+        debugPrint('[tasker] _onMethodCall args=$args (${args.runtimeType})');
+        final map = args is Map ? args : <dynamic, dynamic>{};
+        final pattern = (map['pattern'] as int?) ?? 2;
+        debugPrint('[tasker] buzz pattern=$pattern');
+        await buzzPattern(pattern);
+      } catch (e, st) {
+        debugPrint('[tasker] buzz failed: $e\n$st');
+      }
+    }
+  }
+
+  static Future<int?> consumePendingBuzz() async {
+    final prefs = await SharedPreferences.getInstance();
+    final pending = prefs.getBool(_pendingKey) ?? false;
+    if (!pending) return null;
+    final pattern = prefs.getInt(_pendingPatternKey) ?? 2;
+    await prefs.remove(_pendingKey);
+    await prefs.remove(_pendingPatternKey);
+    return pattern;
+  }
+}

lib/state/app_state.dart

@@ -51,6 +51,7 @@ import '../health/health_export.dart';
 import '../import/noop_import.dart';
 import '../import/whoop_import.dart';
 import '../gestures/gesture_dispatcher.dart';
+import '../platform/tasker_bridge.dart';
 import '../data/models.dart';
 import '../live/live_activity.dart';
 import '../live/breathing_live_activity.dart';
@@ -125,6 +126,12 @@ class AppState extends ChangeNotifier {
     buzz: () => engine.buzz(),
     isConnected: () => engine.isConnected,
   );
+
+  /// Tasker integration bridge — listens for Android broadcast intents from
+  /// Tasker and buzzes the strap. Wired in the constructor.
+  late final TaskerBridge taskerBridge = TaskerBridge(
+    buzzPattern: (p) => engine.buzzPattern(p),
+  );
   Sample? lastSynced;
   // REAL device time (epoch SECONDS) of the newest record we hold — the band's
   // own clock, NOT when the BLE frame arrived. During a flash backfill, frames
@@ -650,6 +657,7 @@ class AppState extends ChangeNotifier {
     // skip the headless BLE path (it would fight FBP for the peripheral) — route
     // them to a catch-up pull over the existing live connection instead.
     IosBgTask.foregroundPull = foregroundCatchUp;
+    taskerBridge; // force init: register the method channel handler
     _init();
     // Notification taps → request a tab switch (the shell listens to navRequest).
     _tapSub = NotificationService.instance.taps.listen(_handleTapRoute);
@@ -1272,6 +1280,15 @@ class AppState extends ChangeNotifier {
         openSession();
       }
     }
+    unawaited(_checkPendingTaskerBuzz());
+  }
+
+  Future<void> _checkPendingTaskerBuzz() async {
+    if (!Platform.isAndroid) return;
+    final pattern = await TaskerBridge.consumePendingBuzz();
+    if (pattern == null) return;
+    _log('[tasker] consuming pending buzz (pattern=$pattern) from headless intent');
+    await engine.buzzPattern(pattern);
   }
 
   /// (Re)register standing scheduled reminders per the user's prefs. Idempotent;
@@ -2022,6 +2039,11 @@ class AppState extends ChangeNotifier {
     await engine.runAlarm();
   }
 
+  Future<void> testBuzzPattern(int pattern) async {
+    if (!isConnected) throw Exception('Connect to your strap first');
+    await engine.buzzPattern(pattern);
+  }
+
   Future<void> disableAlarm() async {
     if (!isConnected) throw Exception('Connect to your strap first');
     await engine.disableAlarm();

lib/ui/profile/gesture_section.dart

@@ -59,25 +59,34 @@ class GestureSettingsCard extends StatelessWidget {
                 Text('What happens when you double-tap the band.',
                     style: AppText.captionMuted),
                 const SizedBox(height: Sp.x4),
-                ...options.map((a) {
-                  final selected = a == settings.doubleTap;
-                  return ListRow(
-                    title: a.label,
-                    subtitle: a.blurb,
-                    trailing: selected
-                        ? AppIcon(OsIcon.check, size: 20, color: AppColors.positive)
-                        : const SizedBox(width: 20),
-                    onTap: () {
-                      settings.setDoubleTap(a);
-                      Navigator.of(sheetCtx).pop();
-                    },
-                  );
-                }),
-                if (options.length <= 1) ...[
-                  const SizedBox(height: Sp.x3),
-                  Text('No band actions are available on this device yet.',
-                      style: AppText.caption),
-                ],
+                Flexible(
+                  child: SingleChildScrollView(
+                    child: Column(
+                      mainAxisSize: MainAxisSize.min,
+                      children: [
+                        ...options.map((a) {
+                          final selected = a == settings.doubleTap;
+                          return ListRow(
+                            title: a.label,
+                            subtitle: a.blurb,
+                            trailing: selected
+                                ? AppIcon(OsIcon.check, size: 20, color: AppColors.positive)
+                                : const SizedBox(width: 20),
+                            onTap: () {
+                              settings.setDoubleTap(a);
+                              Navigator.of(sheetCtx).pop();
+                            },
+                          );
+                        }),
+                        if (options.length <= 1) ...[
+                          const SizedBox(height: Sp.x3),
+                          Text('No band actions are available on this device yet.',
+                              style: AppText.caption),
+                        ],
+                      ],
+                    ),
+                  ),
+                ),
               ],
             ),
           ),