@byteplus/react-native-live-pull 1.0.3-rc.1 → 1.1.1-rc.1

package/android/src/main/AndroidManifest.xml

@@ -6,4 +6,10 @@
   <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
   <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
 
-</manifest>
+  <application>
+    <activity
+      android:name="com.volcengine.velive.rn.pull.pictureInpicture.AssistantActivity"
+      android:exported="true"
+      android:theme="@style/AppTheme.NoActionBar" />
+  </application>
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -4,5 +4,19 @@
   <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
   <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
   <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
 
-</manifest>
+  <application>
+    <activity
+      android:name="com.volcengine.velive.rn.pull.pictureInpicture.FloatingWindowHelper$AssistantActivity"
+      android:exported="true"
+    />
+
+    <service
+      android:name="com.volcengine.velive.rn.pull.pictureInpicture.FloatingWindowService"
+      android:enabled="true"
+      android:exported="false"
+      android:foregroundServiceType="mediaProjection" />
+  </application>
+
+</manifest>

package/android/src/main/java/com/volcengine/velive/rn/pull/VolcLiveModule.java

@@ -1,7 +1,6 @@
 package com.volcengine.velive.rn.pull;
 
 import androidx.annotation.Nullable;
-
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -11,21 +10,21 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
-
 import com.volcengine.VolcApiEngine.*;
 import com.volcengine.velive.rn.pull.autogen.MethodSignature;
 
 @ReactModule(name = VolcLiveModule.NAME)
-public class VolcLiveModule extends VolcLiveModuleSpec implements IEventReceiver {
+public class VolcLiveModule
+    extends VolcLiveModuleSpec implements IEventReceiver {
   public static final String NAME = "VolcLiveModule";
-  
+
   VolcApiEngine apiEngine = null;
-  
+
   VolcLiveModule(ReactApplicationContext context) {
     super(context);
     MethodSignature.init();
   }
-  
+
   @Override
   public String getName() {
     return NAME;
@@ -38,12 +37,12 @@ public class VolcLiveModule extends VolcLiveModuleSpec implements IEventReceiver
       NativeVariableManager.init(apiEngine.msgClient, super.context);
       return true;
     }
-    
+
     return false;
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
-  public String callApiSync(ReadableMap arg)  {
+  public String callApiSync(ReadableMap arg) {
     try {
       newApiEngine();
       String params = arg.getString("params");
@@ -55,16 +54,26 @@ public class VolcLiveModule extends VolcLiveModuleSpec implements IEventReceiver
   }
 
   @ReactMethod(isBlockingSynchronousMethod = false)
-  public void callApi(ReadableMap arg, Callback callback)  {
+  public void callApi(ReadableMap arg, Callback callback) {
     try {
       newApiEngine();
       String params = arg.getString("params");
-      this.apiEngine.callApi(params, (res) -> {
-        callback.invoke(res.toJsonString());
-      }); 
+
+      // 获取主线程处理器
+      android.os.Handler mainHandler =
+          new android.os.Handler(android.os.Looper.getMainLooper());
+
+      // 在主线程上执行 API 调用
+      mainHandler.post(() -> {
+        try {
+          this.apiEngine.callApi(
+              params, (res) -> { callback.invoke(res.toJsonString()); });
+        } catch (Exception e) {
+          e.printStackTrace();
+        }
+      });
     } catch (Exception e) {
       e.printStackTrace();
-      throw new RuntimeException(e);
     }
   }
 
@@ -87,12 +96,11 @@ public class VolcLiveModule extends VolcLiveModuleSpec implements IEventReceiver
     }
   }
 
-  private void sendEvent(ReactContext reactContext,
-                          String eventName,
-                          @Nullable WritableMap params) {
+  private void sendEvent(ReactContext reactContext, String eventName,
+                         @Nullable WritableMap params) {
     reactContext
-      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-      .emit(eventName, params);
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+        .emit(eventName, params);
   }
 
   @Override
@@ -102,7 +110,7 @@ public class VolcLiveModule extends VolcLiveModuleSpec implements IEventReceiver
     map.putString("data", data);
 
     super.context
-      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-      .emit(VolcLiveModuleSpec.EVENT, map);
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+        .emit(VolcLiveModuleSpec.EVENT, map);
   }
 }

package/android/src/main/java/com/volcengine/velive/rn/pull/VolcView.java

@@ -2,7 +2,6 @@ package com.volcengine.velive.rn.pull;
 
 import android.content.Context;
 import android.widget.FrameLayout;
-
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.WritableMap;
@@ -11,13 +10,14 @@ import com.facebook.react.uimanager.events.RCTEventEmitter;
 public class VolcView extends FrameLayout {
   public String viewId;
   public boolean hasRegister = false;
-  
-  public VolcView(Context context) {
+
+  public VolcView(Context context) { 
     super(context);
+    this.setKeepScreenOn(true); 
   }
-  
+
   public void setViewId(String viewId) {
-    this.viewId = viewId;  
+    this.viewId = viewId;
     this.hasRegister = true;
     this.emitOnLoad();
   }
@@ -25,8 +25,7 @@ public class VolcView extends FrameLayout {
   public void emitOnLoad() {
     WritableMap event = Arguments.createMap();
     ReactContext reactContext = (ReactContext)getContext();
-    reactContext
-      .getJSModule(RCTEventEmitter.class)
-      .receiveEvent(getId(), "load", event);
+    reactContext.getJSModule(RCTEventEmitter.class)
+        .receiveEvent(getId(), "load", event);
   }
 }

package/android/src/main/java/com/volcengine/velive/rn/pull/pictureInpicture/FloatingWindowHelper.java

@@ -0,0 +1,224 @@
+package com.volcengine.velive.rn.pull.pictureInpicture;
+
+import static com.volcengine.velive.rn.pull.pictureInpicture.FloatingWindowService.INTENT_EXTRA_KEY_ASPECT_RATIO;
+import static com.volcengine.velive.rn.pull.pictureInpicture.FloatingWindowService.INTENT_EXTRA_KEY_X_POS;
+import static com.volcengine.velive.rn.pull.pictureInpicture.FloatingWindowService.INTENT_EXTRA_KEY_Y_POS;
+import static com.volcengine.velive.rn.pull.pictureInpicture.IFloatingWindowHelper.Listener.ERR_INVALID_PARAMS;
+import static com.volcengine.velive.rn.pull.pictureInpicture.IFloatingWindowHelper.Listener.ERR_IS_ALREADY_OPEN;
+import static com.volcengine.velive.rn.pull.pictureInpicture.IFloatingWindowHelper.Listener.ERR_NO;
+import static com.volcengine.velive.rn.pull.pictureInpicture.IFloatingWindowHelper.Listener.ERR_NOT_SUPPORT;
+import static com.volcengine.velive.rn.pull.pictureInpicture.IFloatingWindowHelper.Listener.ERR_RETRY;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.provider.Settings;
+import android.view.SurfaceView;
+import androidx.annotation.Nullable;
+import java.util.HashMap;
+import java.util.Map;
+
+public class FloatingWindowHelper implements IFloatingWindowHelper {
+  private static FloatingWindowHelper mInstance = null;
+  private Listener mListener;
+  private Config mConfig;
+  private Map<String, Object> mExtraDataMap;
+  private boolean isRunning;
+
+  public synchronized static FloatingWindowHelper getInstance() {
+    if (mInstance == null) {
+      mInstance = new FloatingWindowHelper();
+    }
+    return mInstance;
+  }
+
+  public static boolean isPictureInPictureSupported() {
+    // Check if the system version supports floating windows
+    if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.M) {
+      // Android versions below 6.0 don't support SYSTEM_ALERT_WINDOW permission
+      // management
+      return false;
+    }
+    // The system supports PIP mode
+    return true;
+  }
+
+  @Override
+  public void setEventListener(Listener listener) {
+    mListener = listener;
+  }
+
+  public Listener getEventListener() { return mListener; }
+
+  public void openFloatingWindow(Context context, Config config,
+                                 Map<String, Object> extraData) {
+    if (isRunning) {
+      if (mListener != null) {
+        mListener.onOpenFloatingWindowResult(ERR_IS_ALREADY_OPEN, extraData);
+      }
+      return;
+    }
+    // Invalid parameters
+    if (context == null || config.aspectRatio <= 0) {
+      if (mListener != null) {
+        mListener.onOpenFloatingWindowResult(ERR_INVALID_PARAMS, extraData);
+      }
+      return;
+    }
+
+    // Android versions below 6.0 don't support Overlay functionality
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+      if (mListener != null) {
+        mListener.onOpenFloatingWindowResult(ERR_NOT_SUPPORT, extraData);
+      }
+      return;
+    }
+
+    // Save configuration first, so it can be used in permission request
+    // callback
+    mConfig = config;
+    mExtraDataMap = extraData;
+
+    // If Overlay permission is not enabled, request it first
+    if (!Settings.canDrawOverlays(context)) {
+      if (mListener != null && mListener.onRequestOverlayPermission()) {
+        requestOverlayPermission(context);
+      } else {
+        // User doesn't allow permission request, trigger error callback
+        if (mListener != null) {
+          mListener.onOpenFloatingWindowResult(ERR_INVALID_PARAMS, extraData);
+        }
+      }
+      return;
+    }
+
+    Intent intent = new Intent(context, FloatingWindowService.class);
+    intent.putExtra(INTENT_EXTRA_KEY_ASPECT_RATIO, mConfig.aspectRatio);
+    intent.putExtra(INTENT_EXTRA_KEY_X_POS, mConfig.x);
+    intent.putExtra(INTENT_EXTRA_KEY_Y_POS, mConfig.y);
+    context.startService(intent);
+    isRunning = true;
+  }
+
+  @Override
+  public void closeFloatingWindow(Context context) {
+    if (!isRunning) {
+      return;
+    }
+    context.stopService(new Intent(context, FloatingWindowService.class));
+    isRunning = false;
+  }
+
+  @Override
+  public void requestOverlayPermission(Context context) {
+    try {
+      Intent intent = new Intent(context, AssistantActivity.class);
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+      context.startActivity(intent);
+    } catch (Exception e) {
+      // If starting AssistantActivity fails, trigger error callback
+      if (mListener != null) {
+        Map<String, Object> errorData = new HashMap<>();
+        errorData.put("error", e.getMessage());
+        mListener.onOpenFloatingWindowResult(ERR_NOT_SUPPORT, errorData);
+      }
+    }
+  }
+
+  @Override
+  public Config getConfig() {
+    return mConfig;
+  }
+
+  @Override
+  public Map<String, Object> getExtraData() {
+    return mExtraDataMap;
+  }
+
+  @Override
+  public boolean isOpen() {
+    return isRunning;
+  }
+
+  void setSurfaceView(SurfaceView surfaceView) {
+    if (mListener != null) {
+      mListener.onUpdateSurfaceView(surfaceView);
+    }
+  }
+
+  void performClose(Context context) {
+    if (mListener != null) {
+      mListener.onClickFloatingWindowCloseBtn(context);
+    }
+  }
+
+  void onClickFloatingWindow(Context context) {
+    if (mListener != null) {
+      mListener.onClickFloatingWindow(context);
+    }
+  }
+
+  void onStartService() {
+    if (mListener != null) {
+      mListener.onOpenFloatingWindowResult(ERR_NO, mExtraDataMap);
+    }
+  }
+
+  void onStopService() {
+    if (mListener != null) {
+      mListener.onCloseFloatingWindow(mExtraDataMap);
+    }
+
+    mConfig = null;
+    mExtraDataMap = null;
+  }
+
+  public static class AssistantActivity extends Activity {
+    private Listener mListener;
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+      super.onCreate(savedInstanceState);
+      mListener = FloatingWindowHelper.getInstance().getEventListener();
+
+      int sdkInt = Build.VERSION.SDK_INT;
+      int mOverlayRequestCode = 1001;
+      if (sdkInt >= Build.VERSION_CODES.O) { // Android 8.0 and above
+        Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
+        startActivityForResult(intent, mOverlayRequestCode);
+      } else if (sdkInt >= Build.VERSION_CODES.M) {
+        Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
+        intent.setData(Uri.parse("package:" + getPackageName()));
+        startActivityForResult(intent, mOverlayRequestCode);
+      }
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode,
+                                    @Nullable Intent data) {
+      super.onActivityResult(requestCode, resultCode, data);
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        if (!Settings.canDrawOverlays(this)) {
+          // User denied permission request, return permission error
+          if (mListener != null) {
+            mListener.onOpenFloatingWindowResult(ERR_INVALID_PARAMS, null);
+          }
+        } else {
+          // User granted permission
+          if (mListener != null) {
+            // Return success directly, let the caller retry
+            // startPictureInPicture
+            mListener.onOpenFloatingWindowResult(ERR_RETRY, null);
+          }
+        }
+      }
+
+      // Finish activity regardless of the result
+      finish();
+    }
+  }
+}

package/android/src/main/java/com/volcengine/velive/rn/pull/pictureInpicture/FloatingWindowService.java

@@ -0,0 +1,198 @@
+package com.volcengine.velive.rn.pull.pictureInpicture;
+
+import android.app.Service;
+import android.content.Intent;
+import android.graphics.PixelFormat;
+import android.os.Build;
+import android.os.IBinder;
+import android.provider.Settings;
+import android.util.DisplayMetrics; // Import DisplayMetrics
+import android.util.Log;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.SurfaceView;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.WindowManager;
+import androidx.annotation.Nullable;
+import com.volcengine.velive.rn.pull.R;
+
+public class FloatingWindowService extends Service {
+  private static final String TAG = FloatingWindowService.class.getSimpleName();
+  private static final int LONGER_SIDE_MAX_LEN = 1000;
+
+  private WindowManager mWindowManager;
+  private WindowManager.LayoutParams mLayoutParams;
+  private SurfaceView mSurfaceView;
+  private View mSmallWindowView;
+
+  public static final String INTENT_EXTRA_KEY_ASPECT_RATIO = "aspect_ratio";
+  public static final String INTENT_EXTRA_KEY_X_POS = "x_pos";
+  public static final String INTENT_EXTRA_KEY_Y_POS = "y_pos";
+
+  @Override
+  public void onCreate() {
+    Log.d(TAG, "onCreate");
+    super.onCreate();
+    FloatingWindowHelper.getInstance().onStartService();
+  }
+
+  @Override
+  public int onStartCommand(Intent intent, int flags, int startId) {
+    Log.d(TAG, "onStartCommand");
+    initUI(intent.getFloatExtra(INTENT_EXTRA_KEY_ASPECT_RATIO, 16f / 9f),
+           intent.getIntExtra(INTENT_EXTRA_KEY_X_POS, 300),
+           intent.getIntExtra(INTENT_EXTRA_KEY_Y_POS, 300));
+    FloatingWindowHelper.getInstance().setSurfaceView(mSurfaceView);
+    return super.onStartCommand(intent, flags, startId);
+  }
+
+  @Override
+  public void onDestroy() {
+    Log.d(TAG, "onDestroy");
+    super.onDestroy();
+    if (mSmallWindowView != null) {
+      mWindowManager.removeView(mSmallWindowView);
+    }
+    FloatingWindowHelper.getInstance().onStopService();
+  }
+
+  @Nullable
+  @Override
+  public IBinder onBind(Intent intent) {
+    return null;
+  }
+
+  private void initUI(float aspectRatio, int x, int y) {
+    mWindowManager = (WindowManager)getSystemService(WINDOW_SERVICE);
+    mLayoutParams = new WindowManager.LayoutParams();
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      mLayoutParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
+    } else {
+      mLayoutParams.type = WindowManager.LayoutParams.TYPE_PHONE;
+    }
+    mLayoutParams.format = PixelFormat.RGBA_8888;
+    mLayoutParams.gravity = Gravity.START | Gravity.TOP;
+    mLayoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL |
+                          WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
+
+    // Get screen dimensions
+    DisplayMetrics displayMetrics = new DisplayMetrics();
+    mWindowManager.getDefaultDisplay().getMetrics(displayMetrics);
+    int screenWidth = displayMetrics.widthPixels;
+    int screenHeight = displayMetrics.heightPixels;
+
+    // Calculate the minimum screen dimension
+    int minScreenDim = Math.min(screenWidth, screenHeight);
+
+    // Determine the maximum length based on the smaller of 1000 and
+    // minScreenDim
+    int maxLen = Math.min(LONGER_SIDE_MAX_LEN, minScreenDim);
+
+    // Limit the floating window size to prevent it from being too large or too
+    // small, control the longer side to maxLen, scale the shorter
+    // side proportionally
+    int width, height;
+    if (aspectRatio >= 1) {
+      height = (int)(maxLen / aspectRatio);
+      width = maxLen;
+    } else {
+      width = (int)(maxLen * aspectRatio);
+      height = maxLen;
+    }
+    mLayoutParams.width = width;
+    mLayoutParams.height = height;
+
+    // Initial position of the floating window
+    mLayoutParams.x = x;
+    mLayoutParams.y = y;
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      if (Settings.canDrawOverlays(this)) {
+        LayoutInflater layoutInflater = LayoutInflater.from(this);
+        mSmallWindowView =
+            layoutInflater.inflate(R.layout.floating_window_layout, null);
+        mSmallWindowView.setOnTouchListener(new FloatingOnTouchListener());
+        mWindowManager.addView(mSmallWindowView, mLayoutParams);
+        mSurfaceView = mSmallWindowView.findViewById(R.id.surface_view);
+        mSmallWindowView.findViewById(R.id.surface_close_btn)
+            .setOnClickListener(v -> { stopSelf(); });
+
+        mSmallWindowView.findViewById(R.id.new_window_btn)
+            .setOnClickListener(v -> {
+              Log.d(TAG, "PIP window clicked");
+              
+              try {
+                // Get the pacain activity
+                String packageName = this.getPackageName();
+                Intent launchIntent =
+                    this.getPackageManager().getLaunchIntentForPackage(
+                        packageName);
+
+                if (launchIntent != null) {
+                  Log.d(TAG, "Launching app with intent: " + launchIntent);
+                  launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                  this.startActivity(launchIntent);
+                } else {
+                  Log.e(TAG, "Could not create launch intent for package: " +
+                                 packageName);
+                }
+              } catch (Exception e) {
+                Log.e(TAG, "Error launching app: " + e.getMessage(), e);
+              }
+
+              stopSelf();
+            });
+      }
+    }
+  }
+
+  private class FloatingOnTouchListener implements View.OnTouchListener {
+    private final int touchSlop =
+        ViewConfiguration
+            .get(FloatingWindowService.this.getApplicationContext())
+            .getScaledTouchSlop();
+    private int downX, downY;
+    private int x, y;
+    private boolean isDragging;
+
+    @Override
+    public boolean onTouch(View view, MotionEvent event) {
+      switch (event.getAction()) {
+      case MotionEvent.ACTION_UP:
+        if (isDragging) {
+          isDragging = false;
+        } else {
+          FloatingWindowHelper.getInstance().onClickFloatingWindow(
+              FloatingWindowService.this);
+        }
+        downX = downY = 0;
+        break;
+      case MotionEvent.ACTION_DOWN:
+        downX = x = (int)event.getRawX();
+        downY = y = (int)event.getRawY();
+        break;
+      case MotionEvent.ACTION_MOVE:
+        int nowX = (int)event.getRawX();
+        int nowY = (int)event.getRawY();
+        if (Math.abs(nowX - downX) > touchSlop ||
+            Math.abs(nowY - downY) > touchSlop) {
+          isDragging = true;
+        }
+        int movedX = nowX - x;
+        int movedY = nowY - y;
+        x = nowX;
+        y = nowY;
+        mLayoutParams.x = mLayoutParams.x + movedX;
+        mLayoutParams.y = mLayoutParams.y + movedY;
+        mWindowManager.updateViewLayout(view, mLayoutParams);
+        break;
+
+      default:
+        break;
+      }
+      return true;
+    }
+  }
+}

package/android/src/main/java/com/volcengine/velive/rn/pull/pictureInpicture/IFloatingWindowHelper.java

@@ -0,0 +1,80 @@
+package com.volcengine.velive.rn.pull.pictureInpicture;
+
+import android.content.Context;
+import android.view.SurfaceView;
+import java.util.Map;
+
+public interface IFloatingWindowHelper {
+  // Set event listener callback
+  void setEventListener(Listener listener);
+
+  // Open floating window (will request permission if not granted),
+  // also supports caching business data for restoring the live page.
+  void openFloatingWindow(Context context, Config config,
+                          Map<String, Object> extraData);
+
+  // Close floating window
+  void closeFloatingWindow(Context context);
+
+  // Request overlay permission
+  void requestOverlayPermission(Context context);
+
+  // Get floating window configuration
+  Config getConfig();
+
+  // Get cached business data
+  Map<String, Object> getExtraData();
+
+  // Check if floating window is open
+  boolean isOpen();
+
+  interface Listener {
+    // Error codes for opening floating window callback
+    int ERR_NO = 0;
+    int ERR_NOT_SUPPORT = 1;
+    int ERR_INVALID_PARAMS = 2;
+    int ERR_IS_ALREADY_OPEN = 3;
+    int ERR_RETRY = 4;
+
+    // Triggered when requesting overlay permission
+    // return: boolean, whether to allow requesting overlay permission
+    //      - true: allow
+    //      - false: disallow
+    default boolean onRequestOverlayPermission() { return true; }
+
+    // Callback for the result of opening floating window
+    // param: errCode, ERR_NO means success, other values indicate errors
+    default void onOpenFloatingWindowResult(int errCode,
+                                            Map<String, Object> extraData) {}
+
+    // Callback when closing floating window
+    default void onCloseFloatingWindow(Map<String, Object> extraData) {}
+
+    // Callback when clicking the floating window, needs to be handled by
+    // business logic
+    default void onClickFloatingWindow(Context context) {}
+
+    // Callback when clicking the close button of floating window, needs to be
+    // handled by business logic
+    default void onClickFloatingWindowCloseBtn(Context context) {
+      FloatingWindowHelper.getInstance().closeFloatingWindow(context);
+    }
+
+    // Callback for the SurfaceView of floating window, needs to be set to SDK
+    // to render video
+    void onUpdateSurfaceView(SurfaceView surfaceView);
+  }
+
+  class Config {
+    public float aspectRatio;
+    int x, y; // Position for creating the floating window
+
+    public Config(float aspectRatio) { this(aspectRatio, 0, 0); }
+
+    public Config(float aspectRatio, int x, int y) {
+      this.aspectRatio = aspectRatio;
+      this.x = x;
+      this.y = y;
+    }
+  }
+}