美文网首页
android 截图功能源码解析

android 截图功能源码解析

作者: 一航jason | 来源:发表于2017-09-15 10:45 被阅读0次

    一般没有修改rom的android原生系统截图功能的组合键是音量减+开机键;今天我们从源码角度来分析截图功能是如何在源码中实现的。

    在android系统中,由于我们的每一个Android界面都是一个Activity,而界面的显示都是通过Window对象实现的,每个Window对象实际上都是PhoneWindow的实例,而每个PhoneWindow对象都对应一个PhoneWindowManager对象,当我们在Activity界面执行按键操作的时候,在将按键的处理操作分发到App之前,首先会回调PhoneWindowManager中的dispatchUnhandledKey方法,该方法主要用于执行当前App处理按键之前的操作,我们具体看一下该方法的实现。

    /** {@inheritDoc} */
        @Override
        public KeyEvent dispatchUnhandledKey(WindowState win, KeyEvent event, int policyFlags) {
            ...
            KeyEvent fallbackEvent = null;
            if ((event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
                final KeyCharacterMap kcm = event.getKeyCharacterMap();
                final int keyCode = event.getKeyCode();
                final int metaState = event.getMetaState();
                final boolean initialDown = event.getAction() == KeyEvent.ACTION_DOWN
                        && event.getRepeatCount() == 0;
    
                // Check for fallback actions specified by the key character map.
                final FallbackAction fallbackAction;
                if (initialDown) {
                    fallbackAction = kcm.getFallbackAction(keyCode, metaState);
                } else {
                    fallbackAction = mFallbackActions.get(keyCode);
                }
    
                if (fallbackAction != null) {
                    ...
                    final int flags = event.getFlags() | KeyEvent.FLAG_FALLBACK;
                    fallbackEvent = KeyEvent.obtain(
                            event.getDownTime(), event.getEventTime(),
                            event.getAction(), fallbackAction.keyCode,
                            event.getRepeatCount(), fallbackAction.metaState,
                            event.getDeviceId(), event.getScanCode(),
                            flags, event.getSource(), null);
    
                    if (!interceptFallback(win, fallbackEvent, policyFlags)) {
                        fallbackEvent.recycle();
                        fallbackEvent = null;
                    }
    
                    if (initialDown) {
                        mFallbackActions.put(keyCode, fallbackAction);
                    } else if (event.getAction() == KeyEvent.ACTION_UP) {
                        mFallbackActions.remove(keyCode);
                        fallbackAction.recycle();
                    }
                }
            }
    
            ...
            return fallbackEvent;
        }
    

    这里我们关注一下方法体中调用的:interceptFallback方法,通过调用该方法将处理按键的操作下发到该方法中,我们继续看一下该方法的实现逻辑。

    private boolean interceptFallback(WindowState win, KeyEvent fallbackEvent, int policyFlags) {
            int actions = interceptKeyBeforeQueueing(fallbackEvent, policyFlags);
            if ((actions & ACTION_PASS_TO_USER) != 0) {
                long delayMillis = interceptKeyBeforeDispatching(
                        win, fallbackEvent, policyFlags);
                if (delayMillis == 0) {
                    return true;
                }
            }
            return false;
        }
    

    然后我们看到在interceptFallback方法中我们调用了interceptKeyBeforeQueueing方法,通过阅读我们我们知道该方法主要实现了对截屏按键的处理流程,这样我们继续看一下interceptKeyBeforeWueueing方法的处理:

    @Override
        public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags) {
            if (!mSystemBooted) {
                // If we have not yet booted, don't let key events do anything.
                return 0;
            }
    
            ...
            // Handle special keys.
            switch (keyCode) {
                case KeyEvent.KEYCODE_VOLUME_DOWN:
                case KeyEvent.KEYCODE_VOLUME_UP:
                case KeyEvent.KEYCODE_VOLUME_MUTE: {
                    if (mUseTvRouting) {
                        // On TVs volume keys never go to the foreground app
                        result &= ~ACTION_PASS_TO_USER;
                    }
                    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
                        if (down) {
                            if (interactive && !mScreenshotChordVolumeDownKeyTriggered
                                    && (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
                                mScreenshotChordVolumeDownKeyTriggered = true;
                                mScreenshotChordVolumeDownKeyTime = event.getDownTime();
                                mScreenshotChordVolumeDownKeyConsumed = false;
                                cancelPendingPowerKeyAction();
                                interceptScreenshotChord();
                            }
                        } else {
                            mScreenshotChordVolumeDownKeyTriggered = false;
                            cancelPendingScreenshotChordAction();
                        }
                    }
                    ...
    
            return result;
        }
    

    可以发现这里首先判断当前系统是否已经boot完毕,若尚未启动完毕,则所有的按键操作都将失效,若启动完成,则执行后续的操作,这里我们只是关注音量减少按键和电源按键组合的处理事件。另外这里多说一句想安卓系统的HOME按键事件,MENU按键事件,进程列表按键事件等等都是在这里实现的,后续中我们会陆续介绍这方面的内容。

    回到我们的interceptKeyBeforeQueueing方法,当我用按下音量减少按键的时候回进入到:case KeyEvent.KEYCODE_VOLUME_MUTE分支并执行相应的逻辑,然后同时判断用户是否按下了电源键,若同时按下了电源键,则执行:

    if (interactive && !mScreenshotChordVolumeDownKeyTriggered
                                    && (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
                                mScreenshotChordVolumeDownKeyTriggered = true;
                                mScreenshotChordVolumeDownKeyTime = event.getDownTime();
                                mScreenshotChordVolumeDownKeyConsumed = false;
                                cancelPendingPowerKeyAction();
                                interceptScreenshotChord();
                            }
    

    可以发现这里的interceptScreenshotChrod方法就是系统准备开始执行截屏操作的开始,我们继续看一下interceptcreenshotChord方法的实现。

    private void interceptScreenshotChord() {
            if (mScreenshotChordEnabled
                    && mScreenshotChordVolumeDownKeyTriggered && mScreenshotChordPowerKeyTriggered
                    && !mScreenshotChordVolumeUpKeyTriggered) {
                final long now = SystemClock.uptimeMillis();
                if (now <= mScreenshotChordVolumeDownKeyTime + SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS
                        && now <= mScreenshotChordPowerKeyTime
                                + SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS) {
                    mScreenshotChordVolumeDownKeyConsumed = true;
                    cancelPendingPowerKeyAction();
    
                    mHandler.postDelayed(mScreenshotRunnable, getScreenshotChordLongPressDelay());
                }
            }
        }
    

    在方法体中我们最终会执行发送一个延迟的异步消息,请求执行截屏的操作而这里的延时时间,若当前输入框是打开状态,则延时时间为输入框关闭时间加上系统配置的按键超时时间,若当前输入框没有打开则直接是系统配置的按键超时处理时间,可看一下getScreenshotChordLongPressDelay方法的具体实现。

    private long getScreenshotChordLongPressDelay() {
            if (mKeyguardDelegate.isShowing()) {
                // Double the time it takes to take a screenshot from the keyguard
                return (long) (KEYGUARD_SCREENSHOT_CHORD_DELAY_MULTIPLIER *
                        ViewConfiguration.get(mContext).getDeviceGlobalActionKeyTimeout());
            }
            return ViewConfiguration.get(mContext).getDeviceGlobalActionKeyTimeout();
        }
    

    回到我们的interceptScreenshotChord方法,发送了异步消息之后系统最终会被我们发送的Runnable对象的run方法执行;这样我们看一下Runnable类型的mScreenshotRunnable的run方法的实现:

    private final Runnable mScreenshotRunnable = new Runnable() {
            @Override
            public void run() {
                takeScreenshot();
            }
        };
    

    好吧,方法体中并未执行其他操作,直接就是调用了takeScreenshot方法,这样我们继续看一下takeScreenshot方法的实现。

    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) {
                                            mContext.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 (mContext.bindServiceAsUser(
                        intent, conn, Context.BIND_AUTO_CREATE, UserHandle.CURRENT)) {
                    mScreenshotConnection = conn;
                    mHandler.postDelayed(mScreenshotTimeout, 10000);
                }
            }
        }
    

    可以发现这里通过反射机制创建了一个TakeScreenshotService对象然后调用了bindServiceAsUser,这样就创建了TakeScreenshotService服务并在服务创建之后发送了一个异步消息。好了,我们看一下TakeScreenshotService的实现逻辑。

    public class TakeScreenshotService extends Service {
        private static final String TAG = "TakeScreenshotService";
    
        private static GlobalScreenshot mScreenshot;
    
        private Handler mHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case 1:
                        final Messenger callback = msg.replyTo;
                        if (mScreenshot == null) {
                            mScreenshot = new GlobalScreenshot(TakeScreenshotService.this);
                        }
                        mScreenshot.takeScreenshot(new Runnable() {
                            @Override public void run() {
                                Message reply = Message.obtain(null, 1);
                                try {
                                    callback.send(reply);
                                } catch (RemoteException e) {
                                }
                            }
                        }, msg.arg1 > 0, msg.arg2 > 0);
                }
            }
        };
    
        @Override
        public IBinder onBind(Intent intent) {
            return new Messenger(mHandler).getBinder();
        }
    }
    

    可以发现在在TakeScreenshotService类的定义中有一个Handler成员变量,而我们在启动TakeScreentshowService的时候回发送一个异步消息,这样就会执行mHandler的handleMessage方法,然后在handleMessage方法中我们创建了一个GlobalScreenshow对象,然后执行了takeScreenshot方法,好吧,继续看一下takeScreentshot方法的执行逻辑。

    /**
         * 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 = SurfaceControl.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);
                // Recycle the previous bitmap
                mScreenBitmap.recycle();
                mScreenBitmap = ss;
            }
    
            // Optimizations
            mScreenBitmap.setHasAlpha(false);
            mScreenBitmap.prepareToDraw();
    
            // Start the post-screenshot animation
            startAnimation(finisher, mDisplayMetrics.widthPixels, mDisplayMetrics.heightPixels,
                    statusBarVisible, navBarVisible);
        }
    

    可以看到这里后两个参数:statusBarVisible,navBarVisible是否可见,而这两个参数在我们PhoneWindowManager.takeScreenshot方法传递的:

    if (mStatusBar != null && mStatusBar.isVisibleLw())
                                msg.arg1 = 1;
                            if (mNavigationBar != null && mNavigationBar.isVisibleLw())
                                msg.arg2 = 1;
    

    可见若果mStatusBar可见,则传递的statusBarVisible为true,若mNavigationBar可见,则传递的navBarVisible为true。然后我们在截屏的时候判断nStatusBar是否可见,mNavigationBar是否可见,若可见的时候则截屏同样将其截屏出来。继续回到我们的takeScreenshot方法,然后调用了:

    // Take the screenshot
    mScreenBitmap = SurfaceControl.screenshot((int) dims[0], (int) dims[1]);
    

    方法,看注释,这里就是执行截屏事件的具体操作了,然后我看一下SurfaceControl.screenshot方法的具体实现,另外这里需要注意的是,截屏之后返回的是一个Bitmap对象,其实熟悉android绘制机制的童鞋应该知道android中所有显示能够显示的东西,在内存中表现都是Bitmap对象。

    public static Bitmap screenshot(int width, int height) {
            // TODO: should take the display as a parameter
            IBinder displayToken = SurfaceControl.getBuiltInDisplay(
                    SurfaceControl.BUILT_IN_DISPLAY_ID_MAIN);
            return nativeScreenshot(displayToken, new Rect(), width, height, 0, 0, true,
                    false, Surface.ROTATION_0);
        }
    

    好吧,这里调用的是nativeScreenshot方法,它是一个native方法,具体的实现在JNI层,这里就不做过多的介绍了。继续回到我们的takeScreenshot方法,在调用了截屏方法screentshot之后,判断是否截屏成功:

    if (mScreenBitmap == null) {
                notifyScreenshotError(mContext, mNotificationManager);
                finisher.run();
                return;
            }
    

    若截屏之后,截屏的bitmap对象为空,这里判断截屏失败,调用了notifyScreenshotError方法,发送截屏失败的notification通知。

    static void notifyScreenshotError(Context context, NotificationManager nManager) {
            Resources r = context.getResources();
    
            // Clear all existing notification, compose the new notification and show it
            Notification.Builder b = new Notification.Builder(context)
                .setTicker(r.getString(R.string.screenshot_failed_title))
                .setContentTitle(r.getString(R.string.screenshot_failed_title))
                .setContentText(r.getString(R.string.screenshot_failed_text))
                .setSmallIcon(R.drawable.stat_notify_image_error)
                .setWhen(System.currentTimeMillis())
                .setVisibility(Notification.VISIBILITY_PUBLIC) // ok to show outside lockscreen
                .setCategory(Notification.CATEGORY_ERROR)
                .setAutoCancel(true)
                .setColor(context.getColor(
                            com.android.internal.R.color.system_notification_accent_color));
            Notification n =
                new Notification.BigTextStyle(b)
                    .bigText(r.getString(R.string.screenshot_failed_text))
                    .build();
            nManager.notify(R.id.notification_screenshot, n);
        }
    

    然后继续看takeScreenshot方法,判断截屏的图像是否需要旋转,若需要的话,则旋转图像:

    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);
                // Recycle the previous bitmap
                mScreenBitmap.recycle();
                mScreenBitmap = ss;
            }
    

    在takeScreenshot方法的最后若截屏成功,我们调用了:

    // Start the post-screenshot animation
            startAnimation(finisher, mDisplayMetrics.widthPixels, mDisplayMetrics.heightPixels,
                    statusBarVisible, navBarVisible);
    

    开始截屏的动画,好吧,看一下动画效果的实现:

    /**
         * Starts the animation after taking the screenshot
         */
        private void startAnimation(final Runnable finisher, int w, int h, boolean statusBarVisible,
                boolean navBarVisible) {
            // Add the view for the animation
            mScreenshotView.setImageBitmap(mScreenBitmap);
            mScreenshotLayout.requestFocus();
    
            // Setup the animation with the screenshot just taken
            if (mScreenshotAnimation != null) {
                mScreenshotAnimation.end();
                mScreenshotAnimation.removeAllListeners();
            }
    
            mWindowManager.addView(mScreenshotLayout, mWindowLayoutParams);
            ValueAnimator screenshotDropInAnim = createScreenshotDropInAnimation();
            ValueAnimator screenshotFadeOutAnim = createScreenshotDropOutAnimation(w, h,
                    statusBarVisible, navBarVisible);
            mScreenshotAnimation = new AnimatorSet();
            mScreenshotAnimation.playSequentially(screenshotDropInAnim, screenshotFadeOutAnim);
            mScreenshotAnimation.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animation) {
                    // Save the screenshot once we have a bit of time now
                    saveScreenshotInWorkerThread(finisher);
                    mWindowManager.removeView(mScreenshotLayout);
    
                    // Clear any references to the bitmap
                    mScreenBitmap = null;
                    mScreenshotView.setImageBitmap(null);
                }
            });
            mScreenshotLayout.post(new Runnable() {
                @Override
                public void run() {
                    // Play the shutter sound to notify that we've taken a screenshot
                    mCameraSound.play(MediaActionSound.SHUTTER_CLICK);
    
                    mScreenshotView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
                    mScreenshotView.buildLayer();
                    mScreenshotAnimation.start();
                }
            });
        }
    

    好吧,经过着一些列的操作之后我们实现了截屏之后的动画效果了,这里暂时不分析动画效果,我们看一下动画效果之后做了哪些?还记不记的一般情况下我们截屏之后都会收到一个截屏的notification通知?这里应该也是在其AnimatorListenerAdapter的onAnimationEnd方法中实现的,也就是动画执行完成之后,我们看一下其saveScreenshotInWorkerThread方法的实现:

    /**
         * Creates a new worker thread and saves the screenshot to the media store.
         */
        private void saveScreenshotInWorkerThread(Runnable finisher) {
            SaveImageInBackgroundData data = new SaveImageInBackgroundData();
            data.context = mContext;
            data.image = mScreenBitmap;
            data.iconSize = mNotificationIconSize;
            data.finisher = finisher;
            data.previewWidth = mPreviewWidth;
            data.previewheight = mPreviewHeight;
            if (mSaveInBgTask != null) {
                mSaveInBgTask.cancel(false);
            }
            mSaveInBgTask = new SaveImageInBackgroundTask(mContext, data, mNotificationManager,
                    R.id.notification_screenshot).execute(data);
        }
    

    好吧,这里主要逻辑就是构造了一个SaveImageInBackgroundTask对象,看样子发送截屏成功的通知应该是在这里实现的,我们看一下SaveImageInBackgroundTask构造方法的实现逻辑:

    SaveImageInBackgroundTask(Context context, SaveImageInBackgroundData data,
                NotificationManager nManager, int nId) {
            ...
    
            // Show the intermediate notification
            mTickerAddSpace = !mTickerAddSpace;
            mNotificationId = nId;
            mNotificationManager = nManager;
            final long now = System.currentTimeMillis();
    
            mNotificationBuilder = new Notification.Builder(context)
                .setTicker(r.getString(R.string.screenshot_saving_ticker)
                        + (mTickerAddSpace ? " " : ""))
                .setContentTitle(r.getString(R.string.screenshot_saving_title))
                .setContentText(r.getString(R.string.screenshot_saving_text))
                .setSmallIcon(R.drawable.stat_notify_image)
                .setWhen(now)
                .setColor(r.getColor(com.android.internal.R.color.system_notification_accent_color));
    
            mNotificationStyle = new Notification.BigPictureStyle()
                .bigPicture(picture.createAshmemBitmap());
            mNotificationBuilder.setStyle(mNotificationStyle);
    
            // For "public" situations we want to show all the same info but
            // omit the actual screenshot image.
            mPublicNotificationBuilder = new Notification.Builder(context)
                    .setContentTitle(r.getString(R.string.screenshot_saving_title))
                    .setContentText(r.getString(R.string.screenshot_saving_text))
                    .setSmallIcon(R.drawable.stat_notify_image)
                    .setCategory(Notification.CATEGORY_PROGRESS)
                    .setWhen(now)
                    .setColor(r.getColor(
                            com.android.internal.R.color.system_notification_accent_color));
    
            mNotificationBuilder.setPublicVersion(mPublicNotificationBuilder.build());
    
            Notification n = mNotificationBuilder.build();
            n.flags |= Notification.FLAG_NO_CLEAR;
            mNotificationManager.notify(nId, n);
    
            // On the tablet, the large icon makes the notification appear as if it is clickable (and
            // on small devices, the large icon is not shown) so defer showing the large icon until
            // we compose the final post-save notification below.
            mNotificationBuilder.setLargeIcon(icon.createAshmemBitmap());
            // But we still don't set it for the expanded view, allowing the smallIcon to show here.
            mNotificationStyle.bigLargeIcon((Bitmap) null);
        }
    

    可以发现在构造方法的后面狗仔了一个NotificationBuilder对象,然后发送了一个截屏成功的Notification,这样我们在截屏动画之后就收到了Notification的通知了。

    总结:

    一般默认情况下按下音量减少键和开机键会执行截图动作,程序执行的入口就在在PhoneWindowManager的dispatchUnhandledKey方法中;然后通过TakeScreenshotService服务执行截图逻辑;通过nativie方法获取截图的bitmap,如果失败调用失败通知栏消息,如果成功调用截图动画后发送成功通知栏消息。

    相关文章

      网友评论

          本文标题:android 截图功能源码解析

          本文链接:https://www.haomeiwen.com/subject/pxrssxtx.html