@capgo/capacitor-screen-orientation 8.1.21 → 8.3.0

package/android/src/main/java/ee/forgr/capacitor/screenorientation/CapacitorScreenOrientationPlugin.java

@@ -7,23 +7,60 @@ import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
 import android.hardware.SensorManager;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
 import android.view.Surface;
 import com.getcapacitor.JSObject;
 import com.getcapacitor.Plugin;
 import com.getcapacitor.PluginCall;
 import com.getcapacitor.PluginMethod;
 import com.getcapacitor.annotation.CapacitorPlugin;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Executor;
+import org.json.JSONObject;
 
 @CapacitorPlugin(name = "CapacitorScreenOrientation")
 public class CapacitorScreenOrientationPlugin extends Plugin implements SensorEventListener {
 
-    private final String pluginVersion = "8.1.21";
+    private final String pluginVersion = "8.3.0";
     private int currentOrientation;
     private SensorManager sensorManager;
     private Sensor accelerometer;
     private boolean isTrackingMotion = false;
     private String currentPhysicalOrientation = "portrait-primary";
     private String lastNotifiedOrientation = null;
+    private FoldLayout foldLayout;
+    private Sensor hingeSensor;
+    private boolean hingeRegistered = false;
+    private Float lastHingeAngle = null;
+    private String lastSizeClassKey = null;
+    private final List<PluginCall> pendingHingeCalls = new ArrayList<>();
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+    private final SensorEventListener hingeListener = new SensorEventListener() {
+        @Override
+        public void onSensorChanged(SensorEvent event) {
+            if (event.values.length == 0) {
+                return;
+            }
+            float angle = Math.max(0f, Math.min(360f, event.values[0]));
+            boolean unchanged = lastHingeAngle != null && Math.abs(lastHingeAngle - angle) < 0.5f;
+            lastHingeAngle = angle;
+            if (unchanged && pendingHingeCalls.isEmpty()) {
+                return;
+            }
+            JSObject payload = hingePayload(angle);
+            notifyListeners("hingeAngleChange", payload);
+            resolvePendingHinge(payload);
+            if (!hasListeners("hingeAngleChange")) {
+                stopHingeTracking();
+            }
+        }
+
+        @Override
+        public void onAccuracyChanged(Sensor sensor, int accuracy) {}
+    };
 
     @Override
     public void load() {
@@ -34,12 +71,26 @@ public class CapacitorScreenOrientationPlugin extends Plugin implements SensorEv
         sensorManager = (SensorManager) getActivity().getSystemService(Context.SENSOR_SERVICE);
         if (sensorManager != null) {
             accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                hingeSensor = sensorManager.getDefaultSensor(Sensor.TYPE_HINGE_ANGLE);
+            }
         }
+
+        Executor executor = mainHandler::post;
+        foldLayout = new FoldLayout(getActivity(), bridge.getWebView(), executor, (state) -> {
+            notifyListeners("foldStateChange", state);
+            notifySizeClassIfChanged();
+        });
+        notifySizeClassIfChanged();
     }
 
     @Override
     protected void handleOnDestroy() {
         stopMotionTracking();
+        stopHingeTracking();
+        if (foldLayout != null) {
+            foldLayout.stop();
+        }
         super.handleOnDestroy();
     }
 
@@ -47,6 +98,8 @@ public class CapacitorScreenOrientationPlugin extends Plugin implements SensorEv
     protected void handleOnConfigurationChanged(Configuration newConfig) {
         super.handleOnConfigurationChanged(newConfig);
 
+        notifySizeClassIfChanged();
+
         // Skip system orientation changes when motion tracking is active
         // to avoid duplicate events
         if (isTrackingMotion) {
@@ -59,6 +112,101 @@ public class CapacitorScreenOrientationPlugin extends Plugin implements SensorEv
         }
     }
 
+    @PluginMethod(returnType = PluginMethod.RETURN_NONE)
+    @Override
+    public void addListener(PluginCall call) {
+        super.addListener(call);
+        String eventName = call.getString("eventName");
+        if ("hingeAngleChange".equals(eventName)) {
+            mainHandler.post(this::startHingeTracking);
+        }
+    }
+
+    @PluginMethod(returnType = PluginMethod.RETURN_NONE)
+    @Override
+    public void removeListener(PluginCall call) {
+        super.removeListener(call);
+        if (!hasListeners("hingeAngleChange")) {
+            mainHandler.post(this::stopHingeTracking);
+        }
+    }
+
+    @PluginMethod
+    @Override
+    public void removeAllListeners(PluginCall call) {
+        super.removeAllListeners(call);
+        mainHandler.post(this::stopHingeTracking);
+    }
+
+    @PluginMethod
+    public void isDeviceFoldable(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("foldable", foldLayout != null && foldLayout.isFoldable());
+        result.put("supportsTabletop", foldLayout != null && foldLayout.supportsTabletop());
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void getFoldState(PluginCall call) {
+        call.resolve(foldLayout == null ? flatFold() : foldLayout.currentState());
+    }
+
+    @PluginMethod
+    public void getHingeAngle(PluginCall call) {
+        mainHandler.post(() -> {
+            if (hingeRegistered && lastHingeAngle != null) {
+                call.resolve(hingePayload(lastHingeAngle));
+                return;
+            }
+            if (hingeSensor == null) {
+                call.resolve(hingePayload(null));
+                return;
+            }
+            pendingHingeCalls.add(call);
+            startHingeTracking();
+            mainHandler.postDelayed(
+                () -> {
+                    if (!pendingHingeCalls.contains(call)) {
+                        return;
+                    }
+                    pendingHingeCalls.remove(call);
+                    call.resolve(hingePayload(null));
+                    if (!hasListeners("hingeAngleChange") && pendingHingeCalls.isEmpty()) {
+                        stopHingeTracking();
+                    }
+                },
+                800
+            );
+        });
+    }
+
+    @PluginMethod
+    public void getSizeClass(PluginCall call) {
+        call.resolve(currentSizeClass());
+    }
+
+    @PluginMethod
+    public void getReservedRegions(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("regions", new org.json.JSONArray());
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void getBarPlacement(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("verticalBarEdge", JSONObject.NULL);
+        result.put("inset", 0);
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void setVerticalBarBehavior(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("applied", false);
+        call.resolve(result);
+    }
+
     @PluginMethod
     public void orientation(final PluginCall call) {
         try {
@@ -198,6 +346,68 @@ public class CapacitorScreenOrientationPlugin extends Plugin implements SensorEv
         }
     }
 
+    private JSObject currentSizeClass() {
+        if (foldLayout != null) {
+            return foldLayout.sizeClass();
+        }
+        return FoldLayout.sizeClassOf(0f, 0f);
+    }
+
+    private void notifySizeClassIfChanged() {
+        JSObject sizeClass = currentSizeClass();
+        String key = sizeClass.toString();
+        if (key.equals(lastSizeClassKey)) {
+            return;
+        }
+        lastSizeClassKey = key;
+        notifyListeners("sizeClassChange", sizeClass);
+    }
+
+    private void startHingeTracking() {
+        if (hingeRegistered || hingeSensor == null || sensorManager == null) {
+            return;
+        }
+        hingeRegistered = true;
+        sensorManager.registerListener(hingeListener, hingeSensor, SensorManager.SENSOR_DELAY_NORMAL, mainHandler);
+    }
+
+    private void stopHingeTracking() {
+        if (!hingeRegistered || sensorManager == null) {
+            return;
+        }
+        hingeRegistered = false;
+        sensorManager.unregisterListener(hingeListener);
+    }
+
+    private void resolvePendingHinge(JSObject payload) {
+        if (pendingHingeCalls.isEmpty()) {
+            return;
+        }
+        List<PluginCall> pending = new ArrayList<>(pendingHingeCalls);
+        pendingHingeCalls.clear();
+        for (PluginCall call : pending) {
+            call.resolve(payload);
+        }
+    }
+
+    private static JSObject hingePayload(Float angle) {
+        JSObject result = new JSObject();
+        if (angle == null) {
+            result.put("angle", JSONObject.NULL);
+        } else {
+            result.put("angle", angle.doubleValue());
+        }
+        return result;
+    }
+
+    private static JSObject flatFold() {
+        JSObject state = new JSObject();
+        state.put("state", "flat");
+        state.put("isSeparating", false);
+        state.put("posture", "flat");
+        return state;
+    }
+
     // Motion tracking methods
     private void startMotionTracking() {
         if (isTrackingMotion || accelerometer == null) {

package/android/src/main/java/ee/forgr/capacitor/screenorientation/FoldLayout.java

@@ -0,0 +1,176 @@
+package ee.forgr.capacitor.screenorientation;
+
+import android.app.Activity;
+import android.content.pm.PackageManager;
+import android.graphics.Rect;
+import android.os.Build;
+import android.view.View;
+import androidx.core.util.Consumer;
+import androidx.window.java.layout.WindowInfoTrackerCallbackAdapter;
+import androidx.window.layout.DisplayFeature;
+import androidx.window.layout.FoldingFeature;
+import androidx.window.layout.SupportedPosture;
+import androidx.window.layout.WindowInfoTracker;
+import androidx.window.layout.WindowLayoutInfo;
+import androidx.window.layout.WindowMetricsCalculator;
+import com.getcapacitor.JSObject;
+import java.util.concurrent.Executor;
+
+/**
+ * Reads Jetpack WindowManager fold state for the current activity.
+ * The hinge sensor itself stays in the plugin so it can run only while a listener is registered.
+ */
+final class FoldLayout implements Consumer<WindowLayoutInfo> {
+
+    interface Callback {
+        void onFoldState(JSObject state);
+    }
+
+    private final Activity activity;
+    private final View webView;
+    private final WindowInfoTrackerCallbackAdapter adapter;
+    private final Executor executor;
+    private final Callback callback;
+    private final boolean supportsTabletop;
+    private JSObject current = flatState();
+    private boolean sawFold = false;
+
+    FoldLayout(Activity activity, View webView, Executor executor, Callback callback) {
+        this.activity = activity;
+        this.webView = webView;
+        this.executor = executor;
+        this.callback = callback;
+        WindowInfoTracker tracker = WindowInfoTracker.getOrCreate(activity);
+        this.adapter = new WindowInfoTrackerCallbackAdapter(tracker);
+        this.supportsTabletop = supportsTabletop(tracker);
+        this.current = toFoldState(firstFold());
+        this.adapter.addWindowLayoutInfoListener(activity, executor, this);
+    }
+
+    private FoldingFeature firstFold() {
+        WindowLayoutInfo info;
+        try {
+            info = adapter.getCurrentWindowLayoutInfo(activity);
+        } catch (UnsupportedOperationException ignored) {
+            return null;
+        }
+        for (DisplayFeature feature : info.getDisplayFeatures()) {
+            if (feature instanceof FoldingFeature) {
+                sawFold = true;
+                return (FoldingFeature) feature;
+            }
+        }
+        return null;
+    }
+
+    void stop() {
+        adapter.removeWindowLayoutInfoListener(this);
+    }
+
+    JSObject currentState() {
+        return current;
+    }
+
+    boolean isFoldable() {
+        if (sawFold || supportsTabletop) {
+            return true;
+        }
+        return (
+            Build.VERSION.SDK_INT >= Build.VERSION_CODES.R &&
+            activity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_SENSOR_HINGE_ANGLE)
+        );
+    }
+
+    boolean supportsTabletop() {
+        return supportsTabletop;
+    }
+
+    JSObject sizeClass() {
+        Rect bounds = WindowMetricsCalculator.getOrCreate().computeCurrentWindowMetrics(activity).getBounds();
+        float density = activity.getResources().getDisplayMetrics().density;
+        return sizeClassOf(bounds.width() / density, bounds.height() / density);
+    }
+
+    static JSObject sizeClassOf(float widthDp, float heightDp) {
+        JSObject result = new JSObject();
+        result.put("horizontal", widthDp >= 600f ? "regular" : "compact");
+        result.put("vertical", heightDp >= 480f ? "regular" : "compact");
+        result.put("widthClass", widthClass(widthDp));
+        result.put("heightClass", heightDp >= 900f ? "expanded" : heightDp >= 480f ? "medium" : "compact");
+        return result;
+    }
+
+    @Override
+    public void accept(WindowLayoutInfo info) {
+        FoldingFeature fold = null;
+        for (DisplayFeature feature : info.getDisplayFeatures()) {
+            if (feature instanceof FoldingFeature) {
+                fold = (FoldingFeature) feature;
+                break;
+            }
+        }
+        if (fold != null) {
+            sawFold = true;
+        }
+        current = toFoldState(fold);
+        callback.onFoldState(current);
+    }
+
+    private JSObject toFoldState(FoldingFeature fold) {
+        if (fold == null) {
+            return flatState();
+        }
+
+        float density = activity.getResources().getDisplayMetrics().density;
+        int[] offset = new int[2];
+        webView.getLocationInWindow(offset);
+        JSObject bounds = boundsOf(fold.getBounds(), density, offset[0], offset[1]);
+
+        boolean halfOpened = FoldingFeature.State.HALF_OPENED.equals(fold.getState());
+        boolean horizontal = FoldingFeature.Orientation.HORIZONTAL.equals(fold.getOrientation());
+
+        JSObject state = new JSObject();
+        state.put("state", halfOpened ? "half-opened" : "flat");
+        state.put("isSeparating", fold.isSeparating());
+        state.put("posture", !halfOpened ? "flat" : horizontal ? "tabletop" : "book");
+        state.put("hingeOrientation", horizontal ? "horizontal" : "vertical");
+        state.put("hingeBounds", bounds);
+        if (FoldingFeature.OcclusionType.FULL.equals(fold.getOcclusionType())) {
+            state.put("occludedBounds", bounds);
+        }
+        return state;
+    }
+
+    private static JSObject boundsOf(Rect rect, float density, int offsetX, int offsetY) {
+        JSObject bounds = new JSObject();
+        bounds.put("x", Math.round((rect.left - offsetX) / density));
+        bounds.put("y", Math.round((rect.top - offsetY) / density));
+        bounds.put("width", Math.round(rect.width() / density));
+        bounds.put("height", Math.round(rect.height() / density));
+        return bounds;
+    }
+
+    private static JSObject flatState() {
+        JSObject state = new JSObject();
+        state.put("state", "flat");
+        state.put("isSeparating", false);
+        state.put("posture", "flat");
+        return state;
+    }
+
+    private static String widthClass(float widthDp) {
+        if (widthDp >= 1600f) return "extraLarge";
+        if (widthDp >= 1200f) return "large";
+        if (widthDp >= 840f) return "expanded";
+        if (widthDp >= 600f) return "medium";
+        return "compact";
+    }
+
+    private static boolean supportsTabletop(WindowInfoTracker tracker) {
+        try {
+            return tracker.getSupportedPostures().contains(SupportedPosture.TABLETOP);
+        } catch (RuntimeException ignored) {
+            return false;
+        }
+    }
+}