yaver-feedback-react-native 0.9.7 → 0.9.9

package/README.md

@@ -113,8 +113,9 @@ still require the user's normal Yaver authentication.
 
 ### Device-enrolled Dogfood for apps without their own OAuth/backend
 
-Mount `FeedbackModal` once and configure the ACL-backed dynamic app shortcut.
-No permanent Settings row or shake gesture is required:
+Mount `FeedbackModal` once and configure the ACL-backed dynamic app shortcut
+plus smart quick controls. Keep a native Settings/Profile row as the universal
+enrollment and recovery route; no shake gesture is needed:
 
 ```tsx
 YaverFeedback.init({
@@ -128,20 +129,51 @@ YaverFeedback.init({
     label: 'Example',
     framework: 'expo',
     appShortcut: { label: 'Dogfood Example' },
+    controlGesture: {
+      durationMs: 900,
+      fallback: 'minimized-y',
+    },
     // Optional host presentation ACL. Backend account + phone-key approval
     // remains mandatory even when this returns true.
     canShow: (access) => appUser.isAdmin && access.authorized,
   },
 });
+
+// The host owns only placement of the entry point. The SDK owns OAuth,
+// continuation, machine/project/runner/model/lane selection and live logs.
+const onDogfoodPress = () => YaverFeedback.openDogfood();
 ```
 
 For first-time setup, a signed-in user opens the app from Yaver's Dogfood app
 catalog. The public deep link contains no token. The SDK runs stateful Yaver
 OAuth, machine, coding runner/model, project, and Browser/Hermes/WebRTC setup.
+OAuth returns directly to that setup in the currently running app; it does not
+restart the host. A valid cached Yaver session and prior selections skip steps
+that are already satisfied. Expo and React Native projects default to the
+Browser lane, while every selection remains changeable from Session setup.
 After the owner approves that exact account + app ID + phone key, iOS and
 Android add the long-press shortcut. Signing out, revocation, or host ACL denial
 removes it on the next foreground sync.
 
+Every newly authorized standalone installation starts with a partially
+edge-docked, fading Y, even when the phone supports three-finger input. Its
+one-time `Dogfood ready` card explains the entry point and records
+`controlOnboardingSeenAt` in Convex for the exact Yaver user + app +
+installation. After Continue, Settings in the compact card can switch between
+`Always show Y` and a three-finger hold; that preference is stored in the same
+Convex row and cached locally for cold start. Settings also reopens the session
+setup for machine, coding runner/model, and Browser/Hermes/WebRTC lane changes.
+
+In three-finger mode, a hold opens one compact card whose primary actions are
+exactly `Fast Reload` and `Chat`; nothing is rendered while the card is closed.
+The native observer does not consume ordinary app touches. If the native module
+is absent, the iOS Simulator cannot supply genuine three-finger input, or
+VoiceOver/TalkBack owns multi-touch, the SDK keeps the draggable Y and omits the
+irrelevant mode preference. Inside Yaver's own
+container both are suppressed: the host already renders preview/lane controls
+beside its chat/vibing surface. Tablets follow the same host-vs-standalone rule
+as phones; viewport size never decides ownership.
+
 The app creates a random installation ID and Ed25519 key inside SecureStore.
 The ID is a public handle, not a credential: enrollment and each short session
 require a server challenge signed by the private key. An owner approves,
@@ -753,11 +785,11 @@ YaverFeedback.init({
 
 When a third-party app is loaded through Yaver's Hermes-push flow (so the
 Yaver mobile app is the runtime container for your app), the SDK detects
-that situation via the `YaverInfo` native module and **automatically
-no-ops `YaverFeedback.init()`** — no ShakeDetector, no FeedbackModal, no
-BlackBox stream from inside the guest. The user only ever sees Yaver's
-native shake overlay ("Reload" + "Back to Yaver") and uses Yaver's
-built-in feedback flow instead.
+that situation via the `YaverInfo` native module and suppresses guest-owned
+triggers and overlays: no three-finger listener, minimized Y, shake detector,
+or duplicate quick controls. Yaver owns the workspace, with the app preview
+(Browser/WebRTC/Hermes lane) beside the chat/vibing surface on wider screens
+and in a responsive stacked layout on phones.
 
 Standalone installs (TestFlight / App Store / Play from your own dev
 account) are unaffected — the SDK behaves exactly as it did before.

package/android/src/main/java/io/yaver/feedback/YaverDogfoodGestureModule.java

@@ -0,0 +1,241 @@
+package io.yaver.feedback;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.HapticFeedbackConstants;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.Window;
+import android.view.accessibility.AccessibilityManager;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Proxy;
+import java.util.HashMap;
+import java.util.Map;
+
+/** Passive three-finger hold observer for the Dogfood two-action card. */
+public final class YaverDogfoodGestureModule extends ReactContextBaseJavaModule
+        implements LifecycleEventListener,
+        AccessibilityManager.TouchExplorationStateChangeListener {
+
+    private static final String MODULE_NAME = "YaverDogfoodGesture";
+    private static final String TRIGGER_EVENT = "yaverDogfoodControlGesture";
+    private static final String CAPABILITY_EVENT = "yaverDogfoodControlCapability";
+
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+    private final AccessibilityManager accessibilityManager;
+    private final Map<Integer, float[]> initialPoints = new HashMap<>();
+    private boolean requestedEnabled = false;
+    private long durationMs = 900;
+    private boolean fired = false;
+    private float touchSlop = 16f;
+    private Activity attachedActivity;
+    private Window attachedWindow;
+    private Window.Callback originalCallback;
+    private Window.Callback observingCallback;
+
+    private final Runnable fireGesture = () -> {
+        if (!requestedEnabled || fired || initialPoints.size() < 3 || accessibilityConflict()) return;
+        fired = true;
+        if (attachedWindow != null) {
+            View decor = attachedWindow.getDecorView();
+            decor.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
+        }
+        WritableMap event = Arguments.createMap();
+        event.putString("source", "three-finger-hold");
+        emit(TRIGGER_EVENT, event);
+    };
+
+    public YaverDogfoodGestureModule(ReactApplicationContext context) {
+        super(context);
+        accessibilityManager = (AccessibilityManager) context.getSystemService(Context.ACCESSIBILITY_SERVICE);
+        context.addLifecycleEventListener(this);
+        if (accessibilityManager != null) {
+            accessibilityManager.addTouchExplorationStateChangeListener(this);
+        }
+    }
+
+    @Override
+    @NonNull
+    public String getName() {
+        return MODULE_NAME;
+    }
+
+    @ReactMethod
+    public void getCapability(Promise promise) {
+        mainHandler.post(() -> promise.resolve(status()));
+    }
+
+    @ReactMethod
+    public void setEnabled(boolean enabled, double requestedDurationMs, Promise promise) {
+        mainHandler.post(() -> {
+            requestedEnabled = enabled;
+            durationMs = Math.max(650L, Math.min(2000L, Math.round(requestedDurationMs)));
+            reconcile();
+            promise.resolve(status());
+        });
+    }
+
+    private boolean accessibilityConflict() {
+        return accessibilityManager != null && accessibilityManager.isTouchExplorationEnabled();
+    }
+
+    private WritableMap status() {
+        WritableMap result = Arguments.createMap();
+        boolean supported = !accessibilityConflict();
+        result.putBoolean("supported", supported);
+        result.putBoolean("enabled", requestedEnabled && supported && observingCallback != null);
+        result.putString("reason", !supported
+                ? "accessibility-touch-exploration"
+                : (getCurrentActivity() == null ? "window-unavailable" : "supported"));
+        result.putString("platform", "android");
+        return result;
+    }
+
+    private void reconcile() {
+        Activity current = getCurrentActivity();
+        if (!requestedEnabled || accessibilityConflict() || current == null) {
+            detach();
+            return;
+        }
+        Window window = current.getWindow();
+        if (attachedActivity == current && attachedWindow == window
+                && window.getCallback() == observingCallback) return;
+        detach();
+        Window.Callback callback = window.getCallback();
+        if (callback == null) return;
+        touchSlop = ViewConfiguration.get(current).getScaledTouchSlop();
+        Window.Callback proxy = (Window.Callback) Proxy.newProxyInstance(
+                YaverDogfoodGestureModule.class.getClassLoader(),
+                new Class<?>[]{Window.Callback.class},
+                (ignored, method, args) -> {
+                    if ("dispatchTouchEvent".equals(method.getName())
+                            && args != null && args.length == 1 && args[0] instanceof MotionEvent) {
+                        observe((MotionEvent) args[0]);
+                    }
+                    try {
+                        return method.invoke(callback, args);
+                    } catch (InvocationTargetException error) {
+                        throw error.getCause();
+                    }
+                });
+        attachedActivity = current;
+        attachedWindow = window;
+        originalCallback = callback;
+        observingCallback = proxy;
+        window.setCallback(proxy);
+    }
+
+    private void detach() {
+        cancelGesture();
+        if (attachedWindow != null && attachedWindow.getCallback() == observingCallback
+                && originalCallback != null) {
+            attachedWindow.setCallback(originalCallback);
+        }
+        attachedActivity = null;
+        attachedWindow = null;
+        originalCallback = null;
+        observingCallback = null;
+    }
+
+    /** Observe without consuming: the original Window.Callback always receives the event. */
+    private void observe(MotionEvent event) {
+        if (!requestedEnabled || accessibilityConflict()) return;
+        switch (event.getActionMasked()) {
+            case MotionEvent.ACTION_DOWN:
+                cancelGesture();
+                rememberPointers(event);
+                break;
+            case MotionEvent.ACTION_POINTER_DOWN:
+                rememberPointers(event);
+                if (event.getPointerCount() >= 3 && !fired) {
+                    mainHandler.removeCallbacks(fireGesture);
+                    mainHandler.postDelayed(fireGesture, durationMs);
+                }
+                break;
+            case MotionEvent.ACTION_MOVE:
+                if (movedTooFar(event)) cancelGesture();
+                break;
+            case MotionEvent.ACTION_POINTER_UP:
+            case MotionEvent.ACTION_UP:
+            case MotionEvent.ACTION_CANCEL:
+                cancelGesture();
+                break;
+            default:
+                break;
+        }
+    }
+
+    private void rememberPointers(MotionEvent event) {
+        for (int index = 0; index < event.getPointerCount(); index++) {
+            int id = event.getPointerId(index);
+            if (!initialPoints.containsKey(id)) {
+                initialPoints.put(id, new float[]{event.getX(index), event.getY(index)});
+            }
+        }
+    }
+
+    private boolean movedTooFar(MotionEvent event) {
+        for (int index = 0; index < event.getPointerCount(); index++) {
+            float[] start = initialPoints.get(event.getPointerId(index));
+            if (start == null) continue;
+            if (Math.abs(event.getX(index) - start[0]) > touchSlop
+                    || Math.abs(event.getY(index) - start[1]) > touchSlop) return true;
+        }
+        return false;
+    }
+
+    private void cancelGesture() {
+        mainHandler.removeCallbacks(fireGesture);
+        initialPoints.clear();
+        fired = false;
+    }
+
+    private void emit(String name, WritableMap body) {
+        try {
+            getReactApplicationContext()
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit(name, body);
+        } catch (RuntimeException ignored) {
+            // No JS bridge/listener yet; a trigger must never break the host app.
+        }
+    }
+
+    private void emitCapability() {
+        emit(CAPABILITY_EVENT, status());
+    }
+
+    @Override
+    public void onHostResume() {
+        mainHandler.post(() -> {
+            reconcile();
+            emitCapability();
+        });
+    }
+
+    @Override public void onHostPause() { cancelGesture(); }
+
+    @Override public void onHostDestroy() { detach(); }
+
+    @Override
+    public void onTouchExplorationStateChanged(boolean enabled) {
+        mainHandler.post(() -> {
+            reconcile();
+            emitCapability();
+        });
+    }
+}

package/android/src/main/java/io/yaver/feedback/YaverHotReloadPackage.java

@@ -22,6 +22,7 @@ public class YaverHotReloadPackage implements ReactPackage {
     public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
         List<NativeModule> modules = new ArrayList<>();
         modules.add(new YaverHotReloadModule(reactContext));
+        modules.add(new YaverDogfoodGestureModule(reactContext));
         return modules;
     }
 

package/app.plugin.js

@@ -137,7 +137,12 @@ function withYaverHotReloadNativeModule(config) {
         appName
       );
 
-      const filesToCopy = ["YaverHotReload.swift", "YaverHotReload.m"];
+      const filesToCopy = [
+        "YaverHotReload.swift",
+        "YaverHotReload.m",
+        "YaverDogfoodGesture.swift",
+        "YaverDogfoodGesture.m",
+      ];
       for (const fileName of filesToCopy) {
         const src = path.join(sdkIosDir, fileName);
         const dst = path.join(targetDir, fileName);
@@ -175,7 +180,12 @@ function withYaverHotReloadNativeModule(config) {
     const target = proj.getFirstTarget();
     if (!target || !target.uuid) return config;
 
-    const filesToAdd = ["YaverHotReload.swift", "YaverHotReload.m"];
+    const filesToAdd = [
+      "YaverHotReload.swift",
+      "YaverHotReload.m",
+      "YaverDogfoodGesture.swift",
+      "YaverDogfoodGesture.m",
+    ];
     for (const fileName of filesToAdd) {
       const relPath = `${appName}/${fileName}`;
       // addSourceFile registers PBXFileReference + PBXBuildFile, adds

package/dist/AuthOverlay.js

@@ -61,6 +61,17 @@ const AuthOverlay = () => {
         setLoginVisible(false);
         setPickerVisible(false);
     }, []);
+    const continueDogfood = (0, react_1.useCallback)(async () => {
+        try {
+            const state = await YaverFeedback_1.YaverFeedback.continueDogfoodOnboarding();
+            if (state.phase === 'denied' || state.phase === 'error') {
+                react_native_1.Alert.alert('Dogfood unavailable', state.error || 'This Yaver account or device is not enabled for this app.');
+            }
+        }
+        catch (cause) {
+            react_native_1.Alert.alert('Dogfood unavailable', cause instanceof Error ? cause.message : 'Yaver could not continue Dogfood setup.');
+        }
+    }, []);
     (0, react_1.useEffect)(() => {
         let mounted = true;
         void (0, auth_1.getToken)().then((cached) => {
@@ -91,7 +102,7 @@ const AuthOverlay = () => {
         await YaverFeedback_1.YaverFeedback.setAuthToken(newToken);
         if (YaverFeedback_1.YaverFeedback.getDogfoodOnboarding()) {
             closeAll();
-            await YaverFeedback_1.YaverFeedback.continueDogfoodOnboarding();
+            await continueDogfood();
         }
         else {
             openPicker();
@@ -101,7 +112,7 @@ const AuthOverlay = () => {
         await YaverFeedback_1.YaverFeedback.setPreferredDevice(device.deviceId);
         closeAll();
         if (YaverFeedback_1.YaverFeedback.getDogfoodOnboarding()) {
-            await YaverFeedback_1.YaverFeedback.continueDogfoodOnboarding();
+            await continueDogfood();
         }
         else {
             react_native_1.DeviceEventEmitter.emit('yaverFeedback:startReport');

package/dist/DogfoodQuickControls.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+/**
+ * The standalone SDK's only persistent chrome. A newly authorized tester sees
+ * this edge-docked Y until first-run onboarding is completed in Convex. After
+ * that, capable devices default to a passive three-finger hold; unsupported
+ * devices keep the Y. Both entry points open exactly the same compact card.
+ */
+export declare const DogfoodQuickControls: React.FC;