截图功能源码解析,Android源码解析之截屏事件流程

今天这篇文章我们主要讲一下Android系统中的截屏事件处理流程。用过android系统手机的同学应该都知道,一般的android手机按下音量减少键和电源按键就会触发截屏事件(国内定制机做个修改的这里就不做考虑了)。那么这里的截屏事件是如何触发的呢?触发之后android系统是如何实现截屏操作的呢?带着这两个问题,开始我们的源码阅读流程。

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

我们知道这里的截屏事件是通过我们的按键操作触发的,所以这里就需要我们从android系统的按键触发模块开始看起,由于我们在不同的App页面,操作音量减少键和电源键都会触发系统的截屏处理,所以这里的按键触发逻辑应该是Android系统的全局按键处理逻辑。

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

在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;
    }
/** {@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方法,通过调用该方法将处理按键的操作下发到该方法中,我们继续看一下该方法的实现逻辑。

这里我们关注一下方法体中调用的: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;
    }
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方法的处理:

然后我们看到在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;
    }
@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按键事件,进程列表按键事件等等都是在这里实现的,后续中我们会陆续介绍这方面的内容。

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

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

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

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

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

可以发现这里的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());
            }
        }
    }
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方法的具体实现。

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

回到我们的interceptScreenshotChord方法,发送了异步消息之后系统最终会被我们发送的Runnable对象的run方法执行,这里关于异步消息的逻辑可参考:android源码解析之(二)–>异步消息机制

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

这样我们看一下Runnable类型的mScreenshotRunnable的run方法的实现:

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

private final Runnable mScreenshotRunnable = new Runnable() {
 @Override
 public void run() {
 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);
            }
        }
    }

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

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

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);
 }
 }
 }
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对象然后调用了bindServiceAsUser,这样就创建了TakeScreenshotService服务并在服务创建之后发送了一个异步消息。好了,我们看一下TakeScreenshotService的实现逻辑。

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

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();
 }
}
/**
     * 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);
    }

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

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

/**
 * 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);
 }
if (mStatusBar != null && mStatusBar.isVisibleLw())
                            msg.arg1 = 1;
                        if (mNavigationBar != null && mNavigationBar.isVisibleLw())
                            msg.arg2 = 1;

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

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

if (mStatusBar != null && mStatusBar.isVisibleLw())
 msg.arg1 = 1;
 if (mNavigationBar != null && mNavigationBar.isVisibleLw())
 msg.arg2 = 1;
// Take the screenshot
mScreenBitmap = SurfaceControl.screenshot((int) dims[0], (int) dims[1]);

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

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

// Take the screenshot
mScreenBitmap = SurfaceControl.screenshot((int) dims[0], (int) dims[1]);
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);
    }

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

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

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);
 }
if (mScreenBitmap == null) {
            notifyScreenshotError(mContext, mNotificationManager);
            finisher.run();
            return;
        }

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

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

if (mScreenBitmap == null) {
 notifyScreenshotError(mContext, mNotificationManager);
 finisher.run();
 return;
 }
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);
    }

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

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

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);
 }
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方法,判断截屏的图像是否需要旋转,若需要的话,则旋转图像:

在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;
 }
// Start the post-screenshot animation
        startAnimation(finisher, mDisplayMetrics.widthPixels, mDisplayMetrics.heightPixels,
                statusBarVisible, navBarVisible);

在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方法的实现:

/**
 * 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();
 }
 });
 }
/**
     * 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);
    }

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

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

/**
 * 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(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);
    }

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

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

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);
 }

总结:

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

可以发现在构造方法的后面狗仔了一个NotificationBuilder对象,然后发送了一个截屏成功的Notification,

这样我们在截屏动画之后就收到了Notification的通知了。

总结:

在PhoneWindowManager的dispatchUnhandledKey方法中处理App无法处理的按键事件,当然也包括音量减少键和电源按键的组合按键

通过一系列的调用启动TakeScreenshotService服务,并通过其执行截屏的操作。

具体的截屏代码是在native层实现的。

截屏操作时候,若截屏失败则直接发送截屏失败的notification通知。

截屏之后,若截屏成功,则先执行截屏的动画,并在动画效果执行完毕之后,发送截屏成功的notification的通知

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

您可能感兴趣的文章:

  • 详解Android截屏事件监听
  • Android截屏保存png图片的实例代码
  • Android实现截屏方式整理(总结)
  • JavaScript截屏功能的实现代码
  • java编程实现屏幕截图(截屏)代码总结
  • android截屏功能实现代码
  • 使用python编写android截屏脚本双击运行即可
  • c#根据网址抓取网页截屏生成图片的示例
  • Android
    使用Shell脚本截屏并自动传到电脑上
  • asp.net截屏功能实现截取web页面
  • Android实现截屏并保存操作功能

Post Author: admin

发表评论

电子邮件地址不会被公开。 必填项已用*标注