Camera WIP hardcode to make it work

Add an option to list the device cameras.

Co-authored-by: Romain Vimont <rom@rom1v.com>

README.md

@@ -5,7 +5,7 @@
 _pronounced "**scr**een **c**o**py**"_
 
 This application mirrors Android devices (video and audio) connected via
-USB or [over TCP/IP](doc/device.md#tcpip-wireless), and allows to control the
+USB or [over TCP/IP](doc/connection.md#tcpip-wireless), and allows to control the
 device with the keyboard and the mouse of the computer. It does not require any
 _root_ access. It works on _Linux_, _Windows_ and _macOS_.
 
@@ -68,10 +68,11 @@ mode](doc/hid-otg.md#otg).
 The application provides a lot of features and configuration options. They are
 documented in the following pages:
 
- - [Device](doc/device.md)
+ - [Connection](doc/connection.md)
  - [Video](doc/video.md)
  - [Audio](doc/audio.md)
  - [Control](doc/control.md)
+ - [Device](doc/device.md)
  - [Window](doc/window.md)
  - [Recording](doc/recording.md)
  - [Tunnels](doc/tunnels.md)

app/data/bash-completion/scrcpy

@@ -23,6 +23,7 @@ _scrcpy() {
         --kill-adb-on-close
         -K --hid-keyboard
         --legacy-paste
+        --list-cameras
         --list-displays
         --list-encoders
         --lock-video-orientation

app/data/zsh-completion/_scrcpy

@@ -30,6 +30,7 @@ arguments=(
     '--kill-adb-on-close[Kill adb when scrcpy terminates]'
     {-K,--hid-keyboard}'[Simulate a physical keyboard by using HID over AOAv2]'
     '--legacy-paste[Inject computer clipboard text as a sequence of key events on Ctrl+v]'
+    '--list-cameras[List cameras available on the device]'
     '--list-displays[List displays available on the device]'
     '--list-encoders[List video and audio encoders available on the device]'
     '--lock-video-orientation=[Lock video orientation]:orientation:(unlocked initial 0 1 2 3)'

app/scrcpy.1

@@ -155,6 +155,9 @@ Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+S
 
 This is a workaround for some devices not behaving as expected when setting the device clipboard programmatically.
 
+.B \-\-list\-cameras
+List cameras available on the device.
+
 .TP
 .B \-\-list\-encoders
 List video and audio encoders available on the device.

app/src/cli.c

@@ -79,6 +79,7 @@ enum {
     OPT_AUDIO_SOURCE,
     OPT_KILL_ADB_ON_CLOSE,
     OPT_TIME_LIMIT,
+    OPT_LIST_CAMERAS,
 };
 
 struct sc_option {
@@ -312,6 +313,11 @@ static const struct sc_option options[] = {
                 "This is a workaround for some devices not behaving as "
                 "expected when setting the device clipboard programmatically.",
     },
+    {
+        .longopt_id = OPT_LIST_CAMERAS,
+        .longopt = "list-cameras",
+        .text = "List device cameras.",
+    },
     {
         .longopt_id = OPT_LIST_DISPLAYS,
         .longopt = "list-displays",
@@ -1944,6 +1950,9 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
                      "platform).");
                 return false;
 #endif
+            case OPT_LIST_CAMERAS:
+                opts->list_cameras = true;
+                break;
             case OPT_LIST_ENCODERS:
                 opts->list_encoders = true;
                 break;
@@ -2022,12 +2031,6 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
         opts->audio_playback = false;
     }
 
-    if (!opts->video_playback && !otg) {
-        // If video playback is disabled and OTG are disabled, then there is
-        // no way to control the device.
-        opts->control = false;
-    }
-
     if (opts->video && !opts->video_playback && !opts->record_filename
             && !v4l2) {
         LOGI("No video playback, no recording, no V4L2 sink: video disabled");

app/src/display.c

@@ -53,7 +53,7 @@ sc_display_init(struct sc_display *display, SDL_Window *window, bool mipmaps) {
                 display->mipmaps = true;
             } else {
                 LOGW("Trilinear filtering disabled "
-                     "(OpenGL 3.0+ or ES 2.0+ required");
+                     "(OpenGL 3.0+ or ES 2.0+ required)");
             }
         } else {
             LOGI("Trilinear filtering disabled");

app/src/options.c

@@ -81,5 +81,6 @@ const struct scrcpy_options scrcpy_options_default = {
     .require_audio = false,
     .list_encoders = false,
     .list_displays = false,
+    .list_cameras = false,
     .kill_adb_on_close = false,
 };

app/src/options.h

@@ -181,6 +181,7 @@ struct scrcpy_options {
     bool require_audio;
     bool list_encoders;
     bool list_displays;
+    bool list_cameras;
     bool kill_adb_on_close;
 };
 

app/src/scrcpy.c

@@ -252,7 +252,9 @@ sc_audio_demuxer_on_ended(struct sc_demuxer *demuxer,
 
     // Contrary to the video demuxer, keep mirroring if only the audio fails
     // (unless --require-audio is set).
-    if (status == SC_DEMUXER_STATUS_ERROR
+    if (status == SC_DEMUXER_STATUS_EOS) {
+        PUSH_EVENT(SC_EVENT_DEVICE_DISCONNECTED);
+    } else if (status == SC_DEMUXER_STATUS_ERROR
             || (status == SC_DEMUXER_STATUS_DISABLED
                 && options->require_audio)) {
         PUSH_EVENT(SC_EVENT_DEMUXER_ERROR);
@@ -379,6 +381,7 @@ scrcpy(struct scrcpy_options *options) {
         .power_on = options->power_on,
         .list_encoders = options->list_encoders,
         .list_displays = options->list_displays,
+        .list_cameras = options->list_cameras,
         .kill_adb_on_close = options->kill_adb_on_close,
     };
 
@@ -397,7 +400,8 @@ scrcpy(struct scrcpy_options *options) {
 
     server_started = true;
 
-    if (options->list_encoders || options->list_displays) {
+    if (options->list_encoders || options->list_displays
+            || options->list_cameras) {
         bool ok = await_for_server(NULL);
         ret = ok ? SCRCPY_EXIT_SUCCESS : SCRCPY_EXIT_FAILURE;
         goto end;
@@ -448,9 +452,7 @@ scrcpy(struct scrcpy_options *options) {
 
     struct sc_file_pusher *fp = NULL;
 
-    // control implies video playback
-    assert(!options->control || options->video_playback);
-    if (options->control) {
+    if (options->video_playback && options->control) {
         if (!sc_file_pusher_init(&s->file_pusher, serial,
                                  options->push_target)) {
             goto end;

app/src/server.c

@@ -316,6 +316,9 @@ execute_server(struct sc_server *server,
     if (params->list_displays) {
         ADD_PARAM("list_displays=true");
     }
+    if (params->list_cameras) {
+        ADD_PARAM("list_cameras=true");
+    }
 
 #undef ADD_PARAM
 
@@ -895,7 +898,8 @@ run_server(void *data) {
 
     // If --list-* is passed, then the server just prints the requested data
     // then exits.
-    if (params->list_encoders || params->list_displays) {
+    if (params->list_encoders || params->list_displays
+            || params->list_cameras) {
         sc_pid pid = execute_server(server, params);
         if (pid == SC_PROCESS_NONE) {
             goto error_connection_failed;

app/src/server.h

@@ -58,6 +58,7 @@ struct sc_server_params {
     bool power_on;
     bool list_encoders;
     bool list_displays;
+    bool list_cameras;
     bool kill_adb_on_close;
 };
 

doc/audio.md

@@ -77,6 +77,13 @@ In particular, if you get the following error:
 
 then your device has no Opus encoder: try `scrcpy --audio-codec=aac`.
 
+For advanced usage, to pass arbitrary parameters to the [`MediaFormat`],
+check `--audio-codec-options` in the manpage or in `scrcpy --help`.
+
+[`MediaFormat`]: https://developer.android.com/reference/android/media/MediaFormat
+
+
+## Encoder
 
 Several encoders may be available on the device. They can be listed by:
 
@@ -86,15 +93,10 @@ scrcpy --list-encoders
 
 To select a specific encoder:
 
-```
+```bash
 scrcpy --audio-codec=opus --audio-encoder='c2.android.opus.encoder'
 ```
 
-For advanced usage, to pass arbitrary parameters to the [`MediaFormat`],
-check `--audio-codec-options` in the manpage or in `scrcpy --help`.
-
-[`MediaFormat`]: https://developer.android.com/reference/android/media/MediaFormat
-
 
 ## Bit rate
 

doc/connection.md

@@ -0,0 +1,125 @@
+# Connection
+
+## Selection
+
+If exactly one device is connected (i.e. listed by `adb devices`), then it is
+automatically selected.
+
+However, if there are multiple devices connected, you must specify the one to
+use in one of 4 ways:
+ - by its serial:
+   ```bash
+   scrcpy --serial=0123456789abcdef
+   scrcpy -s 0123456789abcdef   # short version
+
+   # the serial is the ip:port if connected over TCP/IP (same behavior as adb)
+   scrcpy --serial=192.168.1.1:5555
+   ```
+ - the one connected over USB (if there is exactly one):
+   ```bash
+   scrcpy --select-usb
+   scrcpy -d   # short version
+   ```
+ - the one connected over TCP/IP (if there is exactly one):
+   ```bash
+   scrcpy --select-tcpip
+   scrcpy -e   # short version
+   ```
+ - a device already listening on TCP/IP (see [below](#tcpip-wireless)):
+   ```bash
+   scrcpy --tcpip=192.168.1.1:5555
+   scrcpy --tcpip=192.168.1.1        # default port is 5555
+   ```
+
+The serial may also be provided via the environment variable `ANDROID_SERIAL`
+(also used by `adb`):
+
+```bash
+# in bash
+export ANDROID_SERIAL=0123456789abcdef
+scrcpy
+```
+
+```cmd
+:: in cmd
+set ANDROID_SERIAL=0123456789abcdef
+scrcpy
+```
+
+```powershell
+# in PowerShell
+$env:ANDROID_SERIAL = '0123456789abcdef'
+scrcpy
+```
+
+
+## TCP/IP (wireless)
+
+_Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
+device over TCP/IP. The device must be connected on the same network as the
+computer.
+
+[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
+
+
+### Automatic
+
+An option `--tcpip` allows to configure the connection automatically. There are
+two variants.
+
+If the device (accessible at 192.168.1.1 in this example) already listens on a
+port (typically 5555) for incoming _adb_ connections, then run:
+
+```bash
+scrcpy --tcpip=192.168.1.1       # default port is 5555
+scrcpy --tcpip=192.168.1.1:5555
+```
+
+If _adb_ TCP/IP mode is disabled on the device (or if you don't know the IP
+address), connect the device over USB, then run:
+
+```bash
+scrcpy --tcpip   # without arguments
+```
+
+It will automatically find the device IP address and adb port, enable TCP/IP
+mode if necessary, then connect to the device before starting.
+
+
+### Manual
+
+Alternatively, it is possible to enable the TCP/IP connection manually using
+`adb`:
+
+1. Plug the device into a USB port on your computer.
+2. Connect the device to the same Wi-Fi network as your computer.
+3. Get your device IP address, in Settings → About phone → Status, or by
+   executing this command:
+
+    ```bash
+    adb shell ip route | awk '{print $9}'
+    ```
+
+4. Enable `adb` over TCP/IP on your device: `adb tcpip 5555`.
+5. Unplug your device.
+6. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`
+with the device IP address you found)_.
+7. Run `scrcpy` as usual.
+8. Run `adb disconnect` once you're done.
+
+Since Android 11, a [wireless debugging option][adb-wireless] allows to bypass
+having to physically connect your device directly to your computer.
+
+[adb-wireless]: https://developer.android.com/studio/command-line/adb#wireless-android11-command-line
+
+
+## Autostart
+
+A small tool (by the scrcpy author) allows to run arbitrary commands whenever a
+new Android device is connected: [AutoAdb]. It can be used to start scrcpy:
+
+```bash
+autoadb scrcpy -s '{}'
+```
+
+[AutoAdb]: https://github.com/rom1v/autoadb

doc/device.md

@@ -1,156 +1,9 @@
 # Device
 
-## Selection
-
-If exactly one device is connected (i.e. listed by `adb devices`), then it is
-automatically selected.
-
-However, if there are multiple devices connected, you must specify the one to
-use in one of 4 ways:
- - by its serial:
-   ```bash
-   scrcpy --serial=0123456789abcdef
-   scrcpy -s 0123456789abcdef   # short version
-
-   # the serial is the ip:port if connected over TCP/IP (same behavior as adb)
-   scrcpy --serial=192.168.1.1:5555
-   ```
- - the one connected over USB (if there is exactly one):
-   ```bash
-   scrcpy --select-usb
-   scrcpy -d   # short version
-   ```
- - the one connected over TCP/IP (if there is exactly one):
-   ```bash
-   scrcpy --select-tcpip
-   scrcpy -e   # short version
-   ```
- - a device already listening on TCP/IP (see [below](#tcpip-wireless)):
-   ```bash
-   scrcpy --tcpip=192.168.1.1:5555
-   scrcpy --tcpip=192.168.1.1        # default port is 5555
-   ```
-
-The serial may also be provided via the environment variable `ANDROID_SERIAL`
-(also used by `adb`):
-
-```bash
-# in bash
-export ANDROID_SERIAL=0123456789abcdef
-scrcpy
-```
-
-```cmd
-:: in cmd
-set ANDROID_SERIAL=0123456789abcdef
-scrcpy
-```
-
-```powershell
-# in PowerShell
-$env:ANDROID_SERIAL = '0123456789abcdef'
-scrcpy
-```
-
-
-## TCP/IP (wireless)
-
-_Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
-device over TCP/IP. The device must be connected on the same network as the
-computer.
-
-[connect]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-### Automatic
-
-An option `--tcpip` allows to configure the connection automatically. There are
-two variants.
-
-If the device (accessible at 192.168.1.1 in this example) already listens on a
-port (typically 5555) for incoming _adb_ connections, then run:
-
-```bash
-scrcpy --tcpip=192.168.1.1       # default port is 5555
-scrcpy --tcpip=192.168.1.1:5555
-```
-
-If _adb_ TCP/IP mode is disabled on the device (or if you don't know the IP
-address), connect the device over USB, then run:
-
-```bash
-scrcpy --tcpip   # without arguments
-```
-
-It will automatically find the device IP address and adb port, enable TCP/IP
-mode if necessary, then connect to the device before starting.
-
-
-### Manual
-
-Alternatively, it is possible to enable the TCP/IP connection manually using
-`adb`:
-
-1. Plug the device into a USB port on your computer.
-2. Connect the device to the same Wi-Fi network as your computer.
-3. Get your device IP address, in Settings → About phone → Status, or by
-   executing this command:
-
-    ```bash
-    adb shell ip route | awk '{print $9}'
-    ```
-
-4. Enable `adb` over TCP/IP on your device: `adb tcpip 5555`.
-5. Unplug your device.
-6. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`
-with the device IP address you found)_.
-7. Run `scrcpy` as usual.
-8. Run `adb disconnect` once you're done.
-
-Since Android 11, a [wireless debugging option][adb-wireless] allows to bypass
-having to physically connect your device directly to your computer.
-
-[adb-wireless]: https://developer.android.com/studio/command-line/adb#wireless-android11-command-line
-
-
-## Autostart
-
-A small tool (by the scrcpy author) allows to run arbitrary commands whenever a
-new Android device is connected: [AutoAdb]. It can be used to start scrcpy:
-
-```bash
-autoadb scrcpy -s '{}'
-```
-
-[AutoAdb]: https://github.com/rom1v/autoadb
-
-
-## Display
-
-If several displays are available on the Android device, it is possible to
-select the display to mirror:
-
-```bash
-scrcpy --display=1
-```
-
-The list of display ids can be retrieved by:
-
-```bash
-scrcpy --list-displays
-```
-
-A secondary display may only be controlled if the device runs at least Android
-10 (otherwise it is mirrored as read-only).
-
-
-## Actions
-
 Some command line arguments perform actions on the device itself while scrcpy is
 running.
 
-
-### Stay awake
+## Stay awake
 
 To prevent the device from sleeping after a delay **when the device is plugged
 in**:
@@ -166,7 +19,7 @@ If the device is not plugged in (i.e. only connected over TCP/IP),
 `--stay-awake` has no effect (this is the Android behavior).
 
 
-### Turn screen off
+## Turn screen off
 
 It is possible to turn the device screen off while mirroring on start with a
 command-line option:
@@ -194,7 +47,7 @@ scrcpy -Sw   # short version
 ```
 
 
-### Show touches
+## Show touches
 
 For presentations, it may be useful to show physical touches (on the physical
 device). Android exposes this feature in _Developers options_.
@@ -210,7 +63,7 @@ scrcpy -t   # short version
 Note that it only shows _physical_ touches (by a finger on the device).
 
 
-### Power off on close
+## Power off on close
 
 To turn the device screen off when closing _scrcpy_:
 
@@ -218,11 +71,10 @@ To turn the device screen off when closing _scrcpy_:
 scrcpy --power-off-on-close
 ```
 
-### Power on on start
+## Power on on start
 
 By default, on start, the device is powered on. To prevent this behavior:
 
 ```bash
 scrcpy --no-power-on
 ```
-

doc/video.md

@@ -66,6 +66,14 @@ scrcpy --video-codec=av1
 H265 may provide better quality, but H264 should provide lower latency.
 AV1 encoders are not common on current Android devices.
 
+For advanced usage, to pass arbitrary parameters to the [`MediaFormat`],
+check `--video-codec-options` in the manpage or in `scrcpy --help`.
+
+[`MediaFormat`]: https://developer.android.com/reference/android/media/MediaFormat
+
+
+## Encoder
+
 Several encoders may be available on the device. They can be listed by:
 
 ```bash
@@ -79,11 +87,6 @@ try another one:
 scrcpy --video-codec=h264 --video-encoder='OMX.qcom.video.encoder.avc'
 ```
 
-For advanced usage, to pass arbitrary parameters to the [`MediaFormat`],
-check `--video-codec-options` in the manpage or in `scrcpy --help`.
-
-[`MediaFormat`]: https://developer.android.com/reference/android/media/MediaFormat
-
 
 ## Rotation
 
@@ -134,6 +137,25 @@ phone, landscape for a tablet).
 If `--max-size` is also specified, resizing is applied after cropping.
 
 
+## Display
+
+If several displays are available on the Android device, it is possible to
+select the display to mirror:
+
+```bash
+scrcpy --display=1
+```
+
+The list of display ids can be retrieved by:
+
+```bash
+scrcpy --list-displays
+```
+
+A secondary display may only be controlled if the device runs at least Android
+10 (otherwise it is mirrored as read-only).
+
+
 ## Buffering
 
 By default, there is no video buffering, to get the lowest possible latency.

server/src/main/java/com/genymobile/scrcpy/CameraCapture.java

@@ -0,0 +1,197 @@
+package com.genymobile.scrcpy;
+
+import com.genymobile.scrcpy.wrappers.ServiceManager;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.graphics.Rect;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCaptureSession;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraDevice;
+import android.hardware.camera2.CaptureFailure;
+import android.hardware.camera2.CaptureRequest;
+import android.hardware.camera2.params.OutputConfiguration;
+import android.hardware.camera2.params.SessionConfiguration;
+import android.hardware.camera2.params.StreamConfigurationMap;
+import android.media.MediaCodec;
+import android.os.Build;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.util.Log;
+import android.view.Surface;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+public class CameraCapture extends SurfaceCapture {
+
+    private static final Executor EXECUTOR = Executors.newSingleThreadExecutor();
+
+    private final String cameraId;
+
+    private HandlerThread cameraThread;
+    private Handler cameraHandler;
+    private CameraDevice cameraDevice;
+    private int maxSize;
+
+    public CameraCapture(String cameraId, int maxSize) {
+        this.cameraId = cameraId;
+        this.maxSize = maxSize;
+    }
+
+    @Override
+    public void init() throws IOException {
+        cameraThread = new HandlerThread("camera");
+        cameraThread.start();
+        cameraHandler = new Handler(cameraThread.getLooper());
+
+        try {
+            cameraDevice = openCamera(cameraId);
+        } catch (CameraAccessException | InterruptedException e) {
+            throw new IOException(e);
+        }
+    }
+
+    @Override
+    public void start(Surface surface) throws IOException {
+        try {
+            CameraCaptureSession session = createCaptureSession(cameraDevice, surface);
+            CaptureRequest.Builder requestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
+            requestBuilder.addTarget(surface);
+            CaptureRequest request = requestBuilder.build();
+            setRepeatingRequest(session, request);
+        } catch (CameraAccessException | InterruptedException e) {
+            throw new IOException(e);
+        }
+    }
+
+    @Override
+    public void release() {
+        if (cameraDevice != null) {
+            cameraDevice.close();
+        }
+        if (cameraThread != null) {
+            cameraThread.quitSafely();
+        }
+    }
+
+    @Override
+    public Size getSize() {
+        return new Size(1920, 1080);
+    }
+
+    @Override
+    public void setMaxSize(int size) {
+        maxSize = size;
+    }
+
+    @SuppressLint("MissingPermission")
+    @TargetApi(Build.VERSION_CODES.S)
+    private CameraDevice openCamera(String id) throws CameraAccessException, InterruptedException {
+        Ln.v("Open Camera: " + id);
+
+        CompletableFuture<CameraDevice> future = new CompletableFuture<>();
+        ServiceManager.getCameraManager().openCamera(id, new CameraDevice.StateCallback() {
+            @Override
+            public void onOpened(CameraDevice camera) {
+                Ln.v("Open Camera Success");
+                future.complete(camera);
+            }
+
+            @Override
+            public void onDisconnected(CameraDevice camera) {
+                Ln.w("Camera disconnected");
+                // TODO
+            }
+
+            @Override
+            public void onError(CameraDevice camera, int error) {
+                int cameraAccessExceptionErrorCode;
+                switch (error) {
+                    case CameraDevice.StateCallback.ERROR_CAMERA_IN_USE:
+                        cameraAccessExceptionErrorCode = CameraAccessException.CAMERA_IN_USE;
+                        break;
+                    case CameraDevice.StateCallback.ERROR_MAX_CAMERAS_IN_USE:
+                        cameraAccessExceptionErrorCode = CameraAccessException.MAX_CAMERAS_IN_USE;
+                        break;
+                    case CameraDevice.StateCallback.ERROR_CAMERA_DISABLED:
+                        cameraAccessExceptionErrorCode = CameraAccessException.CAMERA_DISABLED;
+                        break;
+                    case CameraDevice.StateCallback.ERROR_CAMERA_DEVICE:
+                    case CameraDevice.StateCallback.ERROR_CAMERA_SERVICE:
+                    default:
+                        cameraAccessExceptionErrorCode = CameraAccessException.CAMERA_ERROR;
+                        break;
+                }
+                future.completeExceptionally(new CameraAccessException(cameraAccessExceptionErrorCode));
+            }
+        }, cameraHandler);
+
+        try {
+            return future.get();
+        } catch (ExecutionException e) {
+            throw (CameraAccessException) e.getCause();
+        }
+    }
+
+    @TargetApi(Build.VERSION_CODES.S)
+    private CameraCaptureSession createCaptureSession(CameraDevice camera, Surface surface) throws CameraAccessException, InterruptedException {
+        Ln.d("Create Capture Session");
+
+        CompletableFuture<CameraCaptureSession> future = new CompletableFuture<>();
+        // replace by createCaptureSession(SessionConfiguration)
+        OutputConfiguration outputConfig = new OutputConfiguration(surface);
+        List<OutputConfiguration> outputs = Arrays.asList(outputConfig);
+        SessionConfiguration sessionConfig = new SessionConfiguration(SessionConfiguration.SESSION_REGULAR, outputs, EXECUTOR,
+                new CameraCaptureSession.StateCallback() {
+                    @Override
+                    public void onConfigured(CameraCaptureSession session) {
+                        Ln.d("Create Capture Session Success");
+                        future.complete(session);
+                    }
+
+                    @Override
+                    public void onConfigureFailed(CameraCaptureSession session) {
+                        future.completeExceptionally(new CameraAccessException(CameraAccessException.CAMERA_ERROR));
+                    }
+                });
+
+        camera.createCaptureSession(sessionConfig);
+
+        try {
+            return future.get();
+        } catch (ExecutionException e) {
+            throw (CameraAccessException) e.getCause();
+        }
+    }
+
+    @TargetApi(Build.VERSION_CODES.S)
+    private void setRepeatingRequest(CameraCaptureSession session, CaptureRequest request) throws CameraAccessException, InterruptedException {
+        CompletableFuture<Void> future = new CompletableFuture<>();
+        session.setRepeatingRequest(request, new CameraCaptureSession.CaptureCallback() {
+            @Override
+            public void onCaptureStarted(CameraCaptureSession session, CaptureRequest request, long timestamp, long frameNumber) {
+                future.complete(null);
+            }
+
+            @Override
+            public void onCaptureFailed(CameraCaptureSession session, CaptureRequest request, CaptureFailure failure) {
+                future.completeExceptionally(new CameraAccessException(CameraAccessException.CAMERA_ERROR));
+            }
+        }, cameraHandler);
+
+        try {
+            future.get();
+        } catch (ExecutionException e) {
+            throw (CameraAccessException) e.getCause();
+        }
+    }
+}

server/src/main/java/com/genymobile/scrcpy/LogUtils.java

@@ -3,6 +3,12 @@ package com.genymobile.scrcpy;
 import com.genymobile.scrcpy.wrappers.DisplayManager;
 import com.genymobile.scrcpy.wrappers.ServiceManager;
 
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.params.StreamConfigurationMap;
+import android.media.MediaCodec;
+
 import java.util.List;
 
 public final class LogUtils {
@@ -60,4 +66,48 @@ public final class LogUtils {
         }
         return builder.toString();
     }
+
+    private static String getCameraFacingName(int facing) {
+        switch (facing) {
+            case CameraCharacteristics.LENS_FACING_FRONT:
+                return "front";
+            case CameraCharacteristics.LENS_FACING_BACK:
+                return "back";
+            case CameraCharacteristics.LENS_FACING_EXTERNAL:
+                return "external";
+            default:
+                return "unknown";
+        }
+    }
+
+    public static String buildCameraListMessage() {
+        StringBuilder builder = new StringBuilder("List of cameras:");
+        CameraManager cameraManager = ServiceManager.getCameraManager();
+        try {
+            String[] cameraIds = cameraManager.getCameraIdList();
+            if (cameraIds == null || cameraIds.length == 0) {
+                builder.append("\n    (none)");
+            } else {
+                for (String id : cameraIds) {
+                    builder.append("\n    --video-source=camera --camera=").append(id);
+                    CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(id);
+                    Integer facingInteger = characteristics.get(CameraCharacteristics.LENS_FACING);
+                    if (facingInteger != null) {
+                        int facing = facingInteger;
+                        builder.append("    (").append(getCameraFacingName(facing)).append(')');
+                    }
+
+                    StreamConfigurationMap configs = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
+                    android.util.Size[] sizes = configs.getOutputSizes(MediaCodec.class);
+                    for (android.util.Size size : sizes) {
+                        // TODO remove (just for testing)
+                        builder.append("\n        - " + size.getWidth() + "x" + size.getHeight());
+                    }
+                }
+            }
+        } catch (CameraAccessException e) {
+            builder.append("\n    (access denied)");
+        }
+        return builder.toString();
+    }
 }

server/src/main/java/com/genymobile/scrcpy/Options.java

@@ -38,6 +38,7 @@ public class Options {
 
     private boolean listEncoders;
     private boolean listDisplays;
+    private boolean listCameras;
 
     // Options not used by the scrcpy client, but useful to use scrcpy-server directly
     private boolean sendDeviceMeta = true; // send device name and size
@@ -161,6 +162,10 @@ public class Options {
         return listDisplays;
     }
 
+    public boolean getListCameras() {
+        return listCameras;
+    }
+
     public boolean getSendDeviceMeta() {
         return sendDeviceMeta;
     }
@@ -306,6 +311,9 @@ public class Options {
                 case "list_displays":
                     options.listDisplays = Boolean.parseBoolean(value);
                     break;
+                case "list_cameras":
+                    options.listCameras = Boolean.parseBoolean(value);
+                    break;
                 case "send_device_meta":
                     options.sendDeviceMeta = Boolean.parseBoolean(value);
                     break;

server/src/main/java/com/genymobile/scrcpy/ScreenCapture.java

@@ -0,0 +1,83 @@
+package com.genymobile.scrcpy;
+
+import com.genymobile.scrcpy.wrappers.SurfaceControl;
+
+import android.graphics.Rect;
+import android.os.Build;
+import android.os.IBinder;
+import android.view.Surface;
+
+public class ScreenCapture extends SurfaceCapture implements Device.RotationListener, Device.FoldListener {
+
+    private final Device device;
+    private IBinder display;
+
+    public ScreenCapture(Device device) {
+        this.device = device;
+    }
+
+    @Override
+    public void init() {
+        display = createDisplay();
+        device.setRotationListener(this);
+        device.setFoldListener(this);
+    }
+
+    @Override
+    public void start(Surface surface) {
+        ScreenInfo screenInfo = device.getScreenInfo();
+        Rect contentRect = screenInfo.getContentRect();
+
+        // does not include the locked video orientation
+        Rect unlockedVideoRect = screenInfo.getUnlockedVideoSize().toRect();
+        int videoRotation = screenInfo.getVideoRotation();
+        int layerStack = device.getLayerStack();
+        setDisplaySurface(display, surface, videoRotation, contentRect, unlockedVideoRect, layerStack);
+    }
+
+    @Override
+    public void release() {
+        device.setRotationListener(null);
+        device.setFoldListener(null);
+        SurfaceControl.destroyDisplay(display);
+    }
+
+    @Override
+    public Size getSize() {
+        return device.getScreenInfo().getVideoSize();
+    }
+
+    @Override
+    public void setMaxSize(int size) {
+        device.setMaxSize(size);
+    }
+
+    @Override
+    public void onFoldChanged(int displayId, boolean folded) {
+        requestReset();
+    }
+
+    @Override
+    public void onRotationChanged(int rotation) {
+        requestReset();
+    }
+
+    private static IBinder createDisplay() {
+        // Since Android 12 (preview), secure displays could not be created with shell permissions anymore.
+        // On Android 12 preview, SDK_INT is still R (not S), but CODENAME is "S".
+        boolean secure = Build.VERSION.SDK_INT < Build.VERSION_CODES.R || (Build.VERSION.SDK_INT == Build.VERSION_CODES.R && !"S".equals(
+                Build.VERSION.CODENAME));
+        return SurfaceControl.createDisplay("scrcpy", secure);
+    }
+
+    private static void setDisplaySurface(IBinder display, Surface surface, int orientation, Rect deviceRect, Rect displayRect, int layerStack) {
+        SurfaceControl.openTransaction();
+        try {
+            SurfaceControl.setDisplaySurface(display, surface);
+            SurfaceControl.setDisplayProjection(display, orientation, deviceRect, displayRect);
+            SurfaceControl.setDisplayLayerStack(display, layerStack);
+        } finally {
+            SurfaceControl.closeTransaction();
+        }
+    }
+}

server/src/main/java/com/genymobile/scrcpy/Server.java

@@ -2,6 +2,7 @@ package com.genymobile.scrcpy;
 
 import android.os.BatteryManager;
 import android.os.Build;
+import android.os.Looper;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -99,7 +100,8 @@ public final class Server {
         boolean audio = options.getAudio();
         boolean sendDummyByte = options.getSendDummyByte();
 
-        Workarounds.apply(audio);
+        boolean camera = true;
+        Workarounds.apply(audio, camera);
 
         List<AsyncProcessor> asyncProcessors = new ArrayList<>();
 
@@ -132,7 +134,9 @@ public final class Server {
             if (video) {
                 Streamer videoStreamer = new Streamer(connection.getVideoFd(), options.getVideoCodec(), options.getSendCodecMeta(),
                         options.getSendFrameMeta());
-                ScreenEncoder screenEncoder = new ScreenEncoder(device, videoStreamer, options.getVideoBitRate(), options.getMaxFps(),
+                CameraCapture capture = new CameraCapture("0", 1920);
+                //ScreenCapture screenCapture = new ScreenCapture(device);
+                SurfaceEncoder screenEncoder = new SurfaceEncoder(capture, videoStreamer, options.getVideoBitRate(), options.getMaxFps(),
                         options.getVideoCodecOptions(), options.getVideoEncoder(), options.getDownsizeOnError());
                 asyncProcessors.add(screenEncoder);
             }
@@ -179,7 +183,7 @@ public final class Server {
 
         Ln.initLogLevel(options.getLogLevel());
 
-        if (options.getListEncoders() || options.getListDisplays()) {
+        if (options.getListEncoders() || options.getListDisplays() || options.getListCameras()) {
             if (options.getCleanup()) {
                 CleanUp.unlinkSelf();
             }
@@ -191,6 +195,10 @@ public final class Server {
             if (options.getListDisplays()) {
                 Ln.i(LogUtils.buildDisplayListMessage());
             }
+            if (options.getListCameras()) {
+                Workarounds.apply(false, true);
+                Ln.i(LogUtils.buildCameraListMessage());
+            }
             // Just print the requested data, do not mirror
             return;
         }

server/src/main/java/com/genymobile/scrcpy/SurfaceCapture.java

@@ -0,0 +1,62 @@
+package com.genymobile.scrcpy;
+
+import android.view.Surface;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * A video source which can be rendered on a Surface for encoding.
+ */
+public abstract class SurfaceCapture {
+
+    private final AtomicBoolean resetCapture = new AtomicBoolean();
+
+    /**
+     * Request the encoding session to be restarted, for example if the capture implementation detects that the video source size has changed (on
+     * device rotation for example).
+     */
+    protected void requestReset() {
+        resetCapture.set(true);
+    }
+
+    /**
+     * Consume the reset request (intended to be called by the encoder).
+     *
+     * @return {@code true} if a reset request was pending, {@code false} otherwise.
+     */
+    public boolean consumeReset() {
+        return resetCapture.getAndSet(false);
+    }
+
+    /**
+     * Called once before the capture starts.
+     */
+    public abstract void init() throws IOException;
+
+    /**
+     * Called after the capture ends (if and only if {@link #init()} has been called).
+     */
+    public abstract void release();
+
+    /**
+     * Start the capture to the target surface.
+     *
+     * @param surface the surface which will be encoded
+     */
+    public abstract void start(Surface surface) throws IOException;
+
+    /**
+     * Return the video size
+     *
+     * @return the video size
+     */
+    public abstract Size getSize();
+
+    /**
+     * Set the maximum capture size (set by the encoder if it does not support the current size).
+     *
+     * @param size Maximum size
+     */
+    public abstract void setMaxSize(int size);
+}

server/src/main/java/com/genymobile/scrcpy/SurfaceEncoder.java

@@ -1,13 +1,8 @@
 package com.genymobile.scrcpy;
 
-import com.genymobile.scrcpy.wrappers.SurfaceControl;
-
-import android.graphics.Rect;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.media.MediaFormat;
-import android.os.Build;
-import android.os.IBinder;
 import android.os.Looper;
 import android.os.SystemClock;
 import android.view.Surface;
@@ -17,7 +12,7 @@ import java.nio.ByteBuffer;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-public class ScreenEncoder implements Device.RotationListener, Device.FoldListener, AsyncProcessor {
+public class SurfaceEncoder implements AsyncProcessor {
 
     private static final int DEFAULT_I_FRAME_INTERVAL = 10; // seconds
     private static final int REPEAT_FRAME_DELAY_US = 100_000; // repeat after 100ms
@@ -27,9 +22,7 @@ public class ScreenEncoder implements Device.RotationListener, Device.FoldListen
     private static final int[] MAX_SIZE_FALLBACK = {2560, 1920, 1600, 1280, 1024, 800};
     private static final int MAX_CONSECUTIVE_ERRORS = 3;
 
-    private final AtomicBoolean resetCapture = new AtomicBoolean();
-
-    private final Device device;
+    private final SurfaceCapture capture;
     private final Streamer streamer;
     private final String encoderName;
     private final List<CodecOption> codecOptions;
@@ -43,9 +36,9 @@ public class ScreenEncoder implements Device.RotationListener, Device.FoldListen
     private Thread thread;
     private final AtomicBoolean stopped = new AtomicBoolean();
 
-    public ScreenEncoder(Device device, Streamer streamer, int videoBitRate, int maxFps, List<CodecOption> codecOptions, String encoderName,
+    public SurfaceEncoder(SurfaceCapture capture, Streamer streamer, int videoBitRate, int maxFps, List<CodecOption> codecOptions, String encoderName,
             boolean downsizeOnError) {
-        this.device = device;
+        this.capture = capture;
         this.streamer = streamer;
         this.videoBitRate = videoBitRate;
         this.maxFps = maxFps;
@@ -54,51 +47,29 @@ public class ScreenEncoder implements Device.RotationListener, Device.FoldListen
         this.downsizeOnError = downsizeOnError;
     }
 
-    @Override
-    public void onFoldChanged(int displayId, boolean folded) {
-        resetCapture.set(true);
-    }
-
-    @Override
-    public void onRotationChanged(int rotation) {
-        resetCapture.set(true);
-    }
-
-    private boolean consumeResetCapture() {
-        return resetCapture.getAndSet(false);
-    }
-
     private void streamScreen() throws IOException, ConfigurationException {
         Codec codec = streamer.getCodec();
         MediaCodec mediaCodec = createMediaCodec(codec, encoderName);
         MediaFormat format = createFormat(codec.getMimeType(), videoBitRate, maxFps, codecOptions);
-        IBinder display = createDisplay();
-        device.setRotationListener(this);
-        device.setFoldListener(this);
 
-        streamer.writeVideoHeader(device.getScreenInfo().getVideoSize());
+        capture.init();
 
-        boolean alive;
         try {
-            do {
-                ScreenInfo screenInfo = device.getScreenInfo();
-                Rect contentRect = screenInfo.getContentRect();
+            streamer.writeVideoHeader(capture.getSize());
 
-                // include the locked video orientation
-                Rect videoRect = screenInfo.getVideoSize().toRect();
-                format.setInteger(MediaFormat.KEY_WIDTH, videoRect.width());
-                format.setInteger(MediaFormat.KEY_HEIGHT, videoRect.height());
+            boolean alive;
+
+            do {
+                Size size = capture.getSize();
+                format.setInteger(MediaFormat.KEY_WIDTH, size.getWidth());
+                format.setInteger(MediaFormat.KEY_HEIGHT, size.getHeight());
 
                 Surface surface = null;
                 try {
                     mediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
                     surface = mediaCodec.createInputSurface();
 
-                    // does not include the locked video orientation
-                    Rect unlockedVideoRect = screenInfo.getUnlockedVideoSize().toRect();
-                    int videoRotation = screenInfo.getVideoRotation();
-                    int layerStack = device.getLayerStack();
-                    setDisplaySurface(display, surface, videoRotation, contentRect, unlockedVideoRect, layerStack);
+                    capture.start(surface);
 
                     mediaCodec.start();
 
@@ -107,7 +78,7 @@ public class ScreenEncoder implements Device.RotationListener, Device.FoldListen
                     mediaCodec.stop();
                 } catch (IllegalStateException | IllegalArgumentException e) {
                     Ln.e("Encoding error: " + e.getClass().getName() + ": " + e.getMessage());
-                    if (!prepareRetry(device, screenInfo)) {
+                    if (!prepareRetry(size)) {
                         throw e;
                     }
                     Ln.i("Retrying...");
@@ -121,13 +92,11 @@ public class ScreenEncoder implements Device.RotationListener, Device.FoldListen
             } while (alive);
         } finally {
             mediaCodec.release();
-            device.setRotationListener(null);
-            device.setFoldListener(null);
-            SurfaceControl.destroyDisplay(display);
+            capture.release();
         }
     }
 
-    private boolean prepareRetry(Device device, ScreenInfo screenInfo) {
+    private boolean prepareRetry(Size currentSize) {
         if (firstFrameSent) {
             ++consecutiveErrors;
             if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
@@ -147,7 +116,7 @@ public class ScreenEncoder implements Device.RotationListener, Device.FoldListen
 
         // Downsizing on error is only enabled if an encoding failure occurs before the first frame (downsizing later could be surprising)
 
-        int newMaxSize = chooseMaxSizeFallback(screenInfo.getVideoSize());
+        int newMaxSize = chooseMaxSizeFallback(currentSize);
         if (newMaxSize == 0) {
             // Must definitively fail
             return false;
@@ -155,7 +124,7 @@ public class ScreenEncoder implements Device.RotationListener, Device.FoldListen
 
         // Retry with a smaller device size
         Ln.i("Retrying with -m" + newMaxSize + "...");
-        device.setMaxSize(newMaxSize);
+        capture.setMaxSize(newMaxSize);
         return true;
     }
 
@@ -176,14 +145,14 @@ public class ScreenEncoder implements Device.RotationListener, Device.FoldListen
         boolean alive = true;
         MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
 
-        while (!consumeResetCapture() && !eof) {
+        while (!capture.consumeReset() && !eof) {
             if (stopped.get()) {
                 alive = false;
                 break;
             }
             int outputBufferId = codec.dequeueOutputBuffer(bufferInfo, -1);
             try {
-                if (consumeResetCapture()) {
+                if (capture.consumeReset()) {
                     // must restart encoding with new size
                     break;
                 }
@@ -264,25 +233,6 @@ public class ScreenEncoder implements Device.RotationListener, Device.FoldListen
         return format;
     }
 
-    private static IBinder createDisplay() {
-        // Since Android 12 (preview), secure displays could not be created with shell permissions anymore.
-        // On Android 12 preview, SDK_INT is still R (not S), but CODENAME is "S".
-        boolean secure = Build.VERSION.SDK_INT < Build.VERSION_CODES.R || (Build.VERSION.SDK_INT == Build.VERSION_CODES.R && !"S"
-                .equals(Build.VERSION.CODENAME));
-        return SurfaceControl.createDisplay("scrcpy", secure);
-    }
-
-    private static void setDisplaySurface(IBinder display, Surface surface, int orientation, Rect deviceRect, Rect displayRect, int layerStack) {
-        SurfaceControl.openTransaction();
-        try {
-            SurfaceControl.setDisplaySurface(display, surface);
-            SurfaceControl.setDisplayProjection(display, orientation, deviceRect, displayRect);
-            SurfaceControl.setDisplayLayerStack(display, layerStack);
-        } finally {
-            SurfaceControl.closeTransaction();
-        }
-    }
-
     @Override
     public void start(TerminationListener listener) {
         thread = new Thread(() -> {

server/src/main/java/com/genymobile/scrcpy/Workarounds.java

@@ -28,14 +28,13 @@ public final class Workarounds {
         // not instantiable
     }
 
-    public static void apply(boolean audio) {
+    public static void apply(boolean audio, boolean camera) {
         Workarounds.prepareMainLooper();
 
         boolean mustFillAppInfo = false;
-        boolean mustFillBaseContext = false;
+        boolean mustFillBaseContext = true;
         boolean mustFillAppContext = false;
 
-
         if (Build.BRAND.equalsIgnoreCase("meizu")) {
             // Workarounds must be applied for Meizu phones:
             //  - <https://github.com/Genymobile/scrcpy/issues/240>
@@ -65,6 +64,10 @@ public final class Workarounds {
             mustFillAppContext = true;
         }
 
+        if (camera) {
+            mustFillAppInfo = true;
+        }
+
         if (mustFillAppInfo) {
             Workarounds.fillAppInfo();
         }
@@ -154,7 +157,7 @@ public final class Workarounds {
         }
     }
 
-    public static void fillBaseContext() {
+    private static void fillBaseContext() {
         try {
             fillActivityThread();
 

server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityManager.java

@@ -17,7 +17,7 @@ import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
 @SuppressLint("PrivateApi,DiscouragedPrivateApi")
-public class ActivityManager {
+public final class ActivityManager {
 
     private final IInterface manager;
     private Method getContentProviderExternalMethod;

server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java

@@ -11,7 +11,7 @@ import android.os.IInterface;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
-public class ClipboardManager {
+public final class ClipboardManager {
     private final IInterface manager;
     private Method getPrimaryClipMethod;
     private Method setPrimaryClipMethod;

server/src/main/java/com/genymobile/scrcpy/wrappers/ContentProvider.java

@@ -14,7 +14,7 @@ import java.io.Closeable;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
-public class ContentProvider implements Closeable {
+public final class ContentProvider implements Closeable {
 
     public static final String TABLE_SYSTEM = "system";
     public static final String TABLE_SECURE = "secure";

server/src/main/java/com/genymobile/scrcpy/wrappers/ServiceManager.java

@@ -1,9 +1,15 @@
 package com.genymobile.scrcpy.wrappers;
 
+import com.genymobile.scrcpy.FakeContext;
+import com.genymobile.scrcpy.Workarounds;
+
 import android.annotation.SuppressLint;
+import android.content.Context;
+import android.hardware.camera2.CameraManager;
 import android.os.IBinder;
 import android.os.IInterface;
 
+import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
@@ -26,6 +32,7 @@ public final class ServiceManager {
     private static StatusBarManager statusBarManager;
     private static ClipboardManager clipboardManager;
     private static ActivityManager activityManager;
+    private static CameraManager cameraManager;
 
     private ServiceManager() {
         /* not instantiable */
@@ -129,4 +136,16 @@ public final class ServiceManager {
 
         return activityManager;
     }
+
+    public static CameraManager getCameraManager() {
+        if (cameraManager == null) {
+            try {
+                Constructor<CameraManager> ctor = CameraManager.class.getDeclaredConstructor(Context.class);
+                cameraManager = ctor.newInstance(FakeContext.get());
+            } catch (Exception e) {
+                throw new AssertionError(e);
+            }
+        }
+        return cameraManager;
+    }
 }

server/src/main/java/com/genymobile/scrcpy/wrappers/StatusBarManager.java

@@ -7,7 +7,7 @@ import android.os.IInterface;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
-public class StatusBarManager {
+public final class StatusBarManager {
 
     private final IInterface manager;
     private Method expandNotificationsPanelMethod;