您的位置：
root是什么意思?手机怎么获取root权限？
root是什么(root之后的好处)
root之后可以刷机， 更换手机的系统! 刷自己喜欢的系统!
root之后可以使用屏幕截图(很多截图软件需要获取root权限)!
root之后可以最主要的是可以删除系统自带的软件。不过有些手机， 比如华为的还需要在解锁!!
ROOT之后还可以更改游戏， 比如我们经常玩的天天联盟， 捕鱼达人之类的， 都可以使用修改器来修改积分和金币!!
root之后安装应用也方便的多， 比如用手机豌豆荚下载东西的时候可以自动安装了。 如果没有权限的下载完之后还需要点击安装按钮。
获取root权限的风险
最大的奉贤就是root之后手机会不稳定!!
另外有很多手机制造商获取了root权限之后都不给予保修了!!
root之后刷机如果有操作失误， 很可能导致手机变砖， 开机都开不了。 变砖之后自己也可以找教程恢复， 如果不会就只能找修手机的地方修理了!!
怎么获取root权限
要想获取root权限就需要使用root工具，现在百度root、卓大师、腾讯管家等常用工具都有获取root权限的功能。不过有的工具支持的机型不多。 这里卓大师的感觉支持的机型多点， 大家可以下载自己喜欢的工具来使用!!或者使用百度这样大公司研发的工具。
然后进入手机设置， 把USB调试开启， 这样电脑才能连接手机!! 安卓系统版本不一样， 操作方法也不一样。 不过都是在设置里面，2.3以前的版本在开发里面可以找到。4.0的在开发人员选项里面可以打开!
获取权限之前需要手机里面有SD卡， 然后最好是吧手机恢复出厂设置一下。 这个也是root工具上面提示的。。
然后打开root工具， root工具会自动的读取你手机机型， 如果未root的点击获取即可。。 获取root权限时间回要个几分钟左右!!
获取root权限之后可以进入到系统管理里面删除系统自带软件， 不过不要乱删哦。 删除那些用的软件即可 ， 乱删除系统会异常。 上次我就是删除了一个电话 ，然后系统一直提示错误， 没办法只能刷机咯。
root也会有风险的， root 的朋友们要小心为好哦。 变砖之后可以拿去维修的地方修。。
有的时候获取root之后开机之后会自动重启， 把数据线拔掉然后再开机应该就能解决了!!
来源：互联网
信息也是生产力，精简才是硬道理！情报猎手带你突破信息迷雾，每日独家为您锁定最有价值的IT行业新鲜事。打开微信，扫描关注，赢取每月粉丝奖！后使用快捷导航没有帐号？
平板/笔记本
云服务专区
我的荣耀6root过，前天手贱系统在线更新了，现在基本变砖...
&新学乍练&
来自：浏览器
开机就发烫，反应慢。想刷回来，恢复root权限，求助啊
width:100%">
&独步江湖&
来自：浏览器
恢复出场设置试试！
width:100%">
&独步江湖&
来自：浏览器
width:100%">
&已臻大成&
来自：浏览器
不错哦，赞一个。
我是花粉，我爱花瓣。
width:100%">
&禁止发言&
来自：浏览器
提示: 作者被禁止或删除 内容自动屏蔽
签名被屏蔽
width:100%">
&初窥门径&
来自：浏览器
我和你一样，在线升级后就发神经
width:100%">
&登堂入室&
来自：浏览器
呵呵，不root就行了
width:100%">
&略有小成&
来自：浏览器
3键强刷试试
width:100%">
&略有小成&
来自：浏览器
可以进行卡刷
width:100%">
&登堂入室&
来自：浏览器
我的稳定版最新版自己ROTT了 在线升级失败，但是手机也没什么问题啊 ！升级失败了后来改卡刷开发板5.1最新系统可以升级，但是升级后不好ROOT了 还要先解锁？
width:100%">
把【秋】做成标本随拍：生活的‘远方’夕照上阳宫秋色白桦林再次邂逅坝上公主湖，依然惊艳！
花粉客户端
Make it Possible
Make your device special
华为云服务
Huawei cloud services
音乐播放器
Huawei Music
Huawei Vmall
没有最新动态
关注花粉俱乐部
联系我们：
|关注花粉俱乐部：
Copyright (C)
华为软件技术有限公司 版权所有 保留一切权利谁能告诉我怎么关闭root权限？今天去设置看了一眼发现有root权限然后手贱开了之后，应用分身用不了了【魅族吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
谁能告诉我怎么关闭root权限？今天去设置看了一眼发现有ro收藏
谁能告诉我怎么关闭root权限？今天去设置看了一眼发现有root权限然后手贱开了之后，应用分身用不了了 而且之前分身的应用用着闪退咋回事昂。求解答
有人来解答一下吗
登录百度帐号推荐应用android 关于屏幕截屏的几种办法
年末较闲，就上个星期查找各方面的资料关于android截图事情，自已也测试一些代码，已改改进或者优化。接下来进行总结一下。其实，如果真正android截屏是需要root权限的。但要用户使用都root，似乎不可能，体验性太差了。这期间我稍微观察了QQ的截图。QQ的截图是摇一摇截图当前屏幕，这个是不需要root权限的。然而，如果你要截图页面不是当前页面，就需要root权限。可以使用360超级root尝试一下。
1、直接使用getWindow().getDecorView().getRootView()
直接使用getWindow().getDecorView().getRootView()是获取当前屏幕的activity。然而对于系统状态栏的信息是截不了，出现一条空白的。如下图：
主要到没，有一条白色边就是系统状态栏。看一下代码，很简单都加了注释了。
//这种方法状态栏是空白，显示不了状态栏的信息
private void saveCurrentImage()
//获取当前屏幕的大小
int width = getWindow().getDecorView().getRootView().getWidth();
int height = getWindow().getDecorView().getRootView().getHeight();
//生成相同大小的图片
Bitmap temBitmap = Bitmap.createBitmap( width, height, Config.ARGB_8888 );
//找到当前页面的跟布局
View view =
getWindow().getDecorView().getRootView();
//设置缓存
view.setDrawingCacheEnabled(true);
view.buildDrawingCache();
//从缓存中获取当前屏幕的图片
temBitmap = view.getDrawingCache();
//输出到sd卡
if (FileIOUtil.getExistStorage()) {
FileIOUtil.GetInstance().onFolderAnalysis(FileIOUtil.GetInstance().getFilePathAndName());
File file = new File(FileIOUtil.GetInstance().getFilePathAndName());
if (!file.exists()) {
file.createNewFile();
FileOutputStream foStream = new FileOutputStream(file);
pressFormat.PNG, 100, foStream);
foStream.flush();
foStream.close();
} catch (Exception e) {
Log.i(&Show&, e.toString());
2、自定义view控件的截图
自定义view控件都是继承view的吗，那么就有可以获取宽度，高度。生成图片，把它绘制出来的。我拿了直接写的的例子来截图。
//保存自定义view的截图
private void saveCustomViewBitmap() {
//获取自定义view图片的大小
Bitmap temBitmap = Bitmap.createBitmap(mCodeView.getWidth(), mCodeView.getHeight(), Config.ARGB_8888);
//使用Canvas，调用自定义view控件的onDraw方法，绘制图片
Canvas canvas = new Canvas(temBitmap);
mCodeView.onDraw(canvas);
//输出到sd卡
if (FileIOUtil.getExistStorage()) {
FileIOUtil.GetInstance().onFolderAnalysis(FileIOUtil.GetInstance().getFilePathAndName());
File file = new File(FileIOUtil.GetInstance().getFilePathAndName());
if (!file.exists()) {
file.createNewFile();
FileOutputStream foStream = new FileOutputStream(file);
pressFormat.PNG, 100, foStream);
foStream.flush();
foStream.close();
Toast.makeText(MainActivity.this, &截屏文件已保存至& + FileIOUtil.GetInstance().getFilePathAndName(), Toast.LENGTH_LONG).show();
} catch (Exception e) {
Log.i(&Show&, e.toString());
有人根据这种思路，自定义整个布局的view，然后来截图。也是够拼的，我有点不赞成这样使用。
3、基于android ddmlib截屏
这个是java写的一个类，入口是mian函数。那么这种实现方式是要android连接着电脑，还需要android设备调试。这种不多说，搞android开发都懂。太麻烦了，我们也不使用。
package com.example.
import java.io.IOE
import java.text.SimpleDateF
import java.util.D
import com.android.ddmlib.AdbCommandRejectedE
import com.android.ddmlib.DebugB
import com.android.ddmlib.ID
import com.android.ddmlib.RawI
import com.android.ddmlib.TimeoutE
public class ScreenShoddmlib {
private BufferedImage image =
* @param args
public static void main(String[] args) {
// TODO Auto-generated method stub
AndroidDebugBridge.init(false); //
ScreenShoddmlib screenshot = new ScreenShoddmlib();
IDevice device = screenshot.getDevice();
for (int i = 0; i & 10; i++) {
Date date=new Date();
SimpleDateFormat df=new SimpleDateFormat(&MM-dd-HH-mm-ss&);
String nowTime = df.format(date);
screenshot.getScreenShot(device, &Robotium& + nowTime);
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
public void getScreenShot(IDevice device,String filename) {
RawImage rawScreen =
rawScreen = device.getScreenshot();
} catch (TimeoutException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (AdbCommandRejectedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
if (rawScreen != null) {
Boolean landscape =
int width2 = landscape ? rawScreen.height : rawScreen.
int height2 = landscape ? rawScreen.width : rawScreen.
if (image == null) {
image = new BufferedImage(width2, height2,
BufferedImage.TYPE_INT_RGB);
if (image.getHeight() != height2 || image.getWidth() != width2) {
image = new BufferedImage(width2, height2,
BufferedImage.TYPE_INT_RGB);
int index = 0;
int indexInc = rawScreen.bpp && 3;
for (int y = 0; y & rawScreen. y++) {
for (int x = 0; x & rawScreen. x++, index += indexInc) {
int value = rawScreen.getARGB(index);
if (landscape)
image.setRGB(y, rawScreen.width - x - 1, value);
image.setRGB(x, y, value);
ImageIO.write((RenderedImage) image, &PNG&, new File(&D:/&
+ filename + &.jpg&));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
* 获取得到device对象
private IDevice getDevice(){
AndroidDebugBridge bridge = AndroidDebugBridge
.createBridge(&adb&, true);//如果代码有问题请查看API，修改此处的参数值试一下
waitDevicesList(bridge);
IDevice devices[] = bridge.getDevices();
device = devices[0];
* 等待查找device
* @param bridge
private void waitDevicesList(AndroidDebugBridge bridge) {
int count = 0;
while (bridge.hasInitialDeviceList() == false) {
Thread.sleep(500);
} catch (InterruptedException e) {
if (count & 240) {
System.err.print(&等待获取设备超时&);
4、使用adb命令
需要系统权限，在APK中调用&adb shell screencap -pfilepath& 命令
需要获得系统权限：1、 在AndroidManifest.xml文件中添加
2、修改APK为系统权限，将APK放到中编译， 修改Android.mk LOCAL_CERTIFICATE := platform
在这里我要说一下，搞过jni调用就知道Android.mk的作用。此举也是麻烦，效果也不是很好。
public void takeScreenShot(){
String mSavedPath = Environment.getExternalStorageDirectory()+File. separator + &screenshot.png& ;
Runtime. getRuntime().exec(&screencap -p & + mSavedPath);
} catch (Exception e) {
e.printStackTrace();
5、看一下系统截屏是怎样的
相信大家都知道，三星的机子是同时按下 home键 + 电源键 3秒截图。
如果没有home键的机子是按下 音量键向下那个 + 电源键 3秒截图的。
获取物理键盘按下的源码：PhoneWindowManager.java
// Handle special keys.
switch (keyCode) {
case KeyEvent.KEYCODE_VOLUME_DOWN:
case KeyEvent.KEYCODE_VOLUME_UP:
case KeyEvent.KEYCODE_VOLUME_MUTE: {
if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
if (down) {
if (isScreenOn && !mVolumeDownKeyTriggered
&& (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
mVolumeDownKeyTriggered =
mVolumeDownKeyTime = event.getDownTime();
mVolumeDownKeyConsumedByScreenshotChord =
cancelPendingPowerKeyAction();
interceptScreenshotChord();
mVolumeDownKeyTriggered =
cancelPendingScreenshotChordAction();
} else if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
if (down) {
if (isScreenOn && !mVolumeUpKeyTriggered
&& (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
mVolumeUpKeyTriggered =
cancelPendingPowerKeyAction();
cancelPendingScreenshotChordAction();
mVolumeUpKeyTriggered =
cancelPendingScreenshotChordAction();
if (down) {
ITelephony telephonyService = getTelephonyService();
if (telephonyService != null) {
if (telephonyService.isRinging()) {
// If an incoming call is ringing, either VOLUME key means
// &silence ringer&.
We handle these keys here, rather than
// in the InCallScreen, to make sure we'll respond to them
// even if the InCallScreen hasn't come to the foreground yet.
// Look for the DOWN event here, to agree with the &fallback&
// behavior in the InCallScreen.
Log.i(TAG, &interceptKeyBeforeQueueing:&
+ & VOLUME key-down while ringing: Silence ringer!&);
// Silence the ringer.
(It's safe to call this
// even if the ringer has already been silenced.)
telephonyService.silenceRinger();
// And *don't* pass this key thru to the current activity
// (which is probably the InCallScreen.)
result &= ~ACTION_PASS_TO_USER;
if (telephonyService.isOffhook()
&& (result & ACTION_PASS_TO_USER) == 0) {
// If we are in call but we decided not to pass the key to
// the application, handle the volume change here.
handleVolumeKey(AudioManager.STREAM_VOICE_CALL, keyCode);
} catch (RemoteException ex) {
Log.w(TAG, &ITelephony threw RemoteException&, ex);
if (isMusicActive() && (result & ACTION_PASS_TO_USER) == 0) {
// If music is playing but we decided not to pass the key to the
// application, handle the volume change here.
handleVolumeKey(AudioManager.STREAM_MUSIC, keyCode);
case KeyEvent.KEYCODE_ENDCALL: {
result &= ~ACTION_PASS_TO_USER;
if (down) {
ITelephony telephonyService = getTelephonyService();
boolean hungUp =
if (telephonyService != null) {
hungUp = telephonyService.endCall();
} catch (RemoteException ex) {
Log.w(TAG, &ITelephony threw RemoteException&, ex);
interceptPowerKeyDown(!isScreenOn || hungUp);
if (interceptPowerKeyUp(canceled)) {
if ((mEndcallBehavior
& Settings.System.END_BUTTON_BEHAVIOR_HOME) != 0) {
if (goHome()) {
if ((mEndcallBehavior
& Settings.System.END_BUTTON_BEHAVIOR_SLEEP) != 0) {
result = (result & ~ACTION_WAKE_UP) | ACTION_GO_TO_SLEEP;
case KeyEvent.KEYCODE_POWER: {
result &= ~ACTION_PASS_TO_USER;
if (down) {
if (isScreenOn && !mPowerKeyTriggered
&& (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
mPowerKeyTriggered =
mPowerKeyTime = event.getDownTime();
interceptScreenshotChord();
ITelephony telephonyService = getTelephonyService();
boolean hungUp =
if (telephonyService != null) {
if (telephonyService.isRinging()) {
// Pressing Power while there's a ringing incoming
// call should silence the ringer.
telephonyService.silenceRinger();
} else if ((mIncallPowerBehavior
& Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_HANGUP) != 0
&& telephonyService.isOffhook()) {
// Otherwise, if &Power button ends call& is enabled,
// the Power button will hang up any current active call.
hungUp = telephonyService.endCall();
} catch (RemoteException ex) {
Log.w(TAG, &ITelephony threw RemoteException&, ex);
interceptPowerKeyDown(!isScreenOn || hungUp
|| mVolumeDownKeyTriggered || mVolumeUpKeyTriggered);
mPowerKeyTriggered =
cancelPendingScreenshotChordAction();
if (interceptPowerKeyUp(canceled || mPendingPowerKeyUpCanceled)) {
result = (result & ~ACTION_WAKE_UP) | ACTION_GO_TO_SLEEP;
mPendingPowerKeyUpCanceled =
响应截屏的方法：
private void interceptScreenshotChord() {
if (mScreenshotChordEnabled
&& mVolumeDownKeyTriggered && mPowerKeyTriggered && !mVolumeUpKeyTriggered) {
final long now = SystemClock.uptimeMillis();
if (now &= mVolumeDownKeyTime + SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS
&& now &= mPowerKeyTime + SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS) {
mVolumeDownKeyConsumedByScreenshotChord =
cancelPendingPowerKeyAction();
mHandler.postDelayed(mScreenshotChordLongPress, getScreenshotChordLongPressDelay());
private long getScreenshotChordLongPressDelay() {
if (mKeyguardMediator.isShowing()) {
// Double the time it takes to take a screenshot from the keyguard
return (long) (KEYGUARD_SCREENSHOT_CHORD_DELAY_MULTIPLIER *
ViewConfiguration.getGlobalActionKeyTimeout());
return ViewConfiguration.getGlobalActionKeyTimeout();
接受响应的服务
private final Runnable mScreenshotChordLongPress = new Runnable() {
public void run() {
takeScreenshot();
private void takeScreenshot() {
synchronized (mScreenshotLock) {
if (mScreenshotConnection != null) {
ComponentName cn = new ComponentName(&com.android.systemui&,
&com.android.systemui.screenshot.TakeScreenshotService&);
Intent intent = new Intent();
intent.setComponent(cn);
ServiceConnection conn = new ServiceConnection() {
public void onServiceConnected(ComponentName name, IBinder service) {
synchronized (mScreenshotLock) {
if (mScreenshotConnection != this) {
Messenger messenger = new Messenger(service);
Message msg = Message.obtain(null, 1);
final ServiceConnection myConn =
Handler h = new Handler(mHandler.getLooper()) {
public void handleMessage(Message msg) {
synchronized (mScreenshotLock) {
if (mScreenshotConnection == myConn) {
mContext.unbindService(mScreenshotConnection);
mScreenshotConnection =
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;
messenger.send(msg);
} catch (RemoteException e) {
public void onServiceDisconnected(ComponentName name) {}
if (mContext.bindService(
intent, conn, Context.BIND_AUTO_CREATE, UserHandle.USER_CURRENT)) {
mScreenshotConnection =
mHandler.postDelayed(mScreenshotTimeout, 10000);
启动时这个服务ComponentName cn = new ComponentName(&com.android.systemui&,&com.android.systemui.screenshot.TakeScreenshotService&);
package com.android.systemui.
import android.app.S
import android.content.I
import android.os.H
import android.os.IB
import android.os.M
import android.os.M
import android.os.RemoteE
public class TakeScreenshotService extends Service {
private static final String TAG = &TakeScreenshotService&;
private static GlobalScreenshot mS
private Handler mHandler = new Handler() {
public void handleMessage(Message msg) {
switch (msg.what) {
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);
callback.send(reply);
} catch (RemoteException e) {
}, msg.arg1 & 0, msg.arg2 & 0);
public IBinder onBind(Intent intent) {
return new Messenger(mHandler).getBinder();
再往下就是底层库，需要编译出来才能看得到了。这些就先不研究了。
6、还有部分系统源码是截图的
* Copyright (C) 2011 The Android Open Source Project
* Licensed under the Apache License, Version 2.0 (the &License&);
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an &AS IS& BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
package com.android.systemui.
import android.animation.A
import android.animation.AnimatorListenerA
import android.animation.AnimatorS
import android.animation.ValueA
import android.animation.ValueAnimator.AnimatorUpdateL
import android.app.N
import android.app.Notification.BigPictureS
import android.app.NotificationM
import android.app.PendingI
import android.content.ContentR
import android.content.ContentV
import android.content.C
import android.content.I
import android.content.res.R
import android.graphics.B
import android.graphics.C
import android.graphics.ColorM
import android.graphics.ColorMatrixColorF
import android.graphics.M
import android.graphics.P
import android.graphics.PixelF
import android.graphics.PointF;
import android.media.MediaActionS
import android.net.U
import android.os.AsyncT
import android.os.E
import android.os.P
import android.provider.MediaS
import android.util.DisplayM
import android.view.D
import android.view.LayoutI
import android.view.MotionE
import android.view.S
import android.view.V
import android.view.ViewG
import android.view.WindowM
import android.view.animation.I
import android.widget.ImageV
import com.android.systemui.R;
import java.io.F
import java.io.OutputS
import java.text.SimpleDateF
import java.util.D
* POD used in the AsyncTask which saves an image in the background.
class SaveImageInBackgroundData {
Uri imageU
* An AsyncTask that saves an image to the media store in the background.
class SaveImageInBackgroundTask extends AsyncTask {
private static final String SCREENSHOTS_DIR_NAME = &Screenshots&;
private static final String SCREENSHOT_FILE_NAME_TEMPLATE = &Screenshot_%s.png&;
private static final String SCREENSHOT_FILE_PATH_TEMPLATE = &%s/%s/%s&;
private int mNotificationId;
private NotificationManager mNotificationM
private Notification.Builder mNotificationB
private String mImageFileN
private String mImageFileP
private long mImageT
private BigPictureStyle mNotificationS
// WORKAROUND: We want the same notification across screenshots that we update so that we don't
// spam a user's notification drawer.
However, we only show the ticker for the saving state
// and if the ticker text is the same as the previous notification, then it will not show. So
// for now, we just add and remove a space from the ticker text to trigger the animation when
// necessary.
private static boolean mTickerAddS
SaveImageInBackgroundTask(Context context, SaveImageInBackgroundData data,
NotificationManager nManager, int nId) {
Resources r = context.getResources();
// Prepare all the output metadata
mImageTime = System.currentTimeMillis();
String imageDate = new SimpleDateFormat(&yyyy-MM-dd-HH-mm-ss&).format(new Date(mImageTime));
String imageDir = Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_PICTURES).getAbsolutePath();
mImageFileName = String.format(SCREENSHOT_FILE_NAME_TEMPLATE, imageDate);
mImageFilePath = String.format(SCREENSHOT_FILE_PATH_TEMPLATE, imageDir,
SCREENSHOTS_DIR_NAME, mImageFileName);
// Create the large notification icon
int imageWidth = data.image.getWidth();
int imageHeight = data.image.getHeight();
int iconSize = data.iconS
final int shortSide = imageWidth & imageHeight ? imageWidth : imageH
Bitmap preview = Bitmap.createBitmap(shortSide, shortSide, data.image.getConfig());
Canvas c = new Canvas(preview);
Paint paint = new Paint();
ColorMatrix desat = new ColorMatrix();
desat.setSaturation(0.25f);
paint.setColorFilter(new ColorMatrixColorFilter(desat));
Matrix matrix = new Matrix();
matrix.postTranslate((shortSide - imageWidth) / 2,
(shortSide - imageHeight) / 2);
c.drawBitmap(data.image, matrix, paint);
c.drawColor(0x40FFFFFF);
Bitmap croppedIcon = Bitmap.createScaledBitmap(preview, iconSize, iconSize, true);
// Show the intermediate notification
mTickerAddSpace = !mTickerAddS
mNotificationId = nId;
mNotificationManager = nM
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(System.currentTimeMillis());
mNotificationStyle = new Notification.BigPictureStyle()
.bigPicture(preview);
mNotificationBuilder.setStyle(mNotificationStyle);
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(croppedIcon);
// But we still don't set it for the expanded view, allowing the smallIcon to show here.
mNotificationStyle.bigLargeIcon(null);
protected SaveImageInBackgroundData doInBackground(SaveImageInBackgroundData... params) {
if (params.length != 1)
// By default, AsyncTask sets the worker thread to have background thread priority, so bump
// it back up so that we save a little quicker.
Process.setThreadPriority(Process.THREAD_PRIORITY_FOREGROUND);
Context context = params[0].
Bitmap image = params[0].
Resources r = context.getResources();
// Save the screenshot to the MediaStore
ContentValues values = new ContentValues();
ContentResolver resolver = context.getContentResolver();
values.put(MediaStore.Images.ImageColumns.DATA, mImageFilePath);
values.put(MediaStore.Images.ImageColumns.TITLE, mImageFileName);
values.put(MediaStore.Images.ImageColumns.DISPLAY_NAME, mImageFileName);
values.put(MediaStore.Images.ImageColumns.DATE_TAKEN, mImageTime);
values.put(MediaStore.Images.ImageColumns.DATE_ADDED, mImageTime);
values.put(MediaStore.Images.ImageColumns.DATE_MODIFIED, mImageTime);
values.put(MediaStore.Images.ImageColumns.MIME_TYPE, &image/png&);
Uri uri = resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
Intent sharingIntent = new Intent(Intent.ACTION_SEND);
sharingIntent.setType(&image/png&);
sharingIntent.putExtra(Intent.EXTRA_STREAM, uri);
Intent chooserIntent = Intent.createChooser(sharingIntent, null);
chooserIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK
| Intent.FLAG_ACTIVITY_NEW_TASK);
mNotificationBuilder.addAction(R.drawable.ic_menu_share,
r.getString(com.android.internal.R.string.share),
PendingIntent.getActivity(context, 0, chooserIntent,
PendingIntent.FLAG_CANCEL_CURRENT));
OutputStream out = resolver.openOutputStream(uri);
pressFormat.PNG, 100, out);
out.flush();
out.close();
// update file size in the database
values.clear();
values.put(MediaStore.Images.ImageColumns.SIZE, new File(mImageFilePath).length());
resolver.update(uri, values, null, null);
params[0].imageUri =
params[0].result = 0;
} catch (Exception e) {
// IOException/UnsupportedOperationException may be thrown if external storage is not
// mounted
params[0].result = 1;
return params[0];
protected void onPostExecute(SaveImageInBackgroundData params) {
if (params.result & 0) {
// Show a message that we've failed to save the image to disk
GlobalScreenshot.notifyScreenshotError(params.context, mNotificationManager);
// Show the final notification to indicate screenshot saved
Resources r = params.context.getResources();
// Create the intent to show the screenshot in gallery
Intent launchIntent = new Intent(Intent.ACTION_VIEW);
launchIntent.setDataAndType(params.imageUri, &image/png&);
launchIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
mNotificationBuilder
.setContentTitle(r.getString(R.string.screenshot_saved_title))
.setContentText(r.getString(R.string.screenshot_saved_text))
.setContentIntent(PendingIntent.getActivity(params.context, 0, launchIntent, 0))
.setWhen(System.currentTimeMillis())
.setAutoCancel(true);
Notification n = mNotificationBuilder.build();
n.flags &= ~Notification.FLAG_NO_CLEAR;
mNotificationManager.notify(mNotificationId, n);
params.finisher.run();
- Performance when over gl surfaces? Ie. Gallery
- what do we say in the Toast? Which icon do we get if the user uses another
type of gallery?
class GlobalScreenshot {
private static final int SCREENSHOT_NOTIFICATION_ID = 789;
private static final int SCREENSHOT_FLASH_TO_PEAK_DURATION = 130;
private static final int SCREENSHOT_DROP_IN_DURATION = 430;
private static final int SCREENSHOT_DROP_OUT_DELAY = 500;
private static final int SCREENSHOT_DROP_OUT_DURATION = 430;
private static final int SCREENSHOT_DROP_OUT_SCALE_DURATION = 370;
private static final int SCREENSHOT_FAST_DROP_OUT_DURATION = 320;
private static final float BACKGROUND_ALPHA = 0.5f;
private static final float SCREENSHOT_SCALE = 1f;
private static final float SCREENSHOT_DROP_IN_MIN_SCALE = SCREENSHOT_SCALE * 0.725f;
private static final float SCREENSHOT_DROP_OUT_MIN_SCALE = SCREENSHOT_SCALE * 0.45f;
private static final float SCREENSHOT_FAST_DROP_OUT_MIN_SCALE = SCREENSHOT_SCALE * 0.6f;
private static final float SCREENSHOT_DROP_OUT_MIN_SCALE_OFFSET = 0f;
private Context mC
private WindowManager mWindowM
private WindowManager.LayoutParams mWindowLayoutP
private NotificationManager mNotificationM
private Display mD
private DisplayMetrics mDisplayM
private Matrix mDisplayM
private Bitmap mScreenB
private View mScreenshotL
private ImageView mBackgroundV
private ImageView mScreenshotV
private ImageView mScreenshotF
private AnimatorSet mScreenshotA
private int mNotificationIconS
private float mBgP
private float mBgPaddingS
private MediaActionSound mCameraS
* @param context everything needs a context :(
public GlobalScreenshot(Context context) {
Resources r = context.getResources();
mContext =
LayoutInflater layoutInflater = (LayoutInflater)
context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
// Inflate the screenshot layout
mDisplayMatrix = new Matrix();
mScreenshotLayout = layoutInflater.inflate(R.layout.global_screenshot, null);
mBackgroundView = (ImageView) mScreenshotLayout.findViewById(R.id.global_screenshot_background);
mScreenshotView = (ImageView) mScreenshotLayout.findViewById(R.id.global_screenshot);
mScreenshotFlash = (ImageView) mScreenshotLayout.findViewById(R.id.global_screenshot_flash);
mScreenshotLayout.setFocusable(true);
mScreenshotLayout.setOnTouchListener(new View.OnTouchListener() {
public boolean onTouch(View v, MotionEvent event) {
// Intercept and ignore all touch events
// Setup the window that we are going to use
mWindowLayoutParams = new WindowManager.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT, 0, 0,
WindowManager.LayoutParams.TYPE_SECURE_SYSTEM_OVERLAY,
WindowManager.LayoutParams.FLAG_FULLSCREEN
| WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED
| WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
| WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED,
PixelFormat.TRANSLUCENT);
mWindowLayoutParams.setTitle(&ScreenshotAnimation&);
mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
mNotificationManager =
(NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
mDisplay = mWindowManager.getDefaultDisplay();
mDisplayMetrics = new DisplayMetrics();
mDisplay.getRealMetrics(mDisplayMetrics);
// Get the various target sizes
mNotificationIconSize =
r.getDimensionPixelSize(android.R.dimen.notification_large_icon_height);
// Scale has to account for both sides of the bg
mBgPadding = (float) r.getDimensionPixelSize(R.dimen.global_screenshot_bg_padding);
mBgPaddingScale = mBgPadding /
mDisplayMetrics.widthP
// Setup the Camera shutter sound
mCameraSound = new MediaActionSound();
mCameraSound.load(MediaActionSound.SHUTTER_CLICK);
* Creates a new worker thread and saves the screenshot to the media store.
private void saveScreenshotInWorkerThread(Runnable finisher) {
SaveImageInBackgroundData data = new SaveImageInBackgroundData();
data.context = mC
data.image = mScreenB
data.iconSize = mNotificationIconS
data.finisher =
new SaveImageInBackgroundTask(mContext, data, mNotificationManager,
SCREENSHOT_NOTIFICATION_ID).execute(data);
* @return the current display rotation in degrees
private float getDegreesForRotation(int value) {
switch (value) {
case Surface.ROTATION_90:
return 360f - 90f;
case Surface.ROTATION_180:
return 360f - 180f;
case Surface.ROTATION_270:
return 360f - 270f;
return 0f;
* 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();
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 =
// Optimizations
mScreenBitmap.setHasAlpha(false);
mScreenBitmap.prepareToDraw();
// 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();
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() {
public void onAnimationEnd(Animator animation) {
// Save the screenshot once we have a bit of time now
saveScreenshotInWorkerThread(finisher);
mWindowManager.removeView(mScreenshotLayout);
mScreenshotLayout.post(new Runnable() {
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();
private ValueAnimator createScreenshotDropInAnimation() {
final float flashPeakDurationPct = ((float) (SCREENSHOT_FLASH_TO_PEAK_DURATION)
/ SCREENSHOT_DROP_IN_DURATION);
final float flashDurationPct = 2f * flashPeakDurationP
final Interpolator flashAlphaInterpolator = new Interpolator() {
public float getInterpolation(float x) {
// Flash the flash view in and out quickly
if (x &= flashDurationPct) {
return (float) Math.sin(Math.PI * (x / flashDurationPct));
final Interpolator scaleInterpolator = new Interpolator() {
public float getInterpolation(float x) {
// We start scaling when the flash is at it's peak
if (x & flashPeakDurationPct) {
return (x - flashDurationPct) / (1f - flashDurationPct);
ValueAnimator anim = ValueAnimator.ofFloat(0f, 1f);
anim.setDuration(SCREENSHOT_DROP_IN_DURATION);
anim.addListener(new AnimatorListenerAdapter() {
public void onAnimationStart(Animator animation) {
mBackgroundView.setAlpha(0f);
mBackgroundView.setVisibility(View.VISIBLE);
mScreenshotView.setAlpha(0f);
mScreenshotView.setTranslationX(0f);
mScreenshotView.setTranslationY(0f);
mScreenshotView.setScaleX(SCREENSHOT_SCALE + mBgPaddingScale);
mScreenshotView.setScaleY(SCREENSHOT_SCALE + mBgPaddingScale);
mScreenshotView.setVisibility(View.VISIBLE);
mScreenshotFlash.setAlpha(0f);
mScreenshotFlash.setVisibility(View.VISIBLE);
public void onAnimationEnd(android.animation.Animator animation) {
mScreenshotFlash.setVisibility(View.GONE);
anim.addUpdateListener(new AnimatorUpdateListener() {
public void onAnimationUpdate(ValueAnimator animation) {
float t = (Float) animation.getAnimatedValue();
float scaleT = (SCREENSHOT_SCALE + mBgPaddingScale)
- scaleInterpolator.getInterpolation(t)
* (SCREENSHOT_SCALE - SCREENSHOT_DROP_IN_MIN_SCALE);
mBackgroundView.setAlpha(scaleInterpolator.getInterpolation(t) * BACKGROUND_ALPHA);
mScreenshotView.setAlpha(t);
mScreenshotView.setScaleX(scaleT);
mScreenshotView.setScaleY(scaleT);
mScreenshotFlash.setAlpha(flashAlphaInterpolator.getInterpolation(t));
private ValueAnimator createScreenshotDropOutAnimation(int w, int h, boolean statusBarVisible,
boolean navBarVisible) {
ValueAnimator anim = ValueAnimator.ofFloat(0f, 1f);
anim.setStartDelay(SCREENSHOT_DROP_OUT_DELAY);
anim.addListener(new AnimatorListenerAdapter() {
public void onAnimationEnd(Animator animation) {
mBackgroundView.setVisibility(View.GONE);
mScreenshotView.setVisibility(View.GONE);
mScreenshotView.setLayerType(View.LAYER_TYPE_NONE, null);
if (!statusBarVisible || !navBarVisible) {
// There is no status bar/nav bar, so just fade the screenshot away in place
anim.setDuration(SCREENSHOT_FAST_DROP_OUT_DURATION);
anim.addUpdateListener(new AnimatorUpdateListener() {
public void onAnimationUpdate(ValueAnimator animation) {
float t = (Float) animation.getAnimatedValue();
float scaleT = (SCREENSHOT_DROP_IN_MIN_SCALE + mBgPaddingScale)
- t * (SCREENSHOT_DROP_IN_MIN_SCALE - SCREENSHOT_FAST_DROP_OUT_MIN_SCALE);
mBackgroundView.setAlpha((1f - t) * BACKGROUND_ALPHA);
mScreenshotView.setAlpha(1f - t);
mScreenshotView.setScaleX(scaleT);
mScreenshotView.setScaleY(scaleT);
// In the case where there is a status bar, animate to the origin of the bar (top-left)
final float scaleDurationPct = (float) SCREENSHOT_DROP_OUT_SCALE_DURATION
/ SCREENSHOT_DROP_OUT_DURATION;
final Interpolator scaleInterpolator = new Interpolator() {
public float getInterpolation(float x) {
if (x & scaleDurationPct) {
// Decelerate, and scale the input accordingly
return (float) (1f - Math.pow(1f - (x / scaleDurationPct), 2f));
return 1f;
// Determine the bounds of how to scale
float halfScreenWidth = (w - 2f * mBgPadding) / 2f;
float halfScreenHeight = (h - 2f * mBgPadding) / 2f;
final float offsetPct = SCREENSHOT_DROP_OUT_MIN_SCALE_OFFSET;
final PointF finalPos = new PointF(
-halfScreenWidth + (SCREENSHOT_DROP_OUT_MIN_SCALE + offsetPct) * halfScreenWidth,
-halfScreenHeight + (SCREENSHOT_DROP_OUT_MIN_SCALE + offsetPct) * halfScreenHeight);
// Animate the screenshot to the status bar
anim.setDuration(SCREENSHOT_DROP_OUT_DURATION);
anim.addUpdateListener(new AnimatorUpdateListener() {
public void onAnimationUpdate(ValueAnimator animation) {
float t = (Float) animation.getAnimatedValue();
float scaleT = (SCREENSHOT_DROP_IN_MIN_SCALE + mBgPaddingScale)
- scaleInterpolator.getInterpolation(t)
* (SCREENSHOT_DROP_IN_MIN_SCALE - SCREENSHOT_DROP_OUT_MIN_SCALE);
mBackgroundView.setAlpha((1f - t) * BACKGROUND_ALPHA);
mScreenshotView.setAlpha(1f - scaleInterpolator.getInterpolation(t));
mScreenshotView.setScaleX(scaleT);
mScreenshotView.setScaleY(scaleT);
mScreenshotView.setTranslationX(t * finalPos.x);
mScreenshotView.setTranslationY(t * finalPos.y);
static void notifyScreenshotError(Context context, NotificationManager nManager) {
Resources r = context.getResources();
// Clear all existing notification, compose the new notification and show it
Notification n = 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())
.setAutoCancel(true)
.getNotification();
nManager.notify(SCREENSHOT_NOTIFICATION_ID, n);
可以从这部分源码中，去寻找解决办法。
其中有一个很重要的方法就是
mScreenBitmap = Surface.screenshot((int) dims[0], (int) dims[1]);
这个是可以截图的，但是是隐藏的代码，不提供外面调用的。
注意需要在AndroidManifest.xml中加入代码：android:sharedUserId=&android.uid.system& 进行后续开发。
先到这里，有时间后续再从这里往下研究。各位也可以yanjiuyxia