精华内容
下载资源
问答
  • Android系统截屏

    2014-11-26 10:10:26
    简单的Android系统截屏,包括状态栏,需要root权限。
  • Android系统截屏功能提取Demo

    千次下载 热门讨论 2014-09-15 21:34:58
    Android系统截屏功能提取的演示代码,文章在这里http://blog.csdn.net/xu_fu/article/details/39268771
  • 监听Android系统截屏

    千次阅读 热门讨论 2019-06-10 11:00:28
    Android系统有一个媒体数据库,每拍一张照片,或使用系统截屏截取一张图片,都会把这张图片的详细信息加入到这个媒体数据库,并发出内容改变通知,我们可以利用内容观察者(ContentObserver)监听媒体数据库的...

    1. 原理

    因为Android系统没有提供截屏的相关API,所以需要我们自己去实现。国内的Android手机都是使用定制系统的,截图方式五花八门,采用对截图按键的监听的方案并不合适。Android系统有一个媒体数据库,每拍一张照片,或使用系统截屏截取一张图片,都会把这张图片的详细信息加入到这个媒体数据库,并发出内容改变通知,我们可以利用内容观察者(ContentObserver)监听媒体数据库的变化,当数据库有变化时,获取最后插入的一条图片数据,如果该图片符合特定的规则,则认为截屏了。

    需要ContentObserver监听的资源URI:

    • 内部存储器内容:MediaStore.Images.Media.INTERNAL_CONTENT_URI
    • 外部存储器内容:MediaStore.Images.Media.EXTERNAL_CONTENT_URI

    2. 具体实现

    根据以上原理,我们可以封装一个工具类来处理系统截屏,具体代码如下:

    package com.fantasy.blogdemo.screenshot;
    
    import android.content.ContentResolver;
    import android.content.Context;
    import android.database.ContentObserver;
    import android.database.Cursor;
    import android.net.Uri;
    import android.os.Handler;
    import android.os.HandlerThread;
    import android.provider.MediaStore;
    import android.support.annotation.NonNull;
    import android.util.Log;
    
    /**
     * 系统截屏监听工具,监听系统截屏,然后对截图进行处理
     * <pre>
     *     author  : Fantasy
     *     version : 1.0, 2019-06-05
     *     since   : 1.0, 2019-06-05
     * </pre>
     */
    public class ScreenShot {
        private static final String TAG = "ScreenShot";
        private static final String[] MEDIA_PROJECTIONS = {
                MediaStore.Images.ImageColumns.DATA,
                MediaStore.Images.ImageColumns.DATE_TAKEN,
                MediaStore.Images.ImageColumns.DATE_ADDED
        };
    
        /**
         * 截屏依据中的路径判断关键字
         */
        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 ContentResolver mContentResolver;
        private CallbackListener mCallbackListener;
        private MediaContentObserver mInternalObserver;
        private MediaContentObserver mExternalObserver;
        private static ScreenShot mInstance;
    
        private ScreenShot() {
        }
    
        /**
         * 获取 ScreenShot 对象
         *
         * @return ScreenShot对象
         */
        public static ScreenShot getInstance() {
            if (mInstance == null) {
                synchronized (ScreenShot.class) {
                    mInstance = new ScreenShot();
                }
            }
            return mInstance;
        }
    
        /**
         * 注册
         *
         * @param context          上下文
         * @param callbackListener 回调监听
         */
        public void register(Context context, CallbackListener callbackListener) {
            mContentResolver = context.getContentResolver();
            mCallbackListener = callbackListener;
    
            HandlerThread handlerThread = new HandlerThread(TAG);
            handlerThread.start();
            Handler handler = new Handler(handlerThread.getLooper());
    
            mInternalObserver = new MediaContentObserver(MediaStore.Images.Media.INTERNAL_CONTENT_URI, handler);
            mExternalObserver = new MediaContentObserver(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, handler);
    
            mContentResolver.registerContentObserver(MediaStore.Images.Media.INTERNAL_CONTENT_URI,
                    false, mInternalObserver);
            mContentResolver.registerContentObserver(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                    false, mExternalObserver);
        }
    
        /**
         * 注销
         */
        public void unregister() {
            if (mContentResolver != null) {
                mContentResolver.unregisterContentObserver(mInternalObserver);
                mContentResolver.unregisterContentObserver(mExternalObserver);
            }
        }
    
        private void handleMediaContentChange(Uri uri) {
            Cursor cursor = null;
            try {
                // 数据改变时,查询数据库中最后加入的一条数据
                cursor = mContentResolver.query(uri, MEDIA_PROJECTIONS, null, null,
                        MediaStore.Images.ImageColumns.DATE_ADDED + " desc limit 1");
                if (cursor == null) {
                    return;
                }
                if (!cursor.moveToFirst()) {
                    return;
                }
                int dataIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
                int dateAddedIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATE_ADDED);
                // 处理获取到的第一行数据
                handleMediaRowData(cursor.getString(dataIndex), cursor.getLong(dateAddedIndex));
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (cursor != null && !cursor.isClosed()) {
                    cursor.close();
                }
            }
        }
    
        /**
         * 处理监听到的资源
         */
        private void handleMediaRowData(String path, long dateAdded) {
            long duration = 0;
            long step = 100;
    
            // 发现个别手机会自己修改截图文件夹的文件,截屏功能会误以为是用户在截屏操作,进行捕获,所以加了一个时间判断
            if (!isTimeValid(dateAdded)) {
                Log.d(TAG, "图片插入时间大于1秒,不是截屏");
                return;
            }
    
            // 设置最大等待时间为500ms,因为魅族的部分手机保存截图有延迟
            while (!checkScreenShot(path) && duration <= 500) {
                try {
                    duration += step;
                    Thread.sleep(step);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
    
            if (checkScreenShot(path)) {
                if (mCallbackListener != null) {
                    mCallbackListener.onShot(path);
                }
            }
        }
    
        /**
         * 判断时间是否合格,图片插入时间小于1秒才有效
         */
        private boolean isTimeValid(long dateAdded) {
            return Math.abs(System.currentTimeMillis() / 1000 - dateAdded) <= 1;
        }
    
        private boolean checkScreenShot(String path) {
            if (path == null) {
                return false;
            }
            path = path.toLowerCase();
            for (String keyword : KEYWORDS) {
                if (path.contains(keyword)) {
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 媒体内容观察者
         */
        private class MediaContentObserver extends ContentObserver {
            private Uri mUri;
    
            MediaContentObserver(Uri uri, Handler handler) {
                super(handler);
                mUri = uri;
            }
    
            @Override
            public void onChange(boolean selfChange) {
                super.onChange(selfChange);
                //Log.d("ScreenShot", "图片数据库发生变化:" + selfChange);
                handleMediaContentChange(mUri);
            }
        }
    
        /**
         * 回调监听器
         */
        public interface CallbackListener {
            /**
             * 截屏
             *
             * @param path 图片路径
             */
            void onShot(String path);
        }
    
    }
    

    3. 使用方式

    在 AndroidManifest.xml 中添加权限:

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

    在Android 6.0及以上系统需要动态申请权限,这里不提供代码。有兴趣想知道我怎么实现的,可以看看我提供的demo(demo的访问地址在文末提供)。

    获取实例:

    private ScreenShot mScreenShot = ScreenShot.getInstance();

    注册并处理截屏:

    mScreenShot.register(mContext, new ScreenShot.CallbackListener() {
        @Override
        public void onShot(String path) {
            // 捕获到系统截屏,path是截屏的绝对路径
        }
    });

    不需要监听系统截屏的话,需要取消注册:

    mScreenShot.unregister();

    好了,以上就是 ScreenShot 工具类的使用方式。想看完整代码的同学,可以到我的GitHub上面看看BlogDemo

     

    如果想进一步交流和学习的同学,可以加一下QQ群哦!

    展开全文
  • Android系统截屏功能提取.pdf
  • Android 系统 截屏监听 的 原理与实现

    万次阅读 多人点赞 2016-10-16 18:35:39
    Android系统有一个媒体数据库,每拍一张照片,或使用系统截屏截取一张图片,都会把这张图片的详细信息加入到这个媒体数据库,并发出内容改变通知,我们可以利用内容观察者(ContentObserver)监听媒体数据库的变化,...

    本文链接: https://xiets.blog.csdn.net/article/details/52692163

    1. 原理

    Android系统并没有提供截屏通知相关的API,需要我们自己利用系统能提供的相关特性变通实现。Android系统有一个媒体数据库,每拍一张照片,或使用系统截屏截取一张图片,都会把这张图片的详细信息加入到这个媒体数据库,并发出内容改变通知,我们可以利用内容观察者(ContentObserver)监听媒体数据库的变化,当数据库有变化时,获取最后插入的一条图片数据,如果该图片符合特定的规则,则认为被截屏了。

    需要ContentObserver监听的资源URI:

    • MediaStore.Images.Media.INTERNAL_CONTENT_URI
    • MediaStore.Images.Media.EXTERNAL_CONTENT_URI

    读取外部存储器资源,需要添加权限:

    • android.permission.READ_EXTERNAL_STORAGE

    2. 截屏判断依据

    ContentObserver监听到媒体数据库的数据改变, 在有数据改变时 获取最后插入数据库的一条图片数据, 如果符合以下规则, 则认为截屏了:

    • 1、时间判断,图片的生成时间在开始监听之后, 并与当前时间相隔10秒内:开始监听后生成的图片才有意义,相隔10秒内说明是刚刚生成的;
    • 2、尺寸判断,图片的尺寸没有超过屏幕的尺寸:图片尺寸超过屏幕尺寸,一般都不是截屏图片(最近发现某些手机ROM支持滑动截屏,如果需要监听的APP界面支持滑动,需要做适当的调整和处理);
    • 3、路径判断,图片路径符合包含特定的关键词:这一点是关键,截屏图片的保存路径通常包含“screenshot”。

    PS: 这些判断是为了增加截屏检测结果的可靠性,防止误报,防止遗漏。其中截屏图片的路径正常Android系统保存的路径格式为:“外部存储器/Pictures/Screenshots/Screenshot_20161001-164643.png”,但Android系统碎片化严重,加上其他第三方截屏APP等,所以路径关键字除了检查是否包含“screenshot”外,还可以适当增加其他关键字,详见最后的监听器完整代码。这种监听截屏的方法也不是100%准确,例如某些被root的机器使用第三方截屏APP自定义保存路径,还比如通过ADB命令在电脑上获取手机屏幕快照均不能监听到,但这也是目前可行性最高的方法,对于绝大多数用户都比较靠谱。

    3. 监听器的封装与使用

    我把ContentObserver对媒体数据库的的监听,以及对结果的判断全都封装在一个独立的类中(ScreenShotListenManager),使用步骤相当简单:

    1、在AndroidManifest.xml中添加权限:

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

    PS: 在 Android 6.0 (API 23) 或 更高版本 上还需要动态申请权限,详见 Android6.0动态权限申请

    2、监听器的调用:

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

    监听器类(ScreenShotListenManager)完整代码实现:

    package com.xiets.screenshotlistener;
    
    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>
     * 截屏判断依据: 监听媒体数据库的数据改变, 在有数据改变时获取最后
     * 插入数据库的一条图片数据, 如果符合以下规则, 则认为截屏了: <br/>
     *
     * 1. 时间判断, 图片的生成时间在开始监听之后, 并与当前时间相隔10秒内; <br/>
     * 2. 尺寸判断, 图片的尺寸没有超过屏幕的尺寸; <br/>
     * 3. 路径判断, 图片路径符合包含特定的关键词。<br/>
     *
     * <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>
     *
     * @author xietansheng
     */
    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);
            }
        }
    
    }
    
    展开全文
  • Android 系统截图

    2017-04-15 11:36:04
    如何实现android手机同时按下电源键和音量-按键截图android截图功能的实现是在SystemUI.apk中做的, 源码位于SystemUI\src\com\android\systemui\screenshot包下, 截图功能的实现简单,...
    如何实现android手机同时按下电源键和音量-按键截图? 
    
    android 的截图功能的实现是在SystemUI.apk中做的, 源码位于SystemUI\src\com\android\systemui\screenshot包下,
    截图功能的实现简单,TakeScreenshotService.java 供其他应用远程访问,GlobalScreenshot.java 实现截图功能。

     /**
         * Takes a screenshot of the current display and shows an animation.
         */
        void takeScreenshot(Runnable finisher, boolean statusBarVisible, boolean navBarVisible) {
            // We need to orient the screenshot correctly (and the Surface api seems to take screenshots
            // only in the natural orientation of the device :!)
            mDisplay.getRealMetrics(mDisplayMetrics);
            float[] dims = {mDisplayMetrics.widthPixels, mDisplayMetrics.heightPixels};
            float degrees = getDegreesForRotation(mDisplay.getRotation());
            boolean requiresRotation = (degrees > 0);
            if (requiresRotation) {
                // Get the dimensions of the device in its native orientation
                mDisplayMatrix.reset();
                mDisplayMatrix.preRotate(-degrees);
                mDisplayMatrix.mapPoints(dims);
                dims[0] = Math.abs(dims[0]);
                dims[1] = Math.abs(dims[1]);
            }

            // Take the screenshot
            mScreenBitmap = Surface.screenshot((int) dims[0], (int) dims[1]);
            if (mScreenBitmap == null) {
                notifyScreenshotError(mContext, mNotificationManager);
                finisher.run();
                return;
            }

            if (requiresRotation) {
                // Rotate the screenshot to the current orientation
                Bitmap ss = Bitmap.createBitmap(mDisplayMetrics.widthPixels,
                        mDisplayMetrics.heightPixels, Bitmap.Config.ARGB_8888);
                Canvas c = new Canvas(ss);
                c.translate(ss.getWidth() / 2, ss.getHeight() / 2);
                c.rotate(degrees);
                c.translate(-dims[0] / 2, -dims[1] / 2);
                c.drawBitmap(mScreenBitmap, 0, 0, null);
                c.setBitmap(null);
                mScreenBitmap = ss;
            }

            // Optimizations
            mScreenBitmap.setHasAlpha(false);
            mScreenBitmap.prepareToDraw();

            // Start the post-screenshot animation
            startAnimation(finisher, mDisplayMetrics.widthPixels, mDisplayMetrics.heightPixels,
                    statusBarVisible, navBarVisible);
        }
     mScreenBitmap = Surface.screenshot((int) dims[0], (int) dims[1]);  获取到Bitmap
    后续做的一些操作解释将图片保存到flash,更新数据库,发送一些notification通知用户目前的截图状态;
    ,如果我们需要在自己的Apk中实现截图 ,我们可以
    private void takeScreenshot() {

    synchronized (mScreenshotLock) {
    if (mScreenshotConnection != null) {
    return;
    }
    ComponentName cn = new ComponentName("com.android.systemui",
    "com.android.systemui.screenshot.TakeScreenshotService");
    Intent intent = new Intent();
    intent.setComponent(cn);
    ServiceConnection conn = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
    synchronized (mScreenshotLock) {
    if (mScreenshotConnection != this) {
    return;
    }
    Messenger messenger = new Messenger(service);
    Message msg = Message.obtain(null, 1);
    final ServiceConnection myConn = this;
    Handler h = new Handler(mHandler.getLooper()) {
    @Override
    public void handleMessage(Message msg) {
    synchronized (mScreenshotLock) {
    if (mScreenshotConnection == myConn) {
    unbindService(mScreenshotConnection);
    mScreenshotConnection = null;
    mHandler.removeCallbacks(mScreenshotTimeout);
    }
    }
    }
    };
    msg.replyTo = new Messenger(h);
    msg.arg1 = msg.arg2 = 0;
    // if (mStatusBar != null && mStatusBar.isVisibleLw())
    // msg.arg1 = 1;
    // if (mNavigationBar != null &&
    // mNavigationBar.isVisibleLw())
    // msg.arg2 = 1;
    try {
    messenger.send(msg);
    } catch (RemoteException e) {
    }
    }
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
    }
    };
    if (bindService(intent, conn, Context.BIND_AUTO_CREATE)) {
    mScreenshotConnection = conn;
    mHandler.postDelayed(mScreenshotTimeout, 10000);
    }
    }
    }
    完成Service的绑定,向Service发送一个Handler消息即可,
    同时注意该 service 是不可垮进程访问的 ,所以给修改 mainfest.xml  将 TakeScreenshotService 。export属性改为true;
    展开全文
  • Android系统截屏监听工具 做系统截屏通知的时候,找了很多资料,测试后发现要做挺多机型适配的,而且有时候会没有监听到,有时候又监听到多次,不能实现想要的效果。一下是最终的解决方案,已在足够多的手机品牌跟...

    Android系统截屏监听工具

    做系统截屏通知的时候,找了很多资料,测试后发现要做挺多机型适配的,而且有时候会没有监听到,有时候又监听到多次,不能实现想要的效果。一下是最终的解决方案,已在足够多的手机品牌跟同一品牌不同版本上做过足够多的适配。

    1、首先创建一个工具类

    /**
     * 系统截屏监听工具,监听系统截屏,然后对截图进行处理
     */
    public class ScreenShot {
        private static final String TAG = "ScreenShot";
        private static final String[] MEDIA_PROJECTIONS = {
                MediaStore.Images.ImageColumns.DATA,
                MediaStore.Images.ImageColumns.DATE_TAKEN,
                MediaStore.Images.ImageColumns.DATE_ADDED,
        };
    
        /**
         * 截屏依据中的路径判断关键字
         */
        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 ContentResolver mContentResolver;
        private CallbackListener mCallbackListener;
        private MediaContentObserver mInternalObserver;
        private MediaContentObserver mExternalObserver;
        private static ScreenShot mInstance;
    
        private long mExitTime;
    
        private ScreenShot() {
        }
    
        /**
         * 获取 ScreenShot 对象
         *
         * @return ScreenShot对象
         */
        public static ScreenShot getInstance() {
            if (mInstance == null) {
                synchronized (ScreenShot.class) {
                    mInstance = new ScreenShot();
                }
            }
            return mInstance;
        }
    
        /**
         * 注册
         *
         * @param context          上下文
         * @param callbackListener 回调监听
         */
        public void register(Context context, CallbackListener callbackListener) {
            mContentResolver = context.getContentResolver();
            mCallbackListener = callbackListener;
    
            HandlerThread handlerThread = new HandlerThread(TAG);
            handlerThread.start();
            Handler handler = new Handler(handlerThread.getLooper());
    
            mInternalObserver = new MediaContentObserver(MediaStore.Images.Media.INTERNAL_CONTENT_URI, handler);
            mExternalObserver = new MediaContentObserver(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, handler);
    
            mContentResolver.registerContentObserver(MediaStore.Images.Media.INTERNAL_CONTENT_URI,
                    true, mInternalObserver);
            mContentResolver.registerContentObserver(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                    true, mExternalObserver);
        }
    
        /**
         * 注销
         */
        public void unregister() {
            if (mContentResolver != null) {
                mContentResolver.unregisterContentObserver(mInternalObserver);
                mContentResolver.unregisterContentObserver(mExternalObserver);
            }
        }
    
        private void handleMediaContentChange(Uri uri) {
            Cursor cursor = null;
            try {
                // 数据改变时,查询数据库中最后加入的一条数据
                cursor = mContentResolver.query(uri, MEDIA_PROJECTIONS, null, null,
                        MediaStore.Images.ImageColumns.DATE_ADDED + " desc limit 1");
                if (cursor == null) {
                    return;
                }
                if (!cursor.moveToFirst()) {
                    return;
                }
                int dataIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
                int dateAddedIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATE_ADDED);
                // 处理获取到的第一行数据
                handleMediaRowData(cursor.getString(dataIndex), cursor.getLong(dateAddedIndex));
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (cursor != null && !cursor.isClosed()) {
                    cursor.close();
                }
            }
        }
    
    //    private Lock lock = new ReentrantLock();
    
        /**
         * 处理监听到的资源
         */
        private void handleMediaRowData(String path, long dateAdded) {
    
            if (checkScreenShot(path,dateAdded)) {
                if (mCallbackListener != null) {
    //                lock.lock();// 得到锁
                    System.out.println(Thread.currentThread().getName()+" begin time: "+System.currentTimeMillis());
                    mCallbackListener.onShot(path);
                    System.out.println(Thread.currentThread().getName()+" end time: "+System.currentTimeMillis());
                }
            }
        }
        /**
         * 判断是否是截屏
         */
        private boolean checkScreenShot(String data, long dateTaken) {
    
            data = data.toLowerCase();
            // 判断图片路径是否含有指定的关键字之一, 如果有, 则认为当前截屏了
            for (String keyWork : KEYWORDS) {
                if (data.contains(keyWork)) {
                    return true;
                }
            }
            return false;
        }
    
        private static long lastTime = 0;
        /**
         * 媒体内容观察者
         */
        private class MediaContentObserver extends ContentObserver {
            private Uri mUri;
    
            MediaContentObserver(Uri uri, Handler handler) {
                super(handler);
                mUri = uri;
            }
    
            @Override
            public void onChange(boolean selfChange) {
                super.onChange(selfChange);
    
                long current = System.currentTimeMillis();
                if (current - lastTime>1000){
                    lastTime = current;
                    Log.d("ScreenShot", "图片数据库发生变化:" + current);
                    handleMediaContentChange(mUri);
                }
            }
        }
    
        /**
         * 回调监听器
         */
        public interface CallbackListener {
            /**
             * 截屏
             *
             * @param path 图片路径
             */
            void onShot(String path);
        }
    }
    

    2、在activity需要的地方新建实体类进行注册

    mScreenShot.register(getContext(), new ScreenShot.CallbackListener() {
                @Override
                public void onShot(String path) {
                    // 捕获到系统截屏,path是截屏的绝对路径
                    ScreenAttachment screenAttachment = new ScreenAttachment();
                    screenAttachment.setScreenId(sessionId);
    
                    IMMessage message = MessageBuilder.createCustomMessage(sessionId, SessionTypeEnum.Team,
                            "截屏通知", screenAttachment);
                    NIMClient.getService(MsgService.class).sendMessage(message, false).setCallback(new RequestCallback<Void>() {
                        @Override
                        public void onSuccess(Void aVoid) {
                        }
    
                        @Override
                        public void onFailed(int i) {
    
                        }
    
                        @Override
                        public void onException(Throwable throwable) {
    
                        }
                    });
                    postRunnable(new Runnable() {
                        @Override
                        public void run() {
                            if (getParentFragment() != null) {
                                ((MessageFragment) getParentFragment()).messageListPanel.onMsgSend(message);
                                if (message.getFromAccount().equals(teamById.getCreator())) {
                                    messageListPanel.onMsgSend(message);
                                }
                            } else {
                                messageListPanel.onMsgSend(message);
                            }
                            if (isAdmin == 1 && teamById != null && message.getFromAccount().equals(teamById.getCreator())&&topMessageFragment!=null) {
                                topMessageFragment.messageListPanel.onMsgSend(message);
                            }
                        }
                    });
                }
            });
    

    3、记得在onDestroy的时候注销

    if (mScreenShot != null) {
                mScreenShot.unregister();
            }
    

    转载请注明出处

    展开全文
  • Android系统截屏方案

    2021-04-28 14:14:55
    系统截屏
  • 查询资料后发现,系统截图有两种方法,一种是通过SurfaceControl.screenshot提供的接口调用,还有一种是通过screencap 命令获取,这两种方式默认都需要使得系统签名才能使用。方法一:SurfaceControl....
  • android系统截屏接口

    千次阅读 2017-05-18 16:57:05
    android系统截屏接口 最近有客户希望它们的apk能够调用系统截屏接口,实现他们的功能。这个需求的实现方案是通过接收客户apk发送的截图广播给SystemUI 调用截图方法takeScreenShot()来实现的,在这里记录一下。...
  • android去除截屏接口
  • 针对Android系统设备截屏操作:1. adb shell screencap -p /sdcard/screen.png //截屏2. adb pull /sdcard/screen.png //将截取的图片传送到电脑上3. adb shell rm /sdcard/screen.png //删除手机上的截屏图片实际...
  • Android系统截屏的实现(附代码)

    万次阅读 多人点赞 2014-09-09 14:51:02
    1.背景 写博客快两年了,写了100+的文章,最火的文章也是大家最关注的就是如何实现android系统截屏。其实我们google android_screen_shot就会找到很对办法,但那些都是很多年前的了,在android4.*版本后,android...
  • Android 系统截屏与系统内置DVR录像冲突,导致SystemUI重启的问题解决与分享
  • Android系统截屏功能提取

    万次阅读 多人点赞 2014-09-14 13:04:59
    Android在4.0版本之后同时按电源键和音量键可以截取当前屏幕,截图后会有一个过渡动画效果,这里提取了将效果这部分提取出来,可以用于应用截图分享功能。 截图功能在源码中的位置是com.android.systemui.screenshot...
  • 代码示例,自己研究的通过读取/dev/graphics/fb0文件解析出系统界面的图片 需要root系统才能使用 可以截取android系统所有界面的图片,需要做系统截图的可以看看
  • 1. 原理 Android系统并没有提供截屏通知相关的API,...Android系统有一个媒体数据库,每拍一张照片,或使用系统截屏截取一张图片,都会把这张图片的详细信息加入到这个媒体数据库,并发出内容改变通知,我们可以
  • android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent"> <ImageButton android:id="@+id/float_id" android:layout_width="150dp" android:...
  • 一个Android系统截屏问题

    千次阅读 2014-09-13 14:11:59
    一、问题  目前遇到截屏参数设置后,
  • Android系统截屏的实现分析

    万次阅读 2016-01-11 11:10:58
    sp<Surface> consumer = android_view_Surface_getSurface(env, surfaceObj); if (consumer != NULL) { int left = env->GetIntField(sourceCropObj, gRectClassInfo.left); int top = env->GetIntField...
  • Ready品牌型号:华为P40系统:EMUI10.1.0不论是在游戏中还是和好友聊天中,都会有需要截屏的时候,那么安卓手机怎么截屏呢?方法一:安卓手机通用截屏方法手机保持在任意需要截屏的页面,这里以手机桌面为例同时按下...
  • Ready品牌型号:华为P40系统:EMUI10.1.0我们日常生活中使用手机时都会用到截图功能,那么安卓手机怎么截屏呢?方法一:安卓手机通用截屏方法手机保持在任意需要截屏的页面,这里以手机桌面为例:同时按下电源键和...
  • Android代码截屏(仿系统截屏效果)

    千次阅读 2019-07-23 11:51:53
    产品要求的新需求,在一个分享的页面对当前的页面截屏保存图片然后在第三方应用中进行图片分享,这里就做了一个简单的demo,为了更好的用户体验就做了一个类似系统按钮截屏的效果,截屏之后将截图做了一个本地存储...
  • Android截屏的方式:1.获取DecorView截屏通过获取DecorView的方式来实现截屏(前提是当前Activity已经加载完成),DecorView为整个Window界面的最顶层View,因此截屏不包含状态栏(SystemUI)部分. View view = getWindow()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,071
精华内容 21,628
关键字:

安卓系统截屏