Wie Sie programmgesteuert nehmen Sie einen screenshot auf Android?

Hier ist der code, der erlaubt, dass meine screenshot gespeichert werden auf einer SD-Karte und später für was auch immer Ihre Bedürfnisse sind:

Ersten, müssen Sie eine entsprechende Berechtigung, die Datei zu speichern:

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

- Und dies ist der code (in eine Tätigkeit):

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

Und dies ist, wie Sie können, öffnen Sie die zuletzt erzeugte Bild:

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

Wenn Sie wollen verwenden Sie diese auf fragment-Ansicht verwenden Sie dann:

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

statt

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

auf takeScreenshot() Funktion

Hinweis:

Diese Lösung funktioniert nicht, wenn das Dialogfeld enthält eine Oberfläche anzeigen. Für details überprüfen Sie bitte die Antwort auf folgende Frage:

Android Screenshot der Surface View Zeigt Schwarzen Bildschirm

Hinweis: funktioniert nur für verwurzelt Telefon

Programmgesteuert können Sie adb shell /system/bin/screencap -p /sdcard/img.png wie unten

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

dann Lesen img.png als Bitmap und nutzen Sie es als Ihr Wunsch.

Keine root-Berechtigung oder keine große Kodierung benötigt wird für diese Methode.

Auf adb shell mit nachstehenden Befehl können Sie take screen shot.

input keyevent 120

Dieser Befehl nicht erforderlich root-Berechtigung, so gleichen Sie können ausführen von java-code aus der android-Anwendung auch.

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

Mehr über keyevent-code in android sehen http://developer.android.com/reference/android/view/KeyEvent.html

Hier haben wir verwendet. KEYCODE_SYSRQ sein Wert ist 120 und für den System-Request - /Druck-Taste.

Als CJBS sagte, Das output-Bild gespeichert werden /sdcard/Pictures/Screenshots

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

Fügen Sie die permission im manifest

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

Zur Unterstützung Marshmallow oder höher Versionen, bitte fügen Sie den untenstehenden code in der activity onCreate-Methode

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

Meine Lösung ist:

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

und

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

Bilder sind gespeichert in dem externen Speicher Ordner.

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

}

HINZUFÜGEN GENEHMIGUNG

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

Können Sie versuchen, so etwas zu tun,

Immer eine bitmap-cache von einem layout-oder Entwurfsansicht, indem es so etwas wie
Zuerst musst du setDrawingCacheEnabled zu einem layout(ein linearlayout oder relativelayout, oder ein Blick)

dann

Bitmap bm = layout.getDrawingCache()

Dann tun Sie, was Sie wollen mit der bitmap. Entweder drehen Sie es in eine image-Datei, oder senden Sie die bitmap-uri woanders hin.

Kurzen Weg

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

Wenn Sie möchten, nehmen screenshot aus fragment als Folge dieser:

1. Überschreiben 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. Logik für die Aufnahme screenshot:

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

3. Methode 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. Methode 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. Methode 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;
      }

Für Aktivität können Sie einfach View v1 = getWindow().getDecorView().getRootView(); statt mView

Die parameter-Ansicht ist die root-layout-Objekt.

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

Für system-Anwendungen nur!

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

Hinweis: System-Anwendungen, die nicht brauchen, um ausführen, "su", um diesen Befehl auszuführen.

Für Die Ganze Seite Scrollen Screenshot

Wenn Sie möchten, erfassen Sie eine vollständige Ansicht screenshot (enthält eine scrollview oder so) dann ein Häkchen an dieser Bibliothek

https://github.com/peter1492/LongScreenshot

Alles, was Sie tun müssen ist, importieren Sie die Gradel, und erstellen Sie ein Objekt der BigScreenshot

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

Einen Rückruf erhalten mit der bitmap der Screenshots getroffen, während automatisch scrollen durch die Ansicht der Gruppe und am Ende zusammengebaut.

@Override public void getScreenshot(Bitmap bitmap) {}

Die gespeichert werden können, um die Galerie oder was auch immer die Nutzung ist notwendig, Ihren nach