Android realizes screen sharing and remote control functions for two mobile phones

+--------------+                                +--------------+
|              |--(Request authorization)------------------->|              |
| MainActivity |                                | RemoteActivity|
|              |<-(Start the service、Connection successfully)-----------|              |
+------+-------+                                +------+-------+
       |                                                |
       | Capture the screen -> MediaProjection -> ImageReader      | Receive screen -> decoding -> SurfaceView
       | coding(JPEG/H.264)                               | 
       | send -> Socket OutputStream                     | 
       |                                                | Receive events -> Accessible Service -> dispatchGesture
       |<--Touch event pack------------------------------------|
       | Simulated touch => AccessibilityService                |
+------+-------+                                +------+-------+
| ScreenShare  |                                | RemoteControl|
|   Service    |                                |   Service    |
+--------------+                                +--------------+

Path path = new Path();
(x, y);
 stroke = new (path, 0, 1);

/**************************  **************************/
package ;
 
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
 
import ;
import ;
import ;
import ;
 
/*
  * MainActivity: Responsible
  * 1. Request screen capture permissions
  * 2. Start ScreenShareService
  * 3. Capture touch events and send
  */
public class MainActivity extends Activity {
    private static final int REQUEST_CODE_CAPTURE = 100;
    private MediaProjectionManager mProjectionManager;
    private MediaProjection mMediaProjection;
    private ImageReader mImageReader;
    private VirtualDisplay mVirtualDisplay;
    private ScreenShareService mShareService;
    private Button mStartBtn, mStopBtn;
    private Socket mSocket;
    private BufferedOutputStream mOut;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        (savedInstanceState);
        setContentView(.activity_main);
        mStartBtn = findViewById(.btn_start);
        mStopBtn = findViewById(.btn_stop);
 
        // Click Start: Request authorization and start the service        (v -> startCapture());
        // Click Stop: Stop the service and disconnect        (v -> {
            ();
        });
    }
 
    /** Request screen capture authorization */
    private void startCapture() {
        mProjectionManager = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);
        startActivityForResult((), REQUEST_CODE_CAPTURE);
    }
 
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == REQUEST_CODE_CAPTURE && resultCode == RESULT_OK) {
            mMediaProjection = (resultCode, data);
            // Initialize ImageReader and VirtualDisplay            setupVirtualDisplay();
            // Start the service            mShareService = new ScreenShareService(mMediaProjection, mImageReader);
            ();
        }
    }
 
    /** Initialize virtual monitors for screen capture */
    private void setupVirtualDisplay() {
        DisplayMetrics metrics = getResources().getDisplayMetrics();
        mImageReader = (, ,
                                               PixelFormat.RGBA_8888, 2);
        mVirtualDisplay = ("ScreenCast",
                , , ,
                DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
                (), null, null);
    }
 
    /** Capture touch events and send them to the controlled end */
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (mShareService != null && ()) {
            (event);
        }
        return (event);
    }
}
 
/**************************  **************************/
package ;
 
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
 
import ;
import ;
import ;
 
/*
  * ScreenShareService: Responsible
  * 1. Establish a Socket connection
  * 2. Get screen frames from ImageReader
  * 3. Send after encoding
  * 4. Receive touch event send
  */
public class ScreenShareService {
    private MediaProjection mProjection;
    private ImageReader mImageReader;
    private Socket mSocket;
    private BufferedOutputStream mOut;
    private volatile boolean mRunning;
    private HandlerThread mEncodeThread;
    private Handler mEncodeHandler;
 
    public ScreenShareService(MediaProjection projection, ImageReader reader) {
        mProjection = projection;
        mImageReader = reader;
        // Create background thread processing encoding and network        mEncodeThread = new HandlerThread("EncodeThread");
        ();
        mEncodeHandler = new Handler(());
    }
 
    /** Start the service: Connect to the server and start capturing and sending */
    public void start() {
        mRunning = true;
        (this::connectAndShare);
    }
 
    /** Stop service */
    public void stop() {
        mRunning = false;
        try {
            if (mSocket != null) ();
            ();
        } catch (Exception ignored) {}
    }
 
    /** Establish Socket connection and loop capture sending */
    private void connectAndShare() {
        try {
            mSocket = new Socket("192.168.1.100", 8888);
            mOut = new BufferedOutputStream(());
            while (mRunning) {
                Image image = ();
                if (image != null) {
                    sendImageFrame(image);
                    ();
                }
            }
        } catch (Exception e) {
            ("ScreenShare", "Connect or send failed", e);
        }
    }
 
    /** Send image frame */
    private void sendImageFrame(Image image) throws Exception {
        // To convert Image to Bitmap and compress it into JPEG         plane = ()[0];
        ByteBuffer buffer = ();
        int width = (), height = ();
        Bitmap bmp = (width, height, .ARGB_8888);
        (buffer);
 
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        (, 40, baos);
        byte[] jpegData = ();
 
        // Write frame header: type=1, length, time stamp        (intToBytes(1));
        (intToBytes());
        (longToBytes(()));
        // Write image data        (jpegData);
        ();
    }
 
    /** Send touch events */
    public void sendTouchEvent(MotionEvent ev) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ((byte) ());
            (floatToBytes(()));
            (floatToBytes(()));
            (longToBytes(()));
            byte[] data = ();
 
            (intToBytes(2));
            (intToBytes());
            (longToBytes(()));
            (data);
            ();
        } catch (Exception ignored) {}
    }
 
    // …(byte/int/long/float and bytes convert each other, omitted)}
 
/**************************  **************************/
package ;
 
import ;
import ;
import ;
 
import ;
import ;
import ;
import ;
 
/*
  * RemoteControlService (Inheriting AccessibilityService)
  * 1. Start ServerSocket to receive the main control terminal connection
  * 2. Looping the frame header and data
  * 3. Distinguish image frames from event frames and process them
  */
public class RemoteControlService extends AccessibilityService {
    private ServerSocket mServerSocket;
    private Socket mClient;
    private BufferedInputStream mIn;
    private volatile boolean mRunning;
 
    @Override
    public void onServiceConnected() {
        ();
        new Thread(this::startServer).start();
    }
 
    /** Start the server socket */
    private void startServer() {
        try {
            mServerSocket = new ServerSocket(8888);
            mClient = ();
            mIn = new BufferedInputStream(());
            mRunning = true;
            while (mRunning) {
                handleFrame();
            }
        } catch (Exception e) {
            ();
        }
    }
 
    /** Process each data frame */
    private void handleFrame() throws Exception {
        byte[] header = new byte[12];
        (header);
        int type = bytesToInt(header, 0);
        int len = bytesToInt(header, 4);
        // long ts = bytesToLong(header, 8);
 
        byte[] payload = new byte[len];
        int read = 0;
        while (read < len) {
            read += (payload, read, len - read);
        }
 
        if (type == 1) {
            // Image frame: decode and render to SurfaceView            handleImageFrame(payload);
        } else if (type == 2) {
            // Touch Event: Simulation            handleTouchEvent(payload);
        }
    }
 
    /** Decode the JPEG and update the UI (communication via Broadcast or Handler) */
    private void handleImageFrame(byte[] data) {
        // … (Omitted, decode Bitmap and post to SurfaceView)    }
 
    /** parse according to the protocol and dispatchGesture */
    private void handleTouchEvent(byte[] data) {
        int action = data[0];
        float x = bytesToFloat(data, 1);
        float y = bytesToFloat(data, 5);
        // long t = bytesToLong(data, 9);
 
        Path path = new Path();
        (x, y);
         sd =
                new (path, 0, 1);
        dispatchGesture(new ().addStroke(sd).build(),
                        null, null);
    }
 
    @Override
    public void onInterrupt() {}
}

<!--  -->
<manifest xmlns:andro
    package="">
    <uses-permission android:name=".FOREGROUND_SERVICE"/>
    <uses-permission android:name=".SYSTEM_ALERT_WINDOW"/>
    <uses-permission android:name=".WRITE_EXTERNAL_STORAGE"/>
    <application
        android:allowBackup="true"
        android:label="ScreenCast">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name=""/>
                <category android:name=""/>
            </intent-filter>
        </activity>
        <service android:name=".RemoteControlService"
                 android:permission=".BIND_ACCESSIBILITY_SERVICE">
            <intent-filter>
                <action android:name=""/>
            </intent-filter>
            <meta-data
                android:name=""
                android:resource="@xml/accessibility_service_config"/>
        </service>
    </application>
</manifest>

<!-- activity_main.xml -->
<LinearLayout xmlns:andro
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="match_parent" android:gravity="center">
    <Button
        android:
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Start Screen Sharing"/>
    <Button
        android:
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Stop Service"/>
    <SurfaceView
        android:
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>
</LinearLayout>