Android 自定义截屏监听管理器

最新推荐文章于 2023-12-02 19:54:03 发布
最新推荐文章于 2023-12-02 19:54:03 发布
阅读量313 收藏
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33023933/article/details/118606877
版权 
 截屏判断依据: 监听媒体数据库的数据改变, 在有数据改变时获取最后
 插入数据库的一条图片数据, 如果符合以下规则, 则认为截屏了: 
 
 1. 时间判断, 图片的生成时间在开始监听之后, 并与当前时间相隔10秒内; 
 2. 尺寸判断, 图片的尺寸没有超过屏幕的尺寸; 
 3. 路径判断, 图片路径符合包含特定的关键词。

直接上代码：

 如何使用？

1.在你需要的地方注册监听可以是在Application中也可以是在Activity中都可以

 private void ListeningScreenshots() {
        ScreenShotListenManager manager = ScreenShotListenManager.newInstance(this);
        manager.setListener(new ScreenShotListenManager.OnScreenShotListener() {
            @Override
            public void onShot(String imagePath) {
            // 这个就是图片截图的位置，我把他存到本地下次可以用
                PreferenceUtils.putString(getApplicationContext(), Constants.SCREEN_SHOTS, imagePath);
            }
        });
        manager.startListen();
    }

2.记得不用的时候停止监听

manager.stopListen();

这个管理类就是截屏监听管理器的类

 

import android.content.Context;
import android.database.ContentObserver;
import android.database.Cursor;
import android.graphics.BitmapFactory;
import android.graphics.Point;
import android.net.Uri;
import android.os.Build;
import android.os.Handler;
import android.os.Looper;
import android.provider.MediaStore;
import android.text.TextUtils;
import android.util.Log;
import android.view.Display;
import android.view.WindowManager;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

/**
 * 截屏监听管理器 <br/><br/>
 * <p>
 * <p>
 * 截屏判断依据: 监听媒体数据库的数据改变, 在有数据改变时获取最后
 * 插入数据库的一条图片数据, 如果符合以下规则, 则认为截屏了: <br/>
 * <p>
 * 1. 时间判断, 图片的生成时间在开始监听之后, 并与当前时间相隔10秒内; <br/>
 * 2. 尺寸判断, 图片的尺寸没有超过屏幕的尺寸; <br/>
 * 3. 路径判断, 图片路径符合包含特定的关键词。<br/>
 * <p>
 * <p>
 * Demo:
 * <pre> {@code
 *
 *      // Requires Permission: android.permission.READ_EXTERNAL_STORAGE
 *
 *      ScreenShotListenManager manager = ScreenShotListenManager.newInstance(context);
 *
 *      manager.setListener(
 *          new OnScreenShotListener() {
 *              public void onShot(String imagePath) {
 *                  // do something
 *              }
 *          }
 *      );
 *
 *      manager.startListen();
 *      ...
 *      manager.stopListen();
 *
 * }</pre>
 *
 * 
 */
public class ScreenShotListenManager {

    private static final String TAG = "ScreenShotListenManager";

    /**
     * 读取媒体数据库时需要读取的列
     */
    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) {
                Log.d(TAG, "Screen Real Size: " + sScreenRealSize.x + " * " + sScreenRealSize.y);
            } else {
                Log.w(TAG, "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) {
                Log.e(TAG, "Deviant logic.");
                return;
            }
            if (!cursor.moveToFirst()) {
                Log.d(TAG, "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)) {
            Log.d(TAG, "ScreenShot: path = " + data + "; size = " + width + " * " + height
                    + "; date = " + dateTaken);
            if (mListener != null && !checkCallback(data)) {
                mListener.onShot(data);
            }
        } else {
            // 如果在观察区间媒体数据库有数据改变，又不符合截屏规则，则输出到 log 待分析
            Log.w(TAG, "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);
        }
    }

}

一只想颠覆世界的蚂蚁
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android App中监听系统截屏(截屏监听功能)
lplj717的博客
09-24 7698
功能需求： App内截屏监控功能，当发现用户在我们的app内进行了截屏操作时，进行对图片的二次操作，例如添加二维码，公司logo等一系列操作。 首先来app界面图及截屏监听图添加效果图 主要是利用内容观察者（ContentObserver）监听媒体数据库的变化，当数据库有变化时，获取最后插入的一条图片数据，如果该图片符合特定的规则，则认为被截屏了，下面看看截屏管理类 ScreenShotListenManager.java package com.test.base; import andro
Android系统截屏监听工具
qq_40789183的博客
06-06 663
Android系统截屏监听工具 做系统截屏通知的时候，找了很多资料，测试后发现要做挺多机型适配的，而且有时候会没有监听到，有时候又监听到多次，不能实现想要的效果。一下是最终的解决方案，已在足够多的手机品牌跟同一品牌不同版本上做过足够多的适配。 1、首先创建一个工具类 /** * 系统截屏监听工具，监听系统截屏，然后对截图进行处理 */ public class ScreenShot { private static final String TAG = "ScreenShot"; pri
Android监听用户的截屏、投屏、录屏行为
最新发布
进击的小怪兽
12-02 5305
探索Android开发中监听用户的截屏+录屏+投屏行为
Android监听系统截屏的坑
落叶挽歌的博客
07-10 3151
最近有做在监听系统截屏操作，然后对截屏的图片获取到，再在其底部加入二维码或者其他信息生成分享海报。这里面最不好做的就是监听系统截屏的操作了，系统没有提供相关api，所以得靠“骚操作”，目前业内主流的操作，像这篇博文写的那样：https://blog.csdn.net/xietansheng/article/details/52692163 通过 自定义媒体内容观察者内部类，去观察媒体数据库的改变，...
Android监听截屏
weixin_47933729的博客
06-13 3446
Android系统没有提供默认的截屏事件监听方式，需要开发者自己想办法实现。查看了网上推荐的实现方式，主要是通过内容观察者（ContentObserver）监听媒体数据库的变化，根据内容名称（路径）中是否包含关键字，判断是否为截屏事件。 关键字： 第一步：对ContentResolver添加内、外存储变化监听； 第二步：当内容观察者（ContentObserver）监听到变化时，会调用onChange方法，此时，我们使用ContentResolver去查询最新的一条数据； 需要注意的是，查询外部存储一定要有
Android 监听系统截屏操作
qq_40959750的博客
01-29 1744
在Android App中监听系统截屏功能，没有系统标准的监听器或者api可以调用，需要自己实现。针对这个需求，目前大部分实现方案是监听系统的媒体数据库。
Android截屏事件监听
王三的专栏
12-23 1万+
Android系统没有直接对截屏事件监听的接口，也没有广播，只能自动动手丰衣足食！
Android 自定义区域截图实现
09-29
综上所述，实现Android自定义区域截图涉及到了`View`的自定义绘制、触摸事件处理、`Bitmap`操作以及权限管理等多个方面。通过巧妙地结合这些技术，我们可以为用户提供更加灵活和个性化的截图功能。在实际开发中，...
android截屏监听
03-14
总之，虽然Android系统没有提供官方的截屏监听API，但通过BroadcastReceiver和自定义的逻辑，开发者仍然可以实现对用户截屏行为的监测。不过，由于兼容性和隐私考虑，这种方式可能需要根据不同的设备和系统版本进行...
详解Android截屏事件监听
01-20
由于厂商自定义Android系统的多样性，再加上快捷键的不同以及第三方应用，监听截屏快捷键这事基本不靠谱，可以直接忽略。 本文使用的测试手机，一加2（One Plus 2)。 2. FileObserver 添加权限： <uses-...
ScreenshotListener:一个Android库，用于检测用户何时拍摄了您的应用程序的屏幕截图
05-09
屏幕截图监听器 它是什么？ 一个Android库，用于检测用户何时拍摄了您的应用程序的屏幕截图。 用法 屏幕快照侦听器位于jCenter Maven存储库中 在您的build.gradle ： dependencies { compile ' com.esc861.screenshotlistener:screenshotlistener:1.0.3 ' } 在想要监听屏幕截图的活动（或任何课程）中 ScreenshotListener listener; @Override protected void onCreate( Bundle savedInstanceState) { super . onCreate(savedInstanceState); setContentView( R . layout . activity_main); listener = new
android截图事件监听的原理与实现
01-20
Android系统没有对用户截屏行为提供回调的api，所以我们只能走野路子来获取用户是否截屏了。一般大家都会采用如下两种方法 1.监听截屏图片所在目录变化（FileObserver） 2.监听媒体库的变化（ContentObserver）  上面两种方法均不是万能的，需要结合使用才能达到良好的效果，首先看看如何监控目录 在android中，我们可以通过FileObserver来监听目录变化，先来看看如何使用 private static final File DIRECTORY_PICTURES = new File(Environment.getExternalStorageDire
ScreenShotListenManager.java
06-28
Android开发用于监听手机截屏帮助类，可用于意见反馈的类似功能辅助使用
Android 14 新 API：直接监听截屏操作，不用再观察媒体文件
chuyouyinghe的专栏
04-19 1045
ScreenCaptureCallback 监听截屏 API 的使用简单、清晰，以后不需要再通过监听媒体文件的变化等逻辑来迂回实现，采用官方的方式去探测用户的截屏操作并按照文件读写的规范去提取文件。但需要留意 adb、代码、AS 等方式发起的截屏无法通过该 API 监听得到，笔者以为这些不属于用户操作，没有必要纳入到监听范围中。另外，这个监听 API 并不是 Application 级别的，每个目标 Activity 都得注册，所以可以考虑在 BaseActivity 中完成 API 的注册和注销。
安卓截屏监听
m0_72345017的博客
10-11 1112
安卓系统并没有提供原生的接口，所以就需要自己去实现。各种定制系统截图方式五花八门，对截图按键的监听并不容易。最通用的方式也就是对图库进行监听，如果在特定时间内增加了符合规则的图片，则判定用户进行了截图操作。当有特殊需求时，例如，某个页面禁止截屏，或者当用户截屏时，提示用户需要意见反馈。就需要用到截屏监听。2.、 截图监听器ScreenShotListenManager。在6.0及以上系统需要动态申请权限。
Android 截屏监听方案
广岛冰盐的博客
05-23 2070
截屏监听方案
Android 系统 截屏监听 的 原理与实现
热门推荐
谢TS的博客
10-16 3万+
Android系统并没有提供截屏通知相关的API，需要我们自己利用系统能提供的相关特性变通实现。Android系统有一个媒体数据库，每拍一张照片，或使用系统截屏截取一张图片，都会把这张图片的详细信息加入到这个媒体数据库，并发出内容改变通知，我们可以利用内容观察者（ContentObserver）监听媒体数据库的变化，当数据库有变化时，获取最后插入的一条图片数据，如果该图片符合特定的规则，则认为被截屏了。
Android控件布局实验：王凯祺的RelativeLayout与自定义Spinner实现
在这个部分，学生需要实现两个关键功能：一是利用下拉框Spinner，起初通过静态数组(arrays.xml)展示选项，然后实现自定义功能，改变字体大小和颜色，参考了ListViewArray-自定义列表模式。这涉及到XML布局文件中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值