Android屏幕共享-传输图片

Myth丶恋晨 2023-03-02 10:26 122阅读 0赞

# Android屏幕共享-传输图片 #

> 该篇主要讲解安卓与安卓之间如何截图传输，属于安卓屏幕共享的入门篇。适用场景：安卓屏幕共享工具类应用。

## 效果图 ##

效果图

![效果图][20200728220333215.gif]  
demo界面

![Demo][]

## 前言 ##

目前安卓屏幕共享的方式有很多种软件已经实现，究其根源，无非就是`采集-传输-播放`的过程，而安卓端无论是截图传输还是硬解码，也一定离不开核心类`MediaProjection`，它就是Google开放了视频录制的接口（屏幕采集的接口）。

比较优秀的软件举例：

*  TeamViewer
 *  向日葵
 *  Vysor

其中Vysor就是通过`adb`实现无root静默截图，然后传输，实现电脑控制手机。在整个屏幕共享的过程中，重点在于如何采集，采集到画质清晰内存又小的技术成为核心。

常用的安卓端采集技术有：

*  MediaProjection 实现截图
 *  MediaProjection 硬解码
 *  ffmpeg 软解码
 *  adb 实现无root截图

## 功能点 ##

1.  android5.0及以上免root截图
2.  安卓屏幕变化的时候采集
3.  多端共享拓展简单
4.  socket传输字节数组
5.  尽可能都使用原生代码实现

## 功能讲解 ##

### 截图 ###

随着安卓系统的不断升级，权限也越来越收紧，无root并且不连接数据线做不到静默截图，这里指截取不属于该app的区域。

*  在允许连接数据线的情况下，可以通过adb shell push 事先编译好的 dex 文件到手机中，实现静默截图。
 *  在没有链接数据线无root的情况下，只能显式的让用户有感知的进行截取。本篇截图使用的是 `MediaProjection`, 如下图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEzNjg1NTE_size_16_color_FFFFFF_t_70]

`MediaProjection` 是Android 5.0 开放的屏幕截图与录制视频的接口，是一个系统级的服务，在使用前需要动态申请权限，并在`onActivityResult`进行处理。  
eg:

/**
         * 申请截屏权限
         */
        private void tryStartScreenShot() {
            MediaProjectionManager mProjectionManager = (MediaProjectionManager) getSystemService(Context.MEDIA_PROJECTION_SERVICE);
            if (mProjectionManager != null) {
                startActivityForResult(mProjectionManager.createScreenCaptureIntent(), REQUEST_MEDIA_PROJECTION);
            }
        }

@Override
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            if (requestCode == REQUEST_MEDIA_PROJECTION && data != null) {
                if (resultCode == RESULT_OK) {
                    // 截屏的回调
                    ScreenShotHelper screenShotHelper = new ScreenShotHelper(this, resultCode, data, this);
                    screenShotHelper.startScreenShot();
                } else if (resultCode == RESULT_CANCELED) {
                    LogWrapper.d(TAG, "用户取消");
                }
            }
        }

在屏幕共享时，一直截图就会很费性能，如果在屏幕改变时进行截图就好了。  
刚好，在`ImageReader`中有`setOnImageAvailableListener`可以让我们方便的拿到屏幕变化的数据。eg：

/**
         * 屏幕发生变化时截取
         */
        private class ImageAvailableListener implements ImageReader.OnImageAvailableListener {
            @Override
            public void onImageAvailable(ImageReader reader) {
                try (Image image = reader.acquireLatestImage()) {
                    if (image != null) {
                      // todo 
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

#### 图片处理 ####

图片格式：

*  png：无损压缩图片格式，支持Alpha通道
 *  jpeg：有损压缩图片格式，不支持背景透明
 *  webp：“WebP 是 Android 4.2.1（API 级别 17）支持的较新图片格式。这种格式可为网络上的图片提供出色的无损压缩和有损压缩效果。使用 WebP，开发者可以创建更小、更丰富的图片。WebP 无损图片文件比 PNG 平均缩小了 26％。这些图片文件还支持透明度（也称为 Alpha 通道），只需增加 22% 的字节。  
    WebP 有损图片比采用等效 SSIM 质量指标的同等 JPG 图片缩小 25-34%。对于可以接受有损 RGB 压缩的情况，有损 WebP 也支持透明度，生成的文件大小通常比 PNG 小 3 倍。” – 出自谷歌官方文档

笔者曾尝试过webp格式的编码，大小确实降低了50%左右，但是编码耗时却长了100%，相当于用CPU换网速。这样看来webp并不适用该场景。

图片压缩：

*  压缩大小
 *  压缩图片质量

该Demo的代码中是将bitmap压缩到固定的大小

Server:

/**
         * 压缩图片 （压缩后不代表实际大小，有差异）
         *
         * @param bitmap    被压缩的图片
         * @param sizeLimit 大小限制  单位 k
         * @return 压缩后的图片
         */
        public static Bitmap compressBitmap(Bitmap bitmap, long sizeLimit) {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int quality = 90;
            bitmap.compress(Bitmap.CompressFormat.JPEG, quality, baos);
            // 循环判断压缩后图片是否超过限制大小
            while (baos.toByteArray().length / 1024 > sizeLimit) {
                baos.reset();
                bitmap.compress(Bitmap.CompressFormat.JPEG, quality, baos);
                quality -= 10;
            }
            return BitmapFactory.decodeStream(new ByteArrayInputStream(baos.toByteArray()), null, null);
        }

#### socket传输 ####

原生socket在发送大量数据时，会进行分包，接收的时候也就必须要合包；  
有一些第三方socket框架会帮助我们处理合包的操作，websocket则是在它的协议标准中处理了这个问题。  
所以该demo中选用了websocket进行通讯。拿到的截图的数据放进去就可以了。

import com.talon.screen.quick.util.LogWrapper;
    import org.java_websocket.WebSocket;
    import org.java_websocket.handshake.ClientHandshake;
    import org.java_websocket.server.WebSocketServer;
    
    import java.net.InetSocketAddress;
    
    /**
     * @author by Talon, Date on 2020-04-13.
     * note: websocket 服务端
     */
    public class MWebSocketServer extends WebSocketServer {
    
        private final String TAG = "MWebSocketServer";
    
        private WebSocket mWebSocket;
        private boolean mIsStarted = false;
        private CallBack mCallBack;
    
        public MWebSocketServer(int port, CallBack callBack) {
            super(new InetSocketAddress(port));
            this.mCallBack = callBack;
            setReuseAddr(true);
            setConnectionLostTimeout(5 * 1000);
        }
    
        @Override
        public void onOpen(WebSocket webSocket, ClientHandshake handshake) {
            LogWrapper.d(TAG, "有用户链接");
            mWebSocket = webSocket;
        }
    
        @Override
        public void onClose(WebSocket conn, int code, String reason, boolean remote) {
            LogWrapper.d(TAG, "有用户离开");
        }
    
        @Override
        public void onMessage(WebSocket conn, String message) {
            LogWrapper.e(TAG, "接收到消息：" + message);
        }
    
        @Override
        public void onError(WebSocket conn, Exception ex) {
            LogWrapper.e(TAG, "发生error:" + ex.toString());
        }
    
        @Override
        public void onStart() {
            updateServerStatus(true);
        }
    
        /**
         * 停止服务器
         */
        public void socketStop() {
            try {
                super.stop(100);
                updateServerStatus(false);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 发送二进制
         *
         * @param bytes
         */
        public void sendBytes(byte[] bytes) {
            if (mWebSocket != null)
                mWebSocket.send(bytes);
        }
    
        private void updateServerStatus(boolean isStarted) {
            mIsStarted = isStarted;
            LogWrapper.e(TAG, "mIsStarted:" + mIsStarted);
            // 回调
            if (mCallBack != null)
                mCallBack.onServerStatus(isStarted);
        }
    
        public boolean isStarted() {
            LogWrapper.e(TAG, "mIsStarted:" + mIsStarted);
            return mIsStarted;
        }
    
        public interface CallBack {
            void onServerStatus(boolean isStarted);
        }
    
    }

Client:

import com.talon.screen.quick.util.BitmapUtils;
    import com.talon.screen.quick.util.LogWrapper;
    
    import org.java_websocket.client.WebSocketClient;
    import org.java_websocket.handshake.ServerHandshake;
    
    import java.net.SocketException;
    import java.net.URI;
    import java.nio.ByteBuffer;
    
    /**
     * @author by Talon, Date on 2020-04-13.
     * note: websocket 客户端
     */
    public class MWebSocketClient extends WebSocketClient {
    
        private final String TAG = "MWebSocketClient";
    
        private boolean mIsConnected = false;
        private CallBack mCallBack;
    
        public MWebSocketClient(URI serverUri, CallBack callBack) {
            super(serverUri);
            this.mCallBack = callBack;
        }
    
        @Override
        public void onOpen(ServerHandshake handshakeData) {
            LogWrapper.e(TAG, "onOpen");
            updateClientStatus(true);
    
            try {
                getSocket().setReceiveBufferSize(5 * 1024 * 1024);
            } catch (SocketException e) {
                e.printStackTrace();
            }
    
    
        }
    
        @Override
        public void onMessage(String message) {
    
        }
    
        @Override
        public void onMessage(ByteBuffer bytes) {
            byte[] buf = new byte[bytes.remaining()];
            bytes.get(buf);
            if (mCallBack != null)
                mCallBack.onBitmapReceived(BitmapUtils.decodeImg(buf));
        }
    
        @Override
        public void onClose(int code, String reason, boolean remote) {
            updateClientStatus(false);
        }
    
        @Override
        public void onError(Exception ex) {
            updateClientStatus(false);
        }
    
        private void updateClientStatus(boolean isConnected) {
    
            mIsConnected = isConnected;
            LogWrapper.d(TAG, "mIsConnected:" + mIsConnected);
            // 回调
            if (mCallBack != null)
                mCallBack.onClientStatus(isConnected);
        }
    
        public boolean isConnected() {
            LogWrapper.d(TAG, "mIsConnected:" + mIsConnected);
            return mIsConnected;
        }
    
        public interface CallBack {
            void onClientStatus(boolean isConnected);
    
            void onBitmapReceived(Bitmap bitmap);
        }
    
    
    }

# Demo下载 #

[demo下载（github）][demo_github]  
[demo下载（CSDN）][demo_CSDN]

[20200728220333215.gif]: /images/20230208/d2225c01165e4c76a5c584720c95c927.png
[Demo]: /images/20230208/1c1c271dc6444740a0dc3aab58dda6c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEzNjg1NTE_size_16_color_FFFFFF_t_70]: /images/20230208/30f4f307b7d142279accf0cd9610ea7f.png
[demo_github]: https://github.com/tangfuOK/AndroidTangFu/tree/master/Android%E5%B1%8F%E5%B9%95%E5%85%B1%E4%BA%AB-%E4%BC%A0%E8%BE%93%E5%9B%BE%E7%89%87/AndroidScreenQuick
[demo_CSDN]: https://download.csdn.net/download/u011368551/12669058