Android(安卓)截图功能源码的分析

Android 截图功能源码的分析

一般没有修改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 screenshotmScreenBitmap = 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，如果失败调用失败通知栏消息，如果成功调用截图动画后发送成功通知栏消息。

如有疑问请留言或者到本站社区交流讨论，感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

更多相关文章

随机推荐