如何以编程方式在Android上截屏？

如何通过代码从电话屏幕的选定区域截屏，而不是通过任何程序截屏？

这是使我的屏幕截图存储在SD卡上，以后可用于您需要的代码：

首先，您需要添加适当的权限来保存文件：

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

这是代码（在Activity中运行）：

private void takeScreenshot() {
    Date now = new Date();
    android.text.format.DateFormat.format("yyyy-MM-dd_hh:mm:ss", now);

    try {
        // image naming and path  to include sd card  appending name you choose for file
        String mPath = Environment.getExternalStorageDirectory().toString() + "/" + now + ".jpg";

        // create bitmap screen capture
        View v1 = getWindow().getDecorView().getRootView();
        v1.setDrawingCacheEnabled(true);
        Bitmap bitmap = Bitmap.createBitmap(v1.getDrawingCache());
        v1.setDrawingCacheEnabled(false);

        File imageFile = new File(mPath);

        FileOutputStream outputStream = new FileOutputStream(imageFile);
        int quality = 100;
        bitmap.compress(Bitmap.CompressFormat.JPEG, quality, outputStream);
        outputStream.flush();
        outputStream.close();

        openScreenshot(imageFile);
    } catch (Throwable e) {
        // Several error may come out with file handling or DOM
        e.printStackTrace();
    }
}

这是打开最近生成的图像的方法：

private void openScreenshot(File imageFile) {
    Intent intent = new Intent();
    intent.setAction(Intent.ACTION_VIEW);
    Uri uri = Uri.fromFile(imageFile);
    intent.setDataAndType(uri, "image/*");
    startActivity(intent);
}

如果要在片段视图上使用此功能，请使用：

View v1 = getActivity().getWindow().getDecorView().getRootView();

代替

View v1 = getWindow().getDecorView().getRootView();

在takeScreenshot（）函数上

注意事项：

如果对话框包含表面视图，则此解决方案不起作用。有关详细信息，请检查以下问题的答案：

Android拍摄Surface View屏幕截图显示黑屏

调用此方法，并传入要截屏的最外面的ViewGroup：

public Bitmap screenShot(View view) {
    Bitmap bitmap = Bitmap.createBitmap(view.getWidth(),
            view.getHeight(), Config.ARGB_8888);
    Canvas canvas = new Canvas(bitmap);
    view.draw(canvas);
    return bitmap;
}

注意：仅适用于根电话

以编程方式，您可以adb shell /system/bin/screencap -p /sdcard/img.png按以下方式运行

Process sh = Runtime.getRuntime().exec("su", null,null);
OutputStream os = sh.getOutputStream();
os.write(("/system/bin/screencap -p " + "/sdcard/img.png").getBytes("ASCII"));
os.flush();
os.close();
sh.waitFor();    

然后阅读img.png并按Bitmap您的意愿使用。

编辑：怜悯唐装。在2010年，我回答了这个问题。

所有允许截图的程序都只能在有根手机上运行。

此方法不需要root许可或不需要大的编码。

在adb shell上，使用以下命令可以进行屏幕截图。

input keyevent 120

此命令不需要任何root权限，因此您也可以从android应用程序的java代码执行相同的命令。

Process process;
process = Runtime.getRuntime().exec("input keyevent 120");

有关android中的keyevent代码的更多信息，请参见http://developer.android.com/reference/android/view/KeyEvent.html

这里我们用过。 KEYCODE_SYSRQ，其值为120，用于系统请求/打印屏幕键。

正如CJBS所说，输出图片将保存在/ sdcard / Pictures / Screenshots中

Mualig的回答很好，但是我遇到了Ewoks所描述的相同问题，但我没有得到背景知识。因此有时效果不错，有时我会在黑色背景上出现黑色文字（取决于主题）。

该解决方案主要基于Mualig代码和我在Robotium中找到的代码。我通过直接调用draw方法来放弃使用绘图缓存。在此之前，我将尝试先从当前活动中获取背景可绘制对象。

// Some constants
final static String SCREENSHOTS_LOCATIONS = Environment.getExternalStorageDirectory().toString() + "/screenshots/";

// Get device dimmensions
Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);

// Get root view
View view = mCurrentUrlMask.getRootView();

// Create the bitmap to use to draw the screenshot
final Bitmap bitmap = Bitmap.createBitmap(size.x, size.y, Bitmap.Config.ARGB_4444);
final Canvas canvas = new Canvas(bitmap);

// Get current theme to know which background to use
final Activity activity = getCurrentActivity();
final Theme theme = activity.getTheme();
final TypedArray ta = theme
    .obtainStyledAttributes(new int[] { android.R.attr.windowBackground });
final int res = ta.getResourceId(0, 0);
final Drawable background = activity.getResources().getDrawable(res);

// Draw background
background.draw(canvas);

// Draw views
view.draw(canvas);

// Save the screenshot to the file system
FileOutputStream fos = null;
try {
    final File sddir = new File(SCREENSHOTS_LOCATIONS);
    if (!sddir.exists()) {
        sddir.mkdirs();
    }
    fos = new FileOutputStream(SCREENSHOTS_LOCATIONS
            + System.currentTimeMillis() + ".jpg");
    if (fos != null) {
        if (!bitmap.compress(Bitmap.CompressFormat.JPEG, 90, fos)) {
            Log.d(LOGTAG, "Compress/Write failed");
        }
        fos.flush();
        fos.close();
    }

} catch (FileNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

private void captureScreen() {
    View v = getWindow().getDecorView().getRootView();
    v.setDrawingCacheEnabled(true);
    Bitmap bmp = Bitmap.createBitmap(v.getDrawingCache());
    v.setDrawingCacheEnabled(false);
    try {
        FileOutputStream fos = new FileOutputStream(new File(Environment
                .getExternalStorageDirectory().toString(), "SCREEN"
                + System.currentTimeMillis() + ".png"));
        bmp.compress(CompressFormat.PNG, 100, fos);
        fos.flush();
        fos.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

在清单中添加权限

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

对于支持棉花糖或更高版本，请在活动onCreate方法中添加以下代码

ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},00);

作为参考，捕获屏幕（而不仅仅是您的应用活动）的一种方法是捕获帧缓冲区（设备/ dev / graphics / fb0）。为此，您必须具有root特权，或者您的应用程序必须是具有签名权限的应用程序（“仅当发出请求的应用程序使用与声明该权限的应用程序相同的证书的系统才会授予该权限”）-除非您编译自己的ROM，否则可能性很小。

从我测试过的两个设备中捕获的每个帧缓冲区都恰好包含一个屏幕截图。人们报告说它包含更多，我想这取决于帧/显示器的大小。

我试图连续读取帧缓冲区，但似乎返回固定数量的已读取字节。在我的情况下，这是（3 410 432）字节，足以存储854 * 480 RGBA（3 279 360字节）的显示帧。是的，从fb0输出的二进制帧是RGBA在我的设备中。这很可能取决于设备。这对您进行解码很重要=）

在我的设备中，/ dev / graphics / fb0权限是允许的，因此只有root用户和来自组图形的用户才能读取fb0。

图形是一个受限制的组，因此您可能只能使用su命令通过有根电话访问fb0。

Android应用具有用户ID（uid）= app _ ##和组ID（guid）= app _ ##。

亚行外壳有uid = shell和guid = shell，比应用程序具有更多的权限。您实际上可以在/system/permissions/platform.xml中检查那些权限

这意味着您可以在没有root的情况下在adb shell中读取fb0，但在没有root的应用程序中将无法读取它。

另外，在AndroidManifest.xml上授予READ_FRAME_BUFFER和/或ACCESS_SURFACE_FLINGER权限对常规应用程序无效，因为它们仅适用于“ 签名 ”应用程序。

还要检查此关闭的线程以获取更多详细信息。

我的解决方案是：

public static Bitmap loadBitmapFromView(Context context, View v) {
    DisplayMetrics dm = context.getResources().getDisplayMetrics(); 
    v.measure(MeasureSpec.makeMeasureSpec(dm.widthPixels, MeasureSpec.EXACTLY),
            MeasureSpec.makeMeasureSpec(dm.heightPixels, MeasureSpec.EXACTLY));
    v.layout(0, 0, v.getMeasuredWidth(), v.getMeasuredHeight());
    Bitmap returnedBitmap = Bitmap.createBitmap(v.getMeasuredWidth(),
            v.getMeasuredHeight(), Bitmap.Config.ARGB_8888);
    Canvas c = new Canvas(returnedBitmap);
    v.draw(c);

    return returnedBitmap;
}

和

public void takeScreen() {
    Bitmap bitmap = ImageUtils.loadBitmapFromView(this, view); //get Bitmap from the view
    String mPath = Environment.getExternalStorageDirectory() + File.separator + "screen_" + System.currentTimeMillis() + ".jpeg";
    File imageFile = new File(mPath);
    OutputStream fout = null;
    try {
        fout = new FileOutputStream(imageFile);
        bitmap.compress(Bitmap.CompressFormat.JPEG, 90, fout);
        fout.flush();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        fout.close();
    }
}

图像保存在外部存储文件夹中。

您可以尝试以下库：http : //code.google.com/p/android-screenshot-library/ Android屏幕截图库（ASL）可以以编程方式从Android设备捕获屏幕截图，而无需具有root用户访问权限。相反，ASL使用在后台运行的本机服务，该服务在每次设备启动时通过Android调试桥（ADB）启动。

基于上面@JustinMorris和@NiravDangi的答案https://stackoverflow.com/a/8504958/2232148，我们必须获取视图的背景和前景，并像这样组装它们：

public static Bitmap takeScreenshot(View view, Bitmap.Config quality) {
    Bitmap bitmap = Bitmap.createBitmap(view.getWidth(), view.getHeight(), quality);
    Canvas canvas = new Canvas(bitmap);

    Drawable backgroundDrawable = view.getBackground();
    if (backgroundDrawable != null) {
        backgroundDrawable.draw(canvas);
    } else {
        canvas.drawColor(Color.WHITE);
    }
    view.draw(canvas);

    return bitmap;
}

quality参数采用Bitmap.Config常量，通常为Bitmap.Config.RGB_565或Bitmap.Config.ARGB_8888。

public class ScreenShotActivity extends Activity{

private RelativeLayout relativeLayout;
private Bitmap myBitmap;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    relativeLayout = (RelativeLayout)findViewById(R.id.relative1);
    relativeLayout.post(new Runnable() {
        public void run() {

            //take screenshot
            myBitmap = captureScreen(relativeLayout);

            Toast.makeText(getApplicationContext(), "Screenshot captured..!", Toast.LENGTH_LONG).show();

            try {
                if(myBitmap!=null){
                    //save image to SD card
                    saveImage(myBitmap);
                }
                Toast.makeText(getApplicationContext(), "Screenshot saved..!", Toast.LENGTH_LONG).show();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    });

}

public static Bitmap captureScreen(View v) {

    Bitmap screenshot = null;
    try {

        if(v!=null) {

            screenshot = Bitmap.createBitmap(v.getMeasuredWidth(),v.getMeasuredHeight(), Config.ARGB_8888);
            Canvas canvas = new Canvas(screenshot);
            v.draw(canvas);
        }

    }catch (Exception e){
        Log.d("ScreenShotActivity", "Failed to capture screenshot because:" + e.getMessage());
    }

    return screenshot;
}

public static void saveImage(Bitmap bitmap) throws IOException{

    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    bitmap.compress(Bitmap.CompressFormat.PNG, 40, bytes);
    File f = new File(Environment.getExternalStorageDirectory() + File.separator + "test.png");
    f.createNewFile();
    FileOutputStream fo = new FileOutputStream(f);
    fo.write(bytes.toByteArray());
    fo.close();
}

}

添加权限

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

您可以尝试做这样的事情，

通过执行诸如“首先要获得”这样的操作，从布局或视图中获取位图缓存 setDrawingCacheEnabled布局”（线性布局或相对布局，或视图）之类的操作来

然后

Bitmap bm = layout.getDrawingCache()

然后，您可以对位图进行任何操作。要么将其转换为图像文件，要么将位图的uri发送到其他地方。

对于那些想要捕获GLSurfaceView的人，getDrawingCache或“绘制到画布”方法将不起作用。

渲染帧后，您必须读取OpenGL帧缓冲区的内容。这是一个很好的答案在这里

我创建了一个简单的库，该库从中获取了屏幕截图，View并为您提供了位图对象或将其直接保存到所需的任何路径

https://github.com/abdallahalaraby/Blink

捷径是

FrameLayout layDraw = (FrameLayout) findViewById(R.id.layDraw); /*Your root view to be part of screenshot*/
layDraw.buildDrawingCache();
Bitmap bmp = layDraw.getDrawingCache();

只是扩展了taraloca的答案。您必须添加以下代码行才能使其正常运行。我已将图像名称设为静态。如果需要动态图像名称，请确保使用taraloca的timestamp变量。

    // Storage Permissions
private static final int REQUEST_EXTERNAL_STORAGE = 1;
private static String[] PERMISSIONS_STORAGE = {
        Manifest.permission.READ_EXTERNAL_STORAGE,
        Manifest.permission.WRITE_EXTERNAL_STORAGE
};

private void verifyStoragePermissions() {
    // Check if we have write permission
    int permission = ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE);

    if (permission != PackageManager.PERMISSION_GRANTED) {
        // We don't have permission so prompt the user
        ActivityCompat.requestPermissions(this, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
    }else{
        takeScreenshot();
    }
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);

    if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
        if (requestCode == REQUEST_EXTERNAL_STORAGE) {
            takeScreenshot();
        }
    }
}

在AndroidManifest.xml文件中，必须输入以下内容：

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

如果要从中获取屏幕截图，请fragment 按照以下步骤操作：

1. 覆写 onCreateView()：

            @Override
           public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                    Bundle savedInstanceState) {
               // Inflate the layout for this fragment
               View view = inflater.inflate(R.layout.fragment_one, container, false);
               mView = view;
           }

2. 截图的逻辑：

    button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        View view =  mView.findViewById(R.id.scrollView1);
         shareScreenShotM(view, (NestedScrollView) view); 
    }

3. 方法shareScreenShotM)()：

   public void shareScreenShotM(View view, NestedScrollView scrollView){
   
        bm = takeScreenShot(view,scrollView);  //method to take screenshot
       File file = savePic(bm);  // method to save screenshot in phone.
       }

4. 方法takeScreenShot（）：

            public Bitmap takeScreenShot(View u, NestedScrollView z){
   
               u.setDrawingCacheEnabled(true);
               int totalHeight = z.getChildAt(0).getHeight();
               int totalWidth = z.getChildAt(0).getWidth();
   
               Log.d("yoheight",""+ totalHeight);
               Log.d("yowidth",""+ totalWidth);
               u.layout(0, 0, totalWidth, totalHeight);
               u.buildDrawingCache();
               Bitmap b = Bitmap.createBitmap(u.getDrawingCache());
               u.setDrawingCacheEnabled(false);
               u.destroyDrawingCache();
                return b;
           }

5. 方法savePic（）：

    public static File savePic(Bitmap bm){
   
           ByteArrayOutputStream bytes = new ByteArrayOutputStream();
           bm.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
            File sdCardDirectory =  new File(Environment.getExternalStorageDirectory() + "/Foldername");
   
          if (!sdCardDirectory.exists()) {
               sdCardDirectory.mkdirs();
         }
          //  File file = new File(dir, fileName);
         try {
            file = new File(sdCardDirectory, Calendar.getInstance()
               .getTimeInMillis() + ".jpg");
           file.createNewFile();
           new FileOutputStream(file).write(bytes.toByteArray());
           Log.d("Fabsolute", "File Saved::--->" + file.getAbsolutePath());
            Log.d("Sabsolute", "File Saved::--->" + sdCardDirectory.getAbsolutePath());
        } catch (IOException e) {
             e.printStackTrace();
         }
        return file;
      }

对于活动，您可以简单地使用View v1 = getWindow().getDecorView().getRootView();而不是mView

此问题的大多数答案使用Canvas绘图方法或绘图缓存方法。但是，View.setDrawingCache()API 28中不推荐使用该方法。当前，推荐的用于制作屏幕截图的API是PixelCopyAPI 24中可用的类（但是Window可以从API 26 == Android 8.0 Oreo中获得接受参数的方法）。这是用于检索的示例Kotlin代码Bitmap：

@RequiresApi(Build.VERSION_CODES.O)
fun saveScreenshot(view: View) {
    val window = (view.context as Activity).window
    if (window != null) {
        val bitmap = Bitmap.createBitmap(view.width, view.height, Bitmap.Config.ARGB_8888)
        val locationOfViewInWindow = IntArray(2)
        view.getLocationInWindow(locationOfViewInWindow)
        try {
            PixelCopy.request(window, Rect(locationOfViewInWindow[0], locationOfViewInWindow[1], locationOfViewInWindow[0] + view.width, locationOfViewInWindow[1] + view.height), bitmap, { copyResult ->
                if (copyResult == PixelCopy.SUCCESS) {
                    saveBitmap(bitmap)
                }
                // possible to handle other result codes ...
            }, Handler())
        } catch (e: IllegalArgumentException) {
            // PixelCopy may throw IllegalArgumentException, make sure to handle it
        }
    }
}

仅用于系统应用程序！

Process process;
process = Runtime.getRuntime().exec("screencap -p " + outputPath);
process.waitFor();

注意：系统应用程序无需运行“ su”即可执行此命令。

参数视图是根布局对象。

public static Bitmap screenShot(View view) {
                    Bitmap bitmap = null;
                    if (view.getWidth() > 0 && view.getHeight() > 0) {
                        bitmap = Bitmap.createBitmap(view.getWidth(),
                                view.getHeight(), Bitmap.Config.ARGB_8888);
                        Canvas canvas = new Canvas(bitmap);
                        view.draw(canvas);
                    }
                    return bitmap;
                }

对于全页滚动截图

如果要捕获完整的View屏幕截图（其中包含滚动视图左右），请在此库中进行检查

https://github.com/peter1492/LongScreenshot

您要做的就是导入Gradel，并创建一个BigScreenshot对象

BigScreenshot longScreenshot = new BigScreenshot(this, x, y);

在自动滚动浏览整个屏幕视图组并最终组装在一起时，将收到带有截屏的位图的回调。

@Override public void getScreenshot(Bitmap bitmap) {}

可以将其保存到图库中，也可以在以后使用

拍摄android中视图的屏幕截图。

public static Bitmap getViewBitmap(View v) {
    v.clearFocus();
    v.setPressed(false);

    boolean willNotCache = v.willNotCacheDrawing();
    v.setWillNotCacheDrawing(false);

    int color = v.getDrawingCacheBackgroundColor();
    v.setDrawingCacheBackgroundColor(0);

    if (color != 0) {
        v.destroyDrawingCache();
    }
    v.buildDrawingCache();
    Bitmap cacheBitmap = v.getDrawingCache();
    if (cacheBitmap == null) {
        return null;
    }

    Bitmap bitmap = Bitmap.createBitmap(cacheBitmap);

    v.destroyDrawingCache();
    v.setWillNotCacheDrawing(willNotCache);
    v.setDrawingCacheBackgroundColor(color);

    return bitmap;
}

如果要捕获视图或布局（例如RelativeLayout或LinearLayout等），请使用以下代码：

LinearLayout llMain = (LinearLayout) findViewById(R.id.linearlayoutMain);
Bitmap bm = loadBitmapFromView(llMain);

现在您可以通过以下方式将此位图保存在设备存储中：

FileOutputStream outStream = null;
File f=new File(Environment.getExternalStorageDirectory()+"/Screen Shots/");
f.mkdir();
String extStorageDirectory = f.toString();
File file = new File(extStorageDirectory, "my new screen shot");
pathOfImage = file.getAbsolutePath();
try {
    outStream = new FileOutputStream(file);
    bm.compress(Bitmap.CompressFormat.PNG, 100, outStream);
    Toast.makeText(getApplicationContext(), "Saved at "+f.getAbsolutePath(), Toast.LENGTH_LONG).show();
    addImageGallery(file);
    //mail.setEnabled(true);
    flag=true;
} catch (FileNotFoundException e) {e.printStackTrace();}
try {
    outStream.flush();
    outStream.close();
} catch (IOException e) {e.printStackTrace();}