Android--截屏（支持Android7.1.1，无需root）-低调大师

Android--截屏（支持Android7.1.1，无需root）

2018-07-02 947

import android.Manifest;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.media.projection.MediaProjectionManager;
import android.os.Build;
import android.os.Bundle;
import android.support.annotation.RequiresApi;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;

import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity {
    MediaProjectionManager mediaProjectionManager;
    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        checkPermission();

        mediaProjectionManager = (MediaProjectionManager) getApplication().getSystemService(Context.MEDIA_PROJECTION_SERVICE);
        startActivityForResult(mediaProjectionManager.createScreenCaptureIntent(), 1);

        final Button button = findViewById(R.id.bt_screenshot);
        final ImageView imageView = findViewById(R.id.img_display);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (MyApplication.mediaProjection != null) {
                    MyApplication.time = System.currentTimeMillis();
                    Bitmap bitmap = CreateBitmap.getInstance(MainActivity.this, true, null, "null").getBitmap();
                    if (bitmap == null) {
                        Log.i("img", "bitmap为空");
                    } else {
                        imageView.setBackground(new BitmapDrawable(null, bitmap));
                    }
                } else {
                    Log.i("img", "未获取到截屏权限");
                }
            }
        });

    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        MyApplication.mediaProjection = mediaProjectionManager.getMediaProjection(resultCode, data);
    }

    public void checkPermission() {
        final List<String> permissionsList = new ArrayList<>();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if ((checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)) {
                permissionsList.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
            } else {
            }

            if (permissionsList.size() != 0) {
                requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
                        100);
            }
        }
    }

    @RequiresApi(api = Build.VERSION_CODES.M)
    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        if (requestCode == 100) {
            if (grantResults.length > 0 && (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED)) {
            } else {
                Log.i("img", "未获取权限");
            }
        }///instant-run
    }

}

import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.PixelFormat;
import android.hardware.display.DisplayManager;
import android.hardware.display.VirtualDisplay;
import android.media.Image;
import android.media.ImageReader;
import android.media.projection.MediaProjection;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.support.annotation.RequiresApi;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.WindowManager;
import android.widget.Toast;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import static android.content.Context.WINDOW_SERVICE;

/**
 * Created by Administrator on 2017/3/16.
 */

public class CreateBitmap {
    private static MediaProjection mediaProjection = MyApplication.mediaProjection;
    private static ImageReader mImageReader;
    private static VirtualDisplay virtualDisplay1;
    private static DisplayMetrics displayMetrics = new DisplayMetrics();
    private static WindowManager windowManager;
    private static Bitmap bmp, bitmap;
    private static Image image;
    private static int width;
    private static int height;
    private static int pixelStride;
    private static int rowStride;
    private static int rowPadding;
    private static String path, name;
    private static int screenwidth, screenheight;
    private static Image.Plane[] planes;
    static ByteBuffer buffer;

    private static class singleHolder {
        static final CreateBitmap createbitmap = new CreateBitmap();
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public static CreateBitmap getInstance(final Context context, final Boolean isSave, String inpath, String inname) {
        init(context, inpath, inname);
        if (image != null) {
            analysesImage();
            long time = System.currentTimeMillis() - MyApplication.time;
            Log.i("img", "截图已生成" + time);
            if (isSave)
                savePic(context);
        }
        return singleHolder.createbitmap;
    }

    private static void loop() {
        do {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } while (image != null);

    }

    //    初始化操作
    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    private static void init(final Context context, String inpath, String inname) {
        if (bitmap != null) {
            bitmap = null;
        }
        path = inpath;
        name = inname;
        windowManager = (WindowManager) context.getSystemService(WINDOW_SERVICE);
        windowManager.getDefaultDisplay().getMetrics(displayMetrics);
        screenwidth = displayMetrics.widthPixels;
        screenheight = displayMetrics.heightPixels;
        mImageReader = ImageReader.newInstance(screenwidth, screenheight, PixelFormat.RGBA_8888, 2);
        virtualDisplay1 = mediaProjection.createVirtualDisplay("screen-mirror", screenwidth, screenheight, displayMetrics.densityDpi, DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR, mImageReader.getSurface(), null, null);
        do {
            try {
                Thread.sleep(10);
                image = mImageReader.acquireLatestImage();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } while (image == null);
    }

    //解析image
    private static void analysesImage() {
        planes = image.getPlanes();
        buffer = planes[0].getBuffer();
        width = image.getWidth();
        height = image.getHeight();
        pixelStride = planes[0].getPixelStride();
        rowStride = planes[0].getRowStride();
        rowPadding = rowStride - pixelStride * width;
        bmp = Bitmap.createBitmap(width + rowPadding / pixelStride, height, Bitmap.Config.ARGB_8888);
        bmp.copyPixelsFromBuffer(buffer);
        bitmap = Bitmap.createScaledBitmap(bmp, bmp.getWidth(), bmp.getHeight(), false);
        image.close();
    }

    //保存图片
    private static void savePic(Context context) {
        if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) && bitmap != null) {
            if (path == null) {
                path = Environment.getExternalStorageDirectory().getPath() + "/Android/screen";
            } else {
                path = Environment.getExternalStorageDirectory().getPath() + path;
            }
            File file = new File(path);
            if (!file.exists()) {
                file.mkdir();
            }
            if (name == null) {
                name = System.currentTimeMillis() + "";
            }
            File file1 = new File(file, name + ".jpg");
            try {
                FileOutputStream fileOutputStream = new FileOutputStream(file1);
                bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fileOutputStream);
                fileOutputStream.flush();
                fileOutputStream.close();
                Log.i("img", "截屏已保存到本地" + path);
                Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
                Uri uri = Uri.fromFile(file1);
                intent.setData(uri);
                context.sendBroadcast(intent);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    public Bitmap getBitmap() {
        return bitmap;
    }
}

import android.app.Application;
import android.media.projection.MediaProjection;

public class MyApplication extends Application {
    public  static MediaProjection mediaProjection;
    public  static  long time;
}

import android.Manifest;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.PixelFormat;
import android.hardware.display.DisplayManager;
import android.hardware.display.VirtualDisplay;
import android.media.Image;
import android.media.ImageReader;
import android.media.projection.MediaProjection;
import android.media.projection.MediaProjectionManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.support.annotation.RequiresApi;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.WindowManager;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

public class ScreenShotActivity extends Activity {
    MediaProjectionManager mediaProjectionManager;
    MediaProjection mediaProjection;
    ImageReader mImageReader;
    VirtualDisplay virtualDisplay1;
    DisplayMetrics displayMetrics;
    WindowManager windowManager;
    String name, path;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Intent intent = getIntent();
        name = intent.getStringExtra("name");
        path = intent.getStringExtra("path");
        checkPermission();
    }
    public void requestCapturePermission() {

        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            //5.0 之后才允许使用屏幕截图
            return;
        }

        mediaProjectionManager = (MediaProjectionManager)
                getApplication().getSystemService(Context.MEDIA_PROJECTION_SERVICE);

        startActivityForResult(
                mediaProjectionManager.createScreenCaptureIntent(),
                1);
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        mediaProjection = mediaProjectionManager.getMediaProjection(resultCode, data);
        captureScreen();
    }

    public void checkPermission() {
        final List<String> permissionsList = new ArrayList<>();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if ((checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)) {
                permissionsList.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
            } else {
                requestCapturePermission();
            }

            if (permissionsList.size() != 0) {
                requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
                        100);
            }
        }
    }

    @RequiresApi(api = Build.VERSION_CODES.M)
    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        if (requestCode == 100) {
            if (grantResults.length > 0 && (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED)) {
                requestCapturePermission();
            } else {
                Log.e("ScreenShotActivity", "未获取权限");
            }
        }///instant-run
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public void captureScreen() {
        displayMetrics = new DisplayMetrics();
        windowManager = (WindowManager) this.getSystemService(WINDOW_SERVICE);
        windowManager.getDefaultDisplay().getMetrics(displayMetrics);
        int width = displayMetrics.widthPixels;
        int height = displayMetrics.heightPixels;
        mImageReader = ImageReader.newInstance(width, height, PixelFormat.RGBA_8888, 2);
        virtualDisplay1 = mediaProjection.createVirtualDisplay("screen-mirror", width, height, displayMetrics.densityDpi, DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR, mImageReader.getSurface(), null, null);
        Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                Image image = mImageReader.acquireLatestImage();
                if (image != null) {
                    final Image.Plane[] planes = image.getPlanes();
                    final ByteBuffer buffer = planes[0].getBuffer();
                    int width = image.getWidth();
                    int height = image.getHeight();
                    int pixelStride = planes[0].getPixelStride();
                    int rowStride = planes[0].getRowStride();
                    int rowPadding = rowStride - pixelStride * width;
                    Bitmap bmp = Bitmap.createBitmap(width + rowPadding / pixelStride, height, Bitmap.Config.ARGB_8888);
                    bmp.copyPixelsFromBuffer(buffer);
                    Bitmap bitmap = Bitmap.createScaledBitmap(bmp, bmp.getWidth(), bmp.getHeight(), false);
                    if(bitmap!=null){
                        long spendtimes = System.currentTimeMillis() - MyApplication.time;
                        Log.e("ScreenShotActivity", "bitmap成功时间" + spendtimes);
                    }
                    setSavePic(bitmap);
                    bitmap.recycle();
                    image.close();
                }
            }
        }, 10);
    }

    private void setSavePic(Bitmap bitmap) {//保存截屏到本地
        if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
            if (path == null) {
                path = Environment.getExternalStorageDirectory().getPath() + "/截屏";
            } else {
                path = Environment.getExternalStorageDirectory().getPath() + "/" + path;
            }
            File file = new File(path);
            if (!file.exists()) {
                file.mkdir();
            }
            if (name == null) {
                name = System.currentTimeMillis() + "";
            }
            File file1 = new File(file, name + ".jpg");
            try {
                FileOutputStream fileOutputStream = new FileOutputStream(file1);
                bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fileOutputStream);
                fileOutputStream.flush();
                fileOutputStream.close();
//                Toast.makeText(this, "截屏已保存到本地" + path, Toast.LENGTH_SHORT).show();
                Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
                Uri uri = Uri.fromFile(file1);
                intent.setData(uri);
                sendBroadcast(intent);
                finish();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

import android.content.Context;
import android.content.Intent;


public class ShotClass {
    private static class SingleHolder {
        static final ShotClass shot = new ShotClass();
    }

    public static ShotClass getInstance() {
        return SingleHolder.shot;
    }

    public void createShot(Context context, String path, String name) {
        Intent intent = new Intent(context, ScreenShotActivity.class);
        intent.putExtra("path", path);
        intent.putExtra("name", name);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        context.startActivity(intent);
    }
}

源码下载： https://download.csdn.net/download/chaoyu168/10516429

微信关注我们

原文链接：https://yq.aliyun.com/articles/631437

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Spring MVC原理

摘要: Spring MVC工作流程图 springMVC工作流程图图一图二开发工具 1.Eclipse IDE：采用Maven项目管理，模块化。 2.代码生成：通过界面方式简单配置，自动生成相应代码，目前包括三种生成方式（增删改查）：单表、一对多、树结构。生成后的代码如果不需要注意美观程度，生成后即可用。技术选型（只列了一部分技术） 1、后端服务框架：Dubbo、zookeeper、Rest服务缓存：Redis、ehcache 消息中间件：ActiveMQ 负载均衡：Nginx 分布式文件：FastDFS 数据库连接池：Alibaba Druid 1.0 核心框架：Spring framework 安全框架：Apache Shiro 1.2 视图框架：Spring MVC 4.0 服务端验证：hibernateValidator 5.1 布局框架：SiteMesh 2.4 工作流引擎：Activiti 5.15 任务调度：quartz 1.8.5 持久层框架：MyBatis 3.2 日志管理：SLF4J 1.7、Log4j 工具类：Apache Commons、Jacks...

2018-07-03

562

python有好几种实现线程池的方式，注意选择一下，哪种是自己需要的。最近用上ThreadPoolExecutor，用来代替celery的方式。主要是用在celery上的时间太少，没有吃透，还有，我们的应用没有复杂到那地步，多开几个服务器，也可以实现线程池的扩展。 ThreadPoolExecutor主要有submit和map方式。 map就够用我们的场景了。使用ThreadPoolExecutor时，需要注意的是map函数的参数是如何构造的。（就是将cmd_run后面的参数，构造为有相同于进程池数量的参数列表！！！）【就是参数个人为cmd_run要求的个数，但列表内的长度为进程池数量，利用率刚好】 data为每个函数的返回值。注意，进程的退出，不到山穷水尽，不要用os.exit()这样的函数， python可能无法正常完成数据操作及资源回收。最好是利用函数的返回值自然退出线程，高端些~ from concurrent.futures import ThreadPoolExecutor executor = ThreadPoolExecutor(max_work...

2018-07-03

802

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。