詳細講解安卓截屏監聽操作

需求

項目中有時會遇到監聽用戶截屏操作的需求，應用場景也比較豐富。

eg. 1: 某個隱私頁面禁止截屏，當發現用戶截屏後，刪除該截屏文件；

eg. 2: 當用戶截屏時，可能是需要進行分享，意見反饋等操作，此時進行彈窗提示，方便用戶操作（支付寶就有類似功能）。

分析

安卓系統裏面並沒有提供監聽截屏的接口，所以就需要自己去實現（不然也不會有本文）。

• 一般來說，對於某一操作的監聽，第一直覺就是監聽對應按鍵的點擊事件。但是各種定製系統的截圖方式五花八門，對截圖按鍵的監聽並不容易。

  截圖方式 ：

  eg.1 快捷組合鍵截屏 ：【電源鍵】+【音量-】；【home鍵】+【音量-】；【電源鍵】+【Home鍵】……

  eg.2 快捷菜單的截屏按鍵

  eg.3 藉助其它軟件截屏：例如QQ輔助功能中的搖一搖截屏；豌豆莢，360手機助手等通過usb調試的截屏 ……

  eg.4 定製系統的其它截屏方式：三指下滑截屏 ；長按指紋鍵截屏 ……

  綜上，此路不通。

• 既然無法通過按鍵點擊判斷出截屏操作，那就只好在生成截屏圖片後進行判斷。

  也就是 【對圖庫進行監聽】，如果 【特定時間】 增加了 【符合規則的圖片】 ，則判定用戶進行了截圖操作。

具體操作

1. 權限

因爲對圖庫文件進行監聽，需要用到內存讀的權限，所以需要在 AndroidManifest.xml 中添加權限:

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

內存讀寫權限屬於高危權限，在安卓6.0及以上的系統還需要進行動態權限的申請。在對應頁面的Activity中進行權限判斷以及申請。

if (Build.VERSION.SDK_INT > 22) {
    List<String> permissionList = new ArrayList<>();
    // 檢查是否有內存權限
    if (ContextCompat.checkSelfPermission(ScreenshotsActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
        permissionList.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
    } else {
    // 開始截圖監聽
        doStart();
    }
    if (permissionList != null && (permissionList.size() != 0)) {
        ActivityCompat.requestPermissions(ScreenshotsActivity.this, permissionList.toArray(new String[permissionList.size()]), 0);
    }

2. 創建截圖監聽器

創建截圖監聽器文件，當判斷用戶進行截圖操作之後，以接口回調的方式進行處理。

那麼如何判斷進行了截圖操作呢？這就又迴歸到分析中的結論：

​ 【監聽圖庫】，若 【特定時間內】增加【符合規則的圖片】，則判定進行了截圖操作。

2.1 監聽圖庫

我們要對圖庫進行監聽，需要讀取媒體數據庫。那麼需要監聽讀取的列如下：

/**
 * 讀取媒體數據庫時需要讀取的列
 */
private static final String[] MEDIA_PROJECTIONS = {
    MediaStore.Images.ImageColumns.DATA,
        MediaStore.Images.ImageColumns.DATE_TAKEN,
};

/**
 * 讀取媒體數據庫時需要讀取的列, 其中 WIDTH 和 HEIGHT 字段在 API 16 以後纔有
 */
private static final String[] MEDIA_PROJECTIONS_API_16 = {
    MediaStore.Images.ImageColumns.DATA,
    MediaStore.Images.ImageColumns.DATE_TAKEN,
    MediaStore.Images.ImageColumns.WIDTH,
    MediaStore.Images.ImageColumns.HEIGHT,
};

圖庫監聽代碼如下：

        Cursor cursor = null;
            // 數據改變時查詢數據庫中最後加入的一條數據
            cursor = mContext.getContentResolver().query(
                    contentUri,
                    Build.VERSION.SDK_INT < 16 ? MEDIA_PROJECTIONS : MEDIA_PROJECTIONS_API_16,
                    null,
                    null,
                    MediaStore.Images.ImageColumns.DATE_ADDED + " desc limit 1"
            );

            if (cursor == null) {
                LogUtils.e("Deviant logic.");
                return;
            }
            if (!cursor.moveToFirst()) {
                LogUtils.e("Cursor no data.");
                return;
            }

            // 獲取各列的索引
            int dataIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
            int dateTakenIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATE_TAKEN);
            int widthIndex = -1;
            int heightIndex = -1;
            if (Build.VERSION.SDK_INT >= 16) {
                widthIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.WIDTH);
                heightIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.HEIGHT);
            }

            // 獲取行數據
            String data = cursor.getString(dataIndex);
            long dateTaken = cursor.getLong(dateTakenIndex);
            int width = 0;
            int height = 0;
            if (widthIndex >= 0 && heightIndex >= 0) {
                width = cursor.getInt(widthIndex);
                height = cursor.getInt(heightIndex);
            } else {
                // API 16 之前, 寬高要手動獲取
                Point size = getImageSize(data);
                width = size.x;
                height = size.y;
            }

            // 處理獲取到的第一行數據
            handleMediaRowData(data, dateTaken, width, height);

2.2 特定時間內

所謂特定時間內，即爲監聽增加開始和結束的方法。可以通過兩個方法進行時間的控制。

    /**
     * 啓動監聽
     */
    public void startListen() {
        assertInMainThread();

        sHasCallbackPaths.clear();

        // 記錄開始監聽的時間戳
        mStartListenTime = System.currentTimeMillis();

        // 創建內容觀察者
        mInternalObserver = new MediaContentObserver(MediaStore.Images.Media.INTERNAL_CONTENT_URI, mUiHandler);
        mExternalObserver = new MediaContentObserver(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, mUiHandler);

        // 註冊內容觀察者
        mContext.getContentResolver().registerContentObserver(
                MediaStore.Images.Media.INTERNAL_CONTENT_URI,
                false,
                mInternalObserver
        );
        mContext.getContentResolver().registerContentObserver(
                MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                false,
                mExternalObserver
        );
    }

    /**
     * 停止監聽
     */
    public void stopListen() {
        assertInMainThread();

        // 註銷內容觀察者
        if (mInternalObserver != null) {
            try {
              mContext.getContentResolver().unregisterContentObserver(mInternalObserver);
            } catch (Exception e) {
                e.printStackTrace();
            }
            mInternalObserver = null;
        }
        if (mExternalObserver != null) {
            try {
              mContext.getContentResolver().unregisterContentObserver(mExternalObserver);
            } catch (Exception e) {
                e.printStackTrace();
            }
            mExternalObserver = null;
        }

        // 清空數據
        mStartListenTime = 0;
        sHasCallbackPaths.clear();
    }

2.3 符合規則的圖片

判斷是否符合規則，首先要先定製一個規則。判斷截圖，一般可以從以下幾個方面進行判斷：

• 時間判斷：

  • 也就是我們2.2中所說的特定時間內，如果圖片的創建時間不在其中，則不認定爲截圖；

  • 爲了提高容錯性，也可以對時間限制進行適當放鬆；

    // 如果加入數據庫的時間在開始監聽之前, 或者與當前時間相差大於10秒, 則認爲當前沒有截屏
    if (dateTaken < mStartListenTime || (System.currentTimeMillis() - dateTaken) > 10 * 1000) {
        return false;
    }
    

• 尺寸判斷：

  • 屏幕是有固定分辨率的，一般來說，屏幕截圖的分辨率也應該小於屏幕的分辨率；

  • 但是如果是長截圖，則圖片的高度會超出屏幕；（是否判斷長截圖，根據自己需求制定）

    // 尺寸判斷
    if (sScreenRealSize != null) {
        // 如果圖片尺寸超出屏幕, 則認爲當前沒有截屏（此處沒有判斷長截屏）
        if (!((width <= sScreenRealSize.x && height <= sScreenRealSize.y)
                || (height <= sScreenRealSize.x && width <= sScreenRealSize.y))) {
            return false;
        }
    }
    

• 路徑名稱判斷

  • 通過統計來看，截圖文件的圖片絕大多數的情況下都會包含screenshot或者類似的關鍵字。我們在這裏進行圖片路徑的判斷。

  • 經過整理得出以下關鍵字，已經涵蓋絕大多數情況的系統機型截圖：

    // 此處忽略大小寫，後續判斷時，統一轉換爲小寫即可
    private static final String[] KEYWORDS = {
            "screenshot", "screen_shot", "screen-shot", "screen shot",
            "screencapture", "screen_capture", "screen-capture", "screen capture",
            "screencap", "screen_cap", "screen-cap", "screen cap"
    };
    

  • 判斷是否包含關鍵字

    // 將路徑轉換爲小寫
    data = data.toLowerCase();
    // 判斷圖片路徑是否含有指定的關鍵字之一, 如果有, 則認爲當前截屏了
    for (String keyWork : KEYWORDS) {
        if (data.contains(keyWork)) {
            return true;
        }
    }
    

3. 調用

完成上述操作之後，即可在響應頁面開始監聽，並進行響應操作

manager = ScreenShotListenManager.newInstance(ScreenshotsActivity.this);
manager.setListener(
        new ScreenShotListenManager.OnScreenShotListener() {
            public void onShot(String imagePath) {
                // do something            

        }
    }
);

完整代碼：

ScreenShotListenManager.java

    /**
     * 讀取媒體數據庫時需要讀取的列
     */
    private static final String[] MEDIA_PROJECTIONS = {
            MediaStore.Images.ImageColumns.DATA,
            MediaStore.Images.ImageColumns.DATE_TAKEN,
    };
    /**
     * 讀取媒體數據庫時需要讀取的列, 其中 WIDTH 和 HEIGHT 字段在 API 16 以後纔有
     */
    private static final String[] MEDIA_PROJECTIONS_API_16 = {
            MediaStore.Images.ImageColumns.DATA,
            MediaStore.Images.ImageColumns.DATE_TAKEN,
            MediaStore.Images.ImageColumns.WIDTH,
            MediaStore.Images.ImageColumns.HEIGHT,
    };

    /**
     * 截屏依據中的路徑判斷關鍵字
     */
    private static final String[] KEYWORDS = {
            "screenshot", "screen_shot", "screen-shot", "screen shot",
            "screencapture", "screen_capture", "screen-capture", "screen capture",
            "screencap", "screen_cap", "screen-cap", "screen cap"
    };

    private static Point sScreenRealSize;

    /**
     * 已回調過的路徑
     */
    private final List<String> sHasCallbackPaths = new ArrayList<String>();

    private Context mContext;

    private OnScreenShotListener mListener;

    private long mStartListenTime;

    /**
     * 內部存儲器內容觀察者
     */
    private MediaContentObserver mInternalObserver;

    /**
     * 外部存儲器內容觀察者
     */
    private MediaContentObserver mExternalObserver;

    /**
     * 運行在 UI 線程的 Handler, 用於運行監聽器回調
     */
    private final Handler mUiHandler = new Handler(Looper.getMainLooper());

    private ScreenShotListenManager(Context context) {
        if (context == null) {
            throw new IllegalArgumentException("The context must not be null.");
        }
        mContext = context;

        // 獲取屏幕真實的分辨率
        if (sScreenRealSize == null) {
            sScreenRealSize = getRealScreenSize();
            if (sScreenRealSize != null) {
                LogUtils.e("Screen Real Size: " + sScreenRealSize.x + " * " + sScreenRealSize.y);
            } else {
                LogUtils.e("Get screen real size failed.");
            }
        }
    }

    public static ScreenShotListenManager newInstance(Context context) {
        assertInMainThread();
        return new ScreenShotListenManager(context);
    }

    /**
     * 啓動監聽
     */
    public void startListen() {
        assertInMainThread();

        sHasCallbackPaths.clear();

        // 記錄開始監聽的時間戳
        mStartListenTime = System.currentTimeMillis();

        // 創建內容觀察者
        mInternalObserver = new MediaContentObserver(MediaStore.Images.Media.INTERNAL_CONTENT_URI, mUiHandler);
        mExternalObserver = new MediaContentObserver(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, mUiHandler);

        // 註冊內容觀察者
        mContext.getContentResolver().registerContentObserver(
                MediaStore.Images.Media.INTERNAL_CONTENT_URI,
                false,
                mInternalObserver
        );
        mContext.getContentResolver().registerContentObserver(
                MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                false,
                mExternalObserver
        );
    }

    /**
     * 停止監聽
     */
    public void stopListen() {
        assertInMainThread();

        // 註銷內容觀察者
        if (mInternalObserver != null) {
            try {
              mContext.getContentResolver().unregisterContentObserver(mInternalObserver);
            } catch (Exception e) {
                e.printStackTrace();
            }
            mInternalObserver = null;
        }
        if (mExternalObserver != null) {
            try {
              mContext.getContentResolver().unregisterContentObserver(mExternalObserver);
            } catch (Exception e) {
                e.printStackTrace();
            }
            mExternalObserver = null;
        }

        // 清空數據
        mStartListenTime = 0;
        sHasCallbackPaths.clear();
    }

    /**
     * 處理媒體數據庫的內容改變
     */
    private void handleMediaContentChange(Uri contentUri) {
        Cursor cursor = null;
        try {
            // 數據改變時查詢數據庫中最後加入的一條數據
            cursor = mContext.getContentResolver().query(
                    contentUri,
                    Build.VERSION.SDK_INT < 16 ? MEDIA_PROJECTIONS : MEDIA_PROJECTIONS_API_16,
                    null,
                    null,
                    MediaStore.Images.ImageColumns.DATE_ADDED + " desc limit 1"
            );

            if (cursor == null) {
                LogUtils.e("Deviant logic.");
                return;
            }
            if (!cursor.moveToFirst()) {
                LogUtils.e("Cursor no data.");
                return;
            }

            // 獲取各列的索引
            int dataIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
            int dateTakenIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATE_TAKEN);
            int widthIndex = -1;
            int heightIndex = -1;
            if (Build.VERSION.SDK_INT >= 16) {
                widthIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.WIDTH);
                heightIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.HEIGHT);
            }

            // 獲取行數據
            String data = cursor.getString(dataIndex);
            long dateTaken = cursor.getLong(dateTakenIndex);
            int width = 0;
            int height = 0;
            if (widthIndex >= 0 && heightIndex >= 0) {
                width = cursor.getInt(widthIndex);
                height = cursor.getInt(heightIndex);
            } else {
                // API 16 之前, 寬高要手動獲取
                Point size = getImageSize(data);
                width = size.x;
                height = size.y;
            }

            // 處理獲取到的第一行數據
            handleMediaRowData(data, dateTaken, width, height);

        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            if (cursor != null && !cursor.isClosed()) {
                cursor.close();
            }
        }
    }

    private Point getImageSize(String imagePath) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(imagePath, options);
        return new Point(options.outWidth, options.outHeight);
    }

    /**
     * 處理獲取到的一行數據
     */
    private void handleMediaRowData(String data, long dateTaken, int width, int height) {
        if (checkScreenShot(data, dateTaken, width, height)) {
            LogUtils.e("ScreenShot: path = " + data + "; size = " + width + " * " + height
                    + "; date = " + dateTaken);
            if (mListener != null && !checkCallback(data)) {
                mListener.onShot(data);
            }
        } else {
            // 如果在觀察區間媒體數據庫有數據改變，又不符合截屏規則，則輸出到 log 待分析
            LogUtils.e("Media content changed, but not screenshot: path = " + data
                    + "; size = " + width + " * " + height + "; date = " + dateTaken);
        }
    }

    /**
     * 判斷指定的數據行是否符合截屏條件
     */
    private boolean checkScreenShot(String data, long dateTaken, int width, int height) {
        /*
         * 判斷依據一: 時間判斷
         */
        // 如果加入數據庫的時間在開始監聽之前, 或者與當前時間相差大於10秒, 則認爲當前沒有截屏
        if (dateTaken < mStartListenTime || (System.currentTimeMillis() - dateTaken) > 10 * 1000) {
            return false;
        }

        /*
         * 判斷依據二: 尺寸判斷
         */
        if (sScreenRealSize != null) {
            // 如果圖片尺寸超出屏幕, 則認爲當前沒有截屏
            if (!((width <= sScreenRealSize.x && height <= sScreenRealSize.y)
                    || (height <= sScreenRealSize.x && width <= sScreenRealSize.y))) {
                return false;
            }
        }

        /*
         * 判斷依據三: 路徑判斷
         */
        if (TextUtils.isEmpty(data)) {
            return false;
        }
        data = data.toLowerCase();
        // 判斷圖片路徑是否含有指定的關鍵字之一, 如果有, 則認爲當前截屏了
        for (String keyWork : KEYWORDS) {
            if (data.contains(keyWork)) {
                return true;
            }
        }

        return false;
    }

    /**
     * 判斷是否已回調過, 某些手機ROM截屏一次會發出多次內容改變的通知; <br/>
     * 刪除一個圖片也會發通知, 同時防止刪除圖片時誤將上一張符合截屏規則的圖片當做是當前截屏.
     */
    private boolean checkCallback(String imagePath) {
        if (sHasCallbackPaths.contains(imagePath)) {
            return true;
        }
        // 大概緩存15~20條記錄便可
        if (sHasCallbackPaths.size() >= 20) {
            for (int i = 0; i < 5; i++) {
                sHasCallbackPaths.remove(0);
            }
        }
        sHasCallbackPaths.add(imagePath);
        return false;
    }

    /**
     * 獲取屏幕分辨率
     */
    private Point getRealScreenSize() {
        Point screenSize = null;
        try {
            screenSize = new Point();
            WindowManager windowManager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
            Display defaultDisplay = windowManager.getDefaultDisplay();
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                defaultDisplay.getRealSize(screenSize);
            } else {
                try {
                    Method mGetRawW = Display.class.getMethod("getRawWidth");
                    Method mGetRawH = Display.class.getMethod("getRawHeight");
                    screenSize.set(
                            (Integer) mGetRawW.invoke(defaultDisplay),
                            (Integer) mGetRawH.invoke(defaultDisplay)
                    );
                } catch (Exception e) {
                    screenSize.set(defaultDisplay.getWidth(), defaultDisplay.getHeight());
                    e.printStackTrace();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return screenSize;
    }

    /**
     * 設置截屏監聽器
     */
    public void setListener(OnScreenShotListener listener) {
        mListener = listener;
    }

    public static interface OnScreenShotListener {
        public void onShot(String imagePath);
    }

    private static void assertInMainThread() {
        if (Looper.myLooper() != Looper.getMainLooper()) {
            StackTraceElement[] elements = Thread.currentThread().getStackTrace();
            String methodMsg = null;
            if (elements != null && elements.length >= 4) {
                methodMsg = elements[3].toString();
            }
            throw new IllegalStateException("Call the method must be in main thread: " + methodMsg);
        }
    }

    /**
     * 媒體內容觀察者(觀察媒體數據庫的改變)
     */
    private class MediaContentObserver extends ContentObserver {

        private Uri mContentUri;

        public MediaContentObserver(Uri contentUri, Handler handler) {
            super(handler);
            mContentUri = contentUri;
        }

        @Override
        public void onChange(boolean selfChange) {
            super.onChange(selfChange);
            handleMediaContentChange(mContentUri);
        }
    }

3、 調用

manager = ScreenShotListenManager.newInstance(ScreenshotsActivity.this);
manager.setListener(
        new ScreenShotListenManager.OnScreenShotListener() {
            public void onShot(String imagePath) {
                // do something
               
            }
        }
);

參考：
https://blog.csdn.net/xietansheng/article/details/52692163