react-native-android-overlay 0.1.0

package/android/src/main/java/tech/zmario/androidoverlay/service/OverlayService.java

@@ -0,0 +1,414 @@
+package tech.zmario.androidoverlay.service;
+
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.Application;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ServiceInfo;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Looper;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.View;
+import android.view.WindowManager;
+import android.widget.FrameLayout;
+import androidx.annotation.NonNull;
+import androidx.core.app.NotificationCompat;
+import com.facebook.react.ReactApplication;
+import com.facebook.react.ReactHost;
+import com.facebook.react.interfaces.fabric.ReactSurface;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import tech.zmario.androidoverlay.view.OverlayContainerView;
+
+public class OverlayService extends Service {
+
+  private static final String STOP_SERVICE_ACTION_NAME = "STOP_SERVICE_ACTION";
+  private static final String TAG = "OverlayService";
+  private static final String DEFAULT_CHANNEL_ID = "OverlayServiceChannel";
+  private static final int NOTIFICATION_ID = 1;
+  private static OverlayService instance = null;
+
+  private final Map<String, OverlayInstance> overlays = new ConcurrentHashMap<>();
+  private final Handler mainHandler = new Handler(Looper.getMainLooper());
+
+  private Application.ActivityLifecycleCallbacks lifecycleCallbacks = null;
+  private WindowManager windowManager;
+  private boolean isDestroyed = false;
+
+  public static OverlayService getInstance() {
+    return instance;
+  }
+
+  private ReactHost getReactHost() {
+    if (getApplication() instanceof ReactApplication reactApplication) {
+      return reactApplication.getReactHost();
+    }
+
+    return null;
+  }
+
+  @Override
+  public IBinder onBind(Intent intent) {
+    return null;
+  }
+
+  @Override
+  public void onCreate() {
+    super.onCreate();
+    instance = this;
+    isDestroyed = false;
+    windowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
+
+    keepReactHostAlive();
+
+    lifecycleCallbacks =
+        new Application.ActivityLifecycleCallbacks() {
+          @Override
+          public void onActivityCreated(@NonNull Activity activity, Bundle savedInstanceState) {}
+
+          @Override
+          public void onActivityStarted(@NonNull Activity activity) {}
+
+          @Override
+          public void onActivityResumed(@NonNull Activity activity) {
+            keepReactHostAlive();
+          }
+
+          @Override
+          public void onActivityPaused(@NonNull Activity activity) {
+            mainHandler.postDelayed(() -> keepReactHostAlive(), 100);
+          }
+
+          @Override
+          public void onActivityStopped(@NonNull Activity activity) {}
+
+          @Override
+          public void onActivitySaveInstanceState(
+              @NonNull Activity activity, @NonNull Bundle outState) {}
+
+          @Override
+          public void onActivityDestroyed(@NonNull Activity activity) {
+            mainHandler.postDelayed(() -> keepReactHostAlive(), 100);
+          }
+        };
+
+    getApplication().registerActivityLifecycleCallbacks(lifecycleCallbacks);
+    Log.d(TAG, "Service onCreate");
+  }
+
+  private void keepReactHostAlive() {
+    if (isDestroyed) return;
+    ReactHost reactHost = getReactHost();
+
+    if (reactHost != null) {
+      reactHost.onHostResume(null);
+    }
+  }
+
+  private boolean isAppInForeground() {
+    ActivityManager.RunningAppProcessInfo appProcessInfo = new ActivityManager.RunningAppProcessInfo();
+    ActivityManager.getMyMemoryState(appProcessInfo);
+    return (appProcessInfo.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND);
+  }
+
+  private void runOnMainThread(Runnable runnable) {
+    if (Looper.myLooper() == Looper.getMainLooper()) {
+      runnable.run();
+    } else {
+      mainHandler.post(runnable);
+    }
+  }
+
+  private void showOverlay(
+      String componentName,
+      double width,
+      double height,
+      double x,
+      double y,
+      String gravity,
+      boolean focusable,
+      boolean draggable,
+      boolean touchable) {
+    runOnMainThread(
+        () -> {
+          if (isDestroyed || overlays.containsKey(componentName) || windowManager == null) return;
+          Log.d(TAG, "Creating overlay component: " + componentName);
+
+          float density = getResources().getDisplayMetrics().density;
+          int screenWidth = getResources().getDisplayMetrics().widthPixels;
+
+          WindowManager.LayoutParams params =
+              OverlayLayoutParamsBuilder.build(
+                  width, height, x, y, gravity, focusable, touchable, density, screenWidth);
+          ReactHost reactHost = getReactHost();
+
+          if (reactHost == null) return;
+
+          keepReactHostAlive();
+
+          ReactSurface reactSurface =
+              reactHost.createSurface(getApplicationContext(), componentName, null);
+          reactSurface.start();
+
+          View reactView = reactSurface.getView();
+          OverlayContainerView container =
+              new OverlayContainerView(OverlayService.this, windowManager, draggable);
+
+          container.addView(
+              reactView,
+              new FrameLayout.LayoutParams(
+                  FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT));
+
+          try {
+            windowManager.addView(container, params);
+
+            OverlayInstance newInstance = new OverlayInstance(container, reactSurface);
+
+            overlays.put(componentName, newInstance);
+          } catch (Exception e) {
+            Log.e(TAG, "Failed to add window overlay", e);
+            reactSurface.stop();
+          }
+        });
+  }
+
+  public void stopOverlayInstance(String componentName) {
+    runOnMainThread(
+        () -> {
+          OverlayInstance inst = overlays.remove(componentName);
+          if (inst != null) {
+            Log.d(TAG, "Stopping overlay: " + componentName);
+            cleanUpInstance(inst);
+          }
+
+          if (overlays.isEmpty() && !isDestroyed) {
+            stopSelf();
+          }
+        });
+  }
+
+  public void startMove(String componentName) {
+    runOnMainThread(
+        () -> {
+          OverlayInstance inst = getOverlayInstance(componentName);
+          if (inst == null) return;
+          WindowManager.LayoutParams params =
+              (WindowManager.LayoutParams) inst.getOverlayView().getLayoutParams();
+          inst.setInitialX(params.x);
+          inst.setInitialY(params.y);
+        });
+  }
+
+  public void moveOverlay(String componentName, int dx, int dy) {
+    runOnMainThread(
+        () -> {
+          OverlayInstance inst = getOverlayInstance(componentName);
+          if (inst == null) return;
+          WindowManager.LayoutParams params =
+              (WindowManager.LayoutParams) inst.getOverlayView().getLayoutParams();
+
+          params.x = inst.getInitialX() + dx;
+          if ((params.gravity & Gravity.BOTTOM) == Gravity.BOTTOM) {
+            params.y = inst.getInitialY() - dy;
+          } else {
+            params.y = inst.getInitialY() + dy;
+          }
+
+          try {
+            windowManager.updateViewLayout(inst.getOverlayView(), params);
+          } catch (Exception e) {
+            Log.e(TAG, "Failed to move overlay", e);
+          }
+        });
+  }
+
+  public void commitMove(String componentName) {
+    runOnMainThread(
+        () -> {
+          OverlayInstance inst = getOverlayInstance(componentName);
+
+          if (inst == null) return;
+          WindowManager.LayoutParams params =
+              (WindowManager.LayoutParams) inst.getOverlayView().getLayoutParams();
+
+          inst.setInitialX(params.x);
+          inst.setInitialY(params.y);
+        });
+  }
+
+  public void resizeOverlay(String componentName, int width, int height) {
+    runOnMainThread(
+        () -> {
+          OverlayInstance inst = getOverlayInstance(componentName);
+          if (inst == null) return;
+          WindowManager.LayoutParams params =
+              (WindowManager.LayoutParams) inst.getOverlayView().getLayoutParams();
+
+          if (params.width != width || params.height != height) {
+            params.width = width;
+            params.height = height;
+            try {
+              windowManager.updateViewLayout(inst.getOverlayView(), params);
+            } catch (Exception e) {
+              Log.e(TAG, "Failed to resize overlay", e);
+            }
+          }
+        });
+  }
+
+  @Override
+  public int onStartCommand(Intent intent, int flags, int startId) {
+    if (intent != null) {
+      String action = intent.getAction();
+
+      if (action != null && action.equals(STOP_SERVICE_ACTION_NAME)) {
+        stopSelf();
+        return START_NOT_STICKY;
+      }
+
+      if (action == null) {
+        boolean foreground = intent.getBooleanExtra("foreground", true);
+
+        if (foreground) {
+          Notification notification = createForegroundNotification(intent);
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            startForeground(
+                NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_SPECIAL_USE);
+          } else {
+            startForeground(NOTIFICATION_ID, notification);
+          }
+        }
+
+        String componentName = intent.getStringExtra("componentName");
+        double width = intent.getDoubleExtra("width", -1);
+        double height = intent.getDoubleExtra("height", -1);
+        double x = intent.getDoubleExtra("x", 0);
+        double y = intent.getDoubleExtra("y", 150);
+        boolean focusable = intent.getBooleanExtra("focusable", false);
+        boolean draggable = intent.getBooleanExtra("draggable", true);
+        boolean touchable = intent.getBooleanExtra("touchable", true);
+        String gravity = intent.getStringExtra("gravity");
+
+        if (componentName == null) componentName = "Overlay";
+        if (gravity == null) gravity = "bottom";
+
+        showOverlay(componentName, width, height, x, y, gravity, focusable, draggable, touchable);
+      }
+    }
+    return START_STICKY;
+  }
+
+  private void cleanUpInstance(OverlayInstance inst) {
+    if (inst.getOverlayView() != null && windowManager != null) {
+      try {
+        inst.getOverlayView().removeAllViews();
+        windowManager.removeView(inst.getOverlayView());
+      } catch (Exception e) {
+        Log.e(TAG, "Error removing view", e);
+      }
+    }
+    if (inst.getReactSurface() != null) {
+      inst.getReactSurface().stop();
+    }
+  }
+
+  @Override
+  public void onDestroy() {
+    Log.d(TAG, "Service onDestroy");
+    isDestroyed = true;
+    instance = null;
+
+    if (lifecycleCallbacks != null) {
+      getApplication().unregisterActivityLifecycleCallbacks(lifecycleCallbacks);
+      lifecycleCallbacks = null;
+    }
+
+    ReactHost reactHost = getReactHost();
+
+    if (reactHost != null && !isAppInForeground()) {
+      reactHost.onHostPause();
+    }
+
+    stopForeground(STOP_FOREGROUND_REMOVE);
+
+    if (windowManager != null) {
+      for (OverlayInstance inst : overlays.values()) {
+        cleanUpInstance(inst);
+      }
+    }
+    overlays.clear();
+    windowManager = null;
+    super.onDestroy();
+  }
+
+  private void createNotificationChannel(String channelId, String channelName) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      NotificationChannel serviceChannel =
+          new NotificationChannel(channelId, channelName, NotificationManager.IMPORTANCE_MIN);
+      serviceChannel.setShowBadge(false);
+
+      NotificationManager manager = getSystemService(NotificationManager.class);
+      if (manager != null) {
+        manager.createNotificationChannel(serviceChannel);
+      }
+    }
+  }
+
+  private OverlayInstance getOverlayInstance(String componentName) {
+    if (windowManager == null || componentName == null) return null;
+    OverlayInstance inst = overlays.get(componentName);
+    if (inst == null || inst.getOverlayView() == null) return null;
+    return inst;
+  }
+
+  private Notification createForegroundNotification(Intent intent) {
+    String title = intent.getStringExtra("notificationTitle");
+    String text = intent.getStringExtra("notificationText");
+    String iconName = intent.getStringExtra("notificationIcon");
+    String channelId = intent.getStringExtra("channelId");
+    String channelName = intent.getStringExtra("channelName");
+
+    if (channelId == null) channelId = DEFAULT_CHANNEL_ID;
+    if (channelName == null) channelName = "Overlay Service";
+
+    createNotificationChannel(channelId, channelName);
+
+    int smallIcon = android.R.drawable.ic_media_play;
+    if (iconName != null) {
+      int resId = getResources().getIdentifier(iconName, "drawable", getPackageName());
+      if (resId == 0) {
+        resId = getResources().getIdentifier(iconName, "mipmap", getPackageName());
+      }
+      if (resId != 0) {
+        smallIcon = resId;
+      }
+    }
+
+    return new NotificationCompat.Builder(this, channelId)
+        .setContentTitle(title != null ? title : "Overlay running")
+        .setContentText(text != null ? text : "View is running in the background")
+        .setSmallIcon(smallIcon)
+        .setPriority(NotificationCompat.PRIORITY_MIN)
+        .setOngoing(true)
+        .build();
+  }
+
+  @Override
+  public void onTaskRemoved(Intent rootIntent) {
+    Intent stopIntent = new Intent(this, OverlayService.class);
+
+    stopIntent.setAction(STOP_SERVICE_ACTION_NAME);
+
+    this.startService(stopIntent);
+    super.onTaskRemoved(rootIntent);
+  }
+}

package/android/src/main/java/tech/zmario/androidoverlay/view/OverlayContainerView.java

@@ -0,0 +1,137 @@
+package tech.zmario.androidoverlay.view;
+
+import android.content.Context;
+import android.util.DisplayMetrics;
+import android.view.Gravity;
+import android.view.MotionEvent;
+import android.view.ViewConfiguration;
+import android.view.WindowManager;
+import android.widget.FrameLayout;
+
+public class OverlayContainerView extends FrameLayout {
+
+  private final WindowManager windowManager;
+  private final boolean draggable;
+  private final int touchSlop;
+
+  private boolean isDragging = false;
+
+  private int initialX = 0;
+  private int initialY = 0;
+  private float initialTouchX = 0f;
+  private float initialTouchY = 0f;
+
+  public OverlayContainerView(Context context, WindowManager windowManager, boolean draggable) {
+    super(context);
+    this.windowManager = windowManager;
+    this.draggable = draggable;
+
+    ViewConfiguration vc = ViewConfiguration.get(context);
+    this.touchSlop = vc.getScaledTouchSlop();
+  }
+
+  @Override
+  public boolean onInterceptTouchEvent(MotionEvent ev) {
+    if (!draggable) return super.onInterceptTouchEvent(ev);
+
+    switch (ev.getActionMasked()) {
+      case MotionEvent.ACTION_DOWN:
+        isDragging = false;
+        initialTouchX = ev.getRawX();
+        initialTouchY = ev.getRawY();
+
+        WindowManager.LayoutParams params = (WindowManager.LayoutParams) getLayoutParams();
+        if (params != null) {
+          initialX = params.x;
+          initialY = params.y;
+        }
+        break;
+
+      case MotionEvent.ACTION_MOVE:
+        float dx = Math.abs(ev.getRawX() - initialTouchX);
+        float dy = Math.abs(ev.getRawY() - initialTouchY);
+
+        if (dx > touchSlop || dy > touchSlop) {
+          isDragging = true;
+          return true;
+        }
+        break;
+
+      case MotionEvent.ACTION_UP:
+      case MotionEvent.ACTION_CANCEL:
+        isDragging = false;
+        break;
+    }
+    return super.onInterceptTouchEvent(ev);
+  }
+
+  @Override
+  public boolean onTouchEvent(MotionEvent event) {
+    if (!draggable) {
+      return super.onTouchEvent(event);
+    }
+
+    switch (event.getActionMasked()) {
+      case MotionEvent.ACTION_MOVE:
+        if (!isDragging) {
+          float dxCheck = Math.abs(event.getRawX() - initialTouchX);
+          float dyCheck = Math.abs(event.getRawY() - initialTouchY);
+
+          if (dxCheck > touchSlop || dyCheck > touchSlop) {
+            isDragging = true;
+          }
+        }
+
+        if (isDragging) {
+          WindowManager.LayoutParams params = (WindowManager.LayoutParams) getLayoutParams();
+
+          if (params == null) {
+            return true;
+          }
+
+          int totalDx = (int) (event.getRawX() - initialTouchX);
+          int totalDy = (int) (event.getRawY() - initialTouchY);
+
+          int targetX = initialX + totalDx;
+          int targetY;
+
+          if ((params.gravity & Gravity.BOTTOM) == Gravity.BOTTOM) {
+            targetY = initialY - totalDy;
+          } else {
+            targetY = initialY + totalDy;
+          }
+
+          DisplayMetrics metrics = getResources().getDisplayMetrics();
+
+          int viewWidth = (params.width > 0) ? params.width : getWidth();
+          int viewHeight = (params.height > 0) ? params.height : getHeight();
+
+          int maxDragX = (metrics.widthPixels - viewWidth) / 2;
+          int maxDragY = metrics.heightPixels - viewHeight;
+
+          if (targetX < -maxDragX) targetX = -maxDragX;
+          if (targetX > maxDragX) targetX = maxDragX;
+          if (targetY < 0) targetY = 0;
+          if (targetY > maxDragY) targetY = maxDragY;
+
+          params.x = targetX;
+          params.y = targetY;
+
+          if (windowManager != null) {
+            try {
+              windowManager.updateViewLayout(this, params);
+            } catch (IllegalArgumentException ignored) {
+            }
+          }
+        }
+        break;
+
+      case MotionEvent.ACTION_UP:
+      case MotionEvent.ACTION_CANCEL:
+        isDragging = false;
+        break;
+    }
+
+    return true;
+  }
+}

package/lib/module/NativeAndroidOverlay.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('AndroidOverlay');
+//# sourceMappingURL=NativeAndroidOverlay.js.map

package/lib/module/NativeAndroidOverlay.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"..\\..\\src","sources":["NativeAndroidOverlay.ts"],"mappings":";;AAAA,SAA2BA,mBAAmB,QAAQ,cAAc;AA0CpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,gBAAgB,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,30 @@
+"use strict";
+
+import AndroidOverlay from "./NativeAndroidOverlay.js";
+export const OverlayManager = {
+  startOverlay(componentName, options = {}) {
+    AndroidOverlay.startOverlay(componentName, options);
+  },
+  hasPermission() {
+    return AndroidOverlay.hasPermission();
+  },
+  requestPermission() {
+    AndroidOverlay.requestPermission();
+  },
+  stopOverlay(componentName = 'Overlay') {
+    AndroidOverlay.stopOverlay(componentName);
+  },
+  resizeOverlay(width, height, componentName = 'Overlay') {
+    AndroidOverlay.resizeOverlay(width, height, componentName);
+  },
+  startMove(componentName = 'Overlay') {
+    AndroidOverlay.startMove(componentName);
+  },
+  moveOverlay(dx, dy, componentName = 'Overlay') {
+    AndroidOverlay.moveOverlay(dx, dy, componentName);
+  },
+  commitMove(componentName = 'Overlay') {
+    AndroidOverlay.commitMove(componentName);
+  }
+};
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AndroidOverlay","OverlayManager","startOverlay","componentName","options","hasPermission","requestPermission","stopOverlay","resizeOverlay","width","height","startMove","moveOverlay","dx","dy","commitMove"],"sourceRoot":"..\\..\\src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,cAAc,MAAM,2BAAwB;AAwBnD,OAAO,MAAMC,cAAc,GAAG;EAC5BC,YAAYA,CAACC,aAAqB,EAAEC,OAAuB,GAAG,CAAC,CAAC,EAAE;IAChEJ,cAAc,CAACE,YAAY,CAACC,aAAa,EAAEC,OAAO,CAAC;EACrD,CAAC;EAEDC,aAAaA,CAAA,EAAG;IACd,OAAOL,cAAc,CAACK,aAAa,CAAC,CAAC;EACvC,CAAC;EAEDC,iBAAiBA,CAAA,EAAG;IAClBN,cAAc,CAACM,iBAAiB,CAAC,CAAC;EACpC,CAAC;EAEDC,WAAWA,CAACJ,aAAa,GAAG,SAAS,EAAE;IACrCH,cAAc,CAACO,WAAW,CAACJ,aAAa,CAAC;EAC3C,CAAC;EAEDK,aAAaA,CAACC,KAAa,EAAEC,MAAc,EAAEP,aAAa,GAAG,SAAS,EAAE;IACtEH,cAAc,CAACQ,aAAa,CAACC,KAAK,EAAEC,MAAM,EAAEP,aAAa,CAAC;EAC5D,CAAC;EAEDQ,SAASA,CAACR,aAAa,GAAG,SAAS,EAAE;IACnCH,cAAc,CAACW,SAAS,CAACR,aAAa,CAAC;EACzC,CAAC;EAEDS,WAAWA,CAACC,EAAU,EAAEC,EAAU,EAAEX,aAAa,GAAG,SAAS,EAAE;IAC7DH,cAAc,CAACY,WAAW,CAACC,EAAE,EAAEC,EAAE,EAAEX,aAAa,CAAC;EACnD,CAAC;EAEDY,UAAUA,CAACZ,aAAa,GAAG,SAAS,EAAE;IACpCH,cAAc,CAACe,UAAU,CAACZ,aAAa,CAAC;EAC1C;AACF,CAAC","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/NativeAndroidOverlay.d.ts

@@ -0,0 +1,29 @@
+import { type TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    hasPermission(): Promise<boolean>;
+    requestPermission(): void;
+    startOverlay(componentName: string, options?: {
+        width?: number;
+        height?: number;
+        x?: number;
+        y?: number;
+        gravity?: string;
+        draggable?: boolean;
+        touchable?: boolean;
+        focusable?: boolean;
+        foreground?: boolean;
+        notificationTitle?: string;
+        notificationText?: string;
+        notificationIcon?: string;
+        channelId?: string;
+        channelName?: string;
+    }): void;
+    stopOverlay(componentName: string): void;
+    resizeOverlay(width: number, height: number, componentName: string): void;
+    startMove(componentName: string): void;
+    moveOverlay(dx: number, dy: number, componentName: string): void;
+    commitMove(componentName: string): void;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeAndroidOverlay.d.ts.map

package/lib/typescript/src/NativeAndroidOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAndroidOverlay.d.ts","sourceRoot":"","sources":["../../../src/NativeAndroidOverlay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,cAAc,CAAC;AAErE,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAElC,iBAAiB,IAAI,IAAI,CAAC;IAE1B,YAAY,CACV,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,CAAC,CAAC,EAAE,MAAM,CAAC;QACX,CAAC,CAAC,EAAE,MAAM,CAAC;QACX,OAAO,CAAC,EAAE,MAAM,CAAC;QAEjB,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,OAAO,CAAC;QAEpB,UAAU,CAAC,EAAE,OAAO,CAAC;QAErB,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAE1B,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,GACA,IAAI,CAAC;IAER,WAAW,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzC,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1E,SAAS,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvC,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAEjE,UAAU,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CACzC;;AAED,wBAAwE"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,27 @@
+export interface OverlayOptions {
+    width?: number;
+    height?: number;
+    x?: number;
+    y?: number;
+    gravity?: string;
+    draggable?: boolean;
+    touchable?: boolean;
+    focusable?: boolean;
+    foreground?: boolean;
+    notificationTitle?: string;
+    notificationText?: string;
+    notificationIcon?: string;
+    channelId?: string;
+    channelName?: string;
+}
+export declare const OverlayManager: {
+    startOverlay(componentName: string, options?: OverlayOptions): void;
+    hasPermission(): Promise<boolean>;
+    requestPermission(): void;
+    stopOverlay(componentName?: string): void;
+    resizeOverlay(width: number, height: number, componentName?: string): void;
+    startMove(componentName?: string): void;
+    moveOverlay(dx: number, dy: number, componentName?: string): void;
+    commitMove(componentName?: string): void;
+};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IAEX,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,cAAc;gCACG,MAAM,YAAW,cAAc;;;;yBAgBtC,MAAM,UAAU,MAAM;;oBAQ3B,MAAM,MAAM,MAAM;;CAOnC,CAAC"}