android之手机截屏小程序
Android 手机截屏程序
一：程序运行的大致思路
1、运行程序，显示一个Activity界面，点击按钮，显示一个浮窗。这里用到一个显示浮窗的小技术。
2、在显示浮窗的同时，会启动一个server服务，这个服务很重要，因为在这里会建立java端和android底层（即c语言端）的通信机制。这个地方比较抽象。以后再来解释，你就记住它是一个通信机制，相当于客户端和服务器端的关系
3、点击一下浮窗，就会向android底层发送消息，开始截屏，这里的向android底层发送消息，采用了android源代码里面的通信机制，我直接就把android源码拿来用了。
4、开始截屏，这里的截屏程序也是用的android自带的截屏程序，也是android源码，但是我在这里做了很多的工作。因为截屏出来的图片，我需要保存为png格式。
5、在保存png格式的图片的时候，我又使用了第三方的一个png库。
6、最后的运行效果相当于点击浮窗，开始截屏，再点击浮窗，停止截屏，图片会自动保存到/sdcard/DCIM/这个目录下面。
二：改程序在做的过程中使用到的一些技术
1、要用到android的应用程序开发的基本知识，这里就不多说了
2、用到了ndk开发技术
3、既然使用ndk开发，那C/C++的技术就不得不用了
4、因为做ndk开发，我觉的就相当于在Linux系统下面做c语言的开发，那Linux开发中使用的一些东西也就需要了。
5、最后一点，你的手机需要root。因为截屏的基本思路就读取屏幕像素在内存中的映射，所有需要直接读取内存中的内容，root是必须的。
三：程序开发的具体过程
1、从现在起，我会一步一步的把这个程序再重新做一遍，目的就是希望能把之前学习到的东西再回顾一遍，温故而知新。
2、先建立一个截屏项目工程，名字随便吧，我的叫screenshot如图
3、在Activity_main.xml文件中添加一个Button控件，如图
在MainActivity.java这个类里面做一些简单的初始化，为Button按钮添加点击响应事件，显示浮窗。因为显示浮窗，程序会直接跳到手机的桌面，所以这里有一个小技术，从应用程序直接跳到手机桌面，代码如下。
/**
* 返回到主桌面 类似按下Home按钮
*
* @param context
*/
public static void backToHomePage(Context context) {
Intent i = new Intent(Intent.ACTION_MAIN);
i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
i.addCategory(Intent.CATEGORY_HOME);
context.startActivity(i);
}
4、要新建一个ScreenCaptureServer类,这个类就非常重要了，它主要有这几个作用，首先要创建一个浮窗，其次就是要建立与android底层的连接，然后要维护与android底层的通信。最后也是最重要的，建立截屏程序的独立线程。首先做一个浮窗，很简单，这里就不多说了，具体可以看我的另一篇博客-----android之浮窗篇。
5、实现android的java端与底层的c端通信。因为这里是调用的系统的通信代码，好多我也没有搞清楚。不过现在到是能用，在该程序里面，java端充当的是服务器端，它随service的启动开始运行，不停的监听来自客户端（c端的连接）。下面是服务器线程的具体代码。
/**
* 服务器端的线程
*
* @author jeck
*
*/
private class ServerSocketThread extends Thread {
/**
* 线程运行的标示
*/
private boolean keeprunning = true;
/**
* 本地服务socket
*/
private LocalServerSocket localServerSocket;
@Override
public void run() {
try {
// 创建一个本地socket
localServerSocket = new LocalServerSocket("screen_shot_socket");
} catch (Exception e) {
e.printStackTrace();
keeprunning = false;
}
// 通过while循环， 轮训从客户端发过来的连接请求
while (keeprunning) {
Log.d(TAG, "Waitting for client to connect !! ");
try {
// 监听客户端的连接
LocalSocket interactClientSocket = localServerSocket
.accept();
// 因为有可能在等待客户端连接的时候，accept阻塞了。Activity被finish掉，所以有必要在检测一次
if (keeprunning) {
Log.d(TAG, "now client coming ！！！");
// 开始为客户端服务
new InteractClientSocketThread(interactClientSocket)
.start();
}
} catch (Exception e) {
e.printStackTrace();
keeprunning = false;
}
}
// 如果断开连接，那就关闭服务
if (localServerSocket != null) {
try {
localServerSocket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
// /**
// * 停止线程
// */
// public void stopRunning() {
//
// keeprunning = false;
// }
}
6、接下来的是service里面的第三个功能，就是维护与客户端（c端）的通信了。这里无非就是监听连接，连接到了就发送消息。因为要配合我的主要功能，截屏，所有我这里的逻辑是启动service，开启服务器监听，如果有客户端连接，会向客户端发送一个数字2，如果客户端收到2，会向服务器端发送2222表示连接成功，然后如果你点击了我们的小浮窗，会向客户端发送数字1，表示开始截屏，客户端收到消息会想服务器端发送1111表示我客户端已经收到消息了。然后你再点击一次小浮窗，服务器端会发送0，表示停止截屏，那客户端收到0会停止截屏，并向服务器端反馈0000.这就是我的通信机制。下面我把代码粘出来。
/**
* 服务器与客户端直接的通信线程
*
* @author jeck
*
*/
private class InteractClientSocketThread extends Thread {
/**
* 本地socket
*/
private LocalSocket interactClientSocket;
/**
* 输入流
*/
private InputStream inputStream = null;
/**
* 输出流
*/
private OutputStream outputStream = null;
/**
* 从客户端发来的消息
*/
private StringBuilder receiveFromClientString = new StringBuilder();
/**
* 输入缓存区
*/
private char[] readBuffer = new char[4096];
/**
* 输入字节数
*/
private int readBytes = -1;
/**
* 构造函数
*/
public InteractClientSocketThread(LocalSocket interactClientSocket) {
this.interactClientSocket = interactClientSocket;
}
/**
* 从客户端读取数据
*
* @return
*/
private boolean readDataFromClient() {
boolean readResult = false;
// 从本地连接中获取输入流
try {
inputStream = interactClientSocket.getInputStream();
// 读数据
InputStreamReader inputStreamReader = new InputStreamReader(
inputStream);
// 从输入流中读取数据
while ((readBytes = inputStreamReader.read(readBuffer)) != -1) {
String tmpStr = new String(readBuffer, 0, readBytes);
receiveFromClientString.append(tmpStr).append("\n");
}
if (receiveFromClientString.toString() != null) {
if (receiveFromClientString.toString().startsWith("0000")
|| receiveFromClientString.toString().startsWith(
"1111")) {
captureState = 2;
}
// 显示client发送的消息
Log.d(TAG, receiveFromClientString.toString());
// 读取时间成功
readResult = true;
}
} catch (IOException e) {
e.printStackTrace();
}
return readResult;
}
/**
* 向客户端写数据
*
* @return
*/
private boolean writeDataToClient(String writeContent) {
boolean writeResult = false;
try {
outputStream = interactClientSocket.getOutputStream();
// 如果点击了开始录屏，则发送消息
if (writeContent != null && !"".equals(writeContent)) {
outputStream.write(writeContent.getBytes());
}
writeResult = true;
} catch (IOException e) {
e.printStackTrace();
writeResult = false;
}
return writeResult;
}
@Override
public void run() {
try {
switch (captureState) {
case 0:
// 停止截屏
writeDataToClient(STOP_CAPTURE_SCREEN);
break;
case 1:
// 开始录屏
writeDataToClient(START_CAPTURE_SCREEN);
break;
case 2:
// 等待连接
writeDataToClient(KEEP_CONNECTION);
break;
}
readDataFromClient();
} catch (Exception e) {
e.printStackTrace();
Log.d(TAG, "receive data failed !!");
} finally {
if (outputStream != null) {
try {
outputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if (inputStream != null) {
try {
inputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
7、接下来是最关键的部分，呵呵，其实那个地方都很关键，缺少了任何一个地方，这个程序也跑不起来。废话不多说了，现在简绍截屏进程了。这进程的工作原理是这样的。1需要手机root权限，在获取手机root权限之后，通过ndk的混合编译器，编译一个exe文件，在root权限下面，通过代码执行这个exe程序。换句话说就是相当于在java端，执行exe文件。因为android系统是基于Linux操作系统的，所以你的exe想要直接执行，必须获取一点的权限，就算你在Linux系统下面直接写代码，那你执行./xxxx 程序的时候，也是需要权限的。2就是要创建一个进程了（process）。你执行了exe程序，就相当于你创建了一个进程，所以要把这个进程获取出来，以便操作。最后这些东西都是在一个单独的线程中运行的，来代码。
/**
* 响应点击截屏按钮
*/
private boolean screenCapture() {
boolean result = false;
try {
// 创建log对象
screenLog = new StringBuilder();
// 创建一个进程
logcatProcess = RuntimeHelper.getLogcatProcess(this);
// 创建一个缓冲
bufferedReader = new BufferedReader(new InputStreamReader(
logcatProcess.getInputStream()), 8192);
String line;
while ((line = bufferedReader.readLine()) != null) {
Log.d(TAG, line);
screenLog.append(line).append("\n");
if (line.startsWith("Success")) {
result = true;
}
}
} catch (Exception e) {
e.printStackTrace();
result = false;
}
return result;
}
/**
* 使用异步线程执行截屏操作
*
* @author jeck
*
*/
private class ScreenCaptureTask extends AsyncTask
@Override
protected Boolean doInBackground(Void... params) {
return screenCapture();
}
@Override
protected void onPostExecute(Boolean result) {
if (result) {
// 将日志保存在SD卡上
// try {
// // Utils.saveCaptureLog(screenLog.toString());
// } catch (Exception e) {
// e.printStackTrace();
// }
Toast.makeText(getApplicationContext(), "截屏成功",
Toast.LENGTH_LONG).show();
}
}
}
8、以上就是我们这个截屏程序的java端的所有代码了，这只是一个好的开始。
在java端的功能就是显示一个浮窗，然后点击浮窗，会开始和C端进行交互。
C端涉及的东西就都是C语言的了，这里面都是ndk的知识了，这里首先要编写一个.cpp文件，就是我们的通信程序，因为这里用的是android源代码，所以这个程序目前只适合android4.1系统的。其他版本暂时没有测试。下面这是我的exe程序的主要代码。
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "screen_capture_image.h"
#define TAG "--screen_capture-->"
int socketID;
/*
*获取当前的系统版本
*/
int getCurrentSDKVersion() {
int sdk;
char c[PROP_VALUE_MAX];
if (__system_property_get("ro.build.version.sdk", c) > 0) {
sscanf(c, "%d", &sdk);
} else {
sdk = 8;
}
return sdk;
}
/*
* Class: com_rdtd_jni_SendMessageFromClientJNI
* Method: startHeartBead
* Signature: ()I
*/
int connection_to_server() {
char path[] = "screen_shot_socket";
socketID = socket_local_client(path, ANDROID_SOCKET_NAMESPACE_ABSTRACT,
SOCK_STREAM);
//如果连接失败
if (socketID < 0) {
return socketID;
} else {
return 1;
}
}
void close_connection() {
if (socketID) {
close(socketID);
}
}
int read_data_from_server() {
//0表示停止录屏，1 表示开始录屏, 2 表示连接中， -1 表示读取数据出错
int result;
//读取的字数
int read_result;
char readBuffer[2];
memset(readBuffer, 0, 2);
read_result = read(socketID, readBuffer, 2);
if (read_result) {
result = atoi(readBuffer);
//printf("---->read data success :%d\n", result);
} else {
result = -1;
}
return result;
}
int write_data_to_server(const char *str) {
int write_result;
write_result = write(socketID, str, strlen(str));
if (write_result) {
close_connection();
return 1;
} else {
printf("write data failed !\n");
close_connection();
return 0;
}
}
void* begin_capture(void*) {
long result = 1;
//设置截屏开始的标示
set_capture_flag_png(1);
//截屏并保存成png图片，现在在联想的机器上是不行的。一直报的是找不到libpng。so文件
screen_capture_png();
return (void*) result;
}
/*
*截屏程序的入口，截屏参数都放在这里面。
*argv[1]表示宽度， argv[2]表示高度
*默认帧率15帧每秒，宽度和高度是手机屏幕的宽高
*/
int main(int argc, char *argv[]) {
int count = 0;
pthread_t thread_id;
void *thread_result;
//循环读写数据
while (connection_to_server()) {
//先读取数据
int read_result = read_data_from_server();
printf("---->receive message = %d\n", read_result);
__android_log_print(ANDROID_LOG_DEBUG, TAG, "receive message = %d",
read_result);
switch (read_result) {
case 0:
//停止录制
write_data_to_server("0000---------->");
set_capture_flag_png(0);
if (pthread_join(thread_id, &thread_result) == -1) {
printf("waiting thread failed !\n");
} else {
if ((long) thread_result == 0) {
printf("screen_cap return failed \n");
} else {
printf("Success------------------>\n");
//这个地方必须返回，否则保存的图片都是黑屏图片，不知道是为什么，呵呵，应该是没有关闭文件，只有函数返回了，系统自动关闭文件
exit(0);
}
}
break;
case 1:
//开始录制
write_data_to_server("1111---------->");
if (pthread_create(&thread_id, NULL, begin_capture, NULL) == -1) {
printf("create thread failed !\n");
}
break;
case 2:
//连接中
write_data_to_server("2222---------->");
break;
case -1:
//读取数据出错
printf("---->read data failed !\n");
goto exit;
}
sleep(3);
}
exit: close_connection();
return 0;
}
这个cpp文件就会被ndk编译成我们在上面提到的exe文件，就是Linux系统下面的可执行文件。只有这个文件，我们能做的就是和java端发个信息而已，还是不能截屏的，需要截屏的程序在下面，也是用的android源代码，不过基本让我改的没有源代码的味道了。
在这里，我使用了第三方的png库，我把它编译成静态库，然后链接到我的cpp文件中，最后把cpp文件编译成exe文件，再在代码中执行exe文件。下面是截屏的主要代码。
/*
* Copyright (C) 2010 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.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "screen_capture_image.h"
#include
//#ifdef ANDROID_KK //4.4
//#include
//#include
//#else
#include
//#endif
using namespace android;
#define TAG "--screen_capture-->"
//截屏标识
static int capture_flag = 0;
//录音标识
static int record_flag = 0;
int PushTime = 0;
//获取当前时间(microsecond)
int64_t getCurrentTime() {
struct timeval tv;
gettimeofday(&tv, NULL);
return (1000000LL * tv.tv_sec) + tv.tv_usec;
}
//#ifdef ANDROID_KK
//static uint32_t DEFAULT_DISPLAY_ID = ISurfaceComposer::eDisplayIdMain;
//#endif
//显示错误信息
void error(const char* msg) {
fprintf(stderr, "%s: %s:\n", msg, strerror(errno));
exit(1);
}
typedef struct param {
void *fb_in;
FILE * fb_out;
int width;
int height;
int64_t usedTime;
size_t buffer_size;
param * next;
} image_info;
// 获取当前日期, 以秒为单位，现在我一秒之内可以截取3张图片，他的名字当然一样了
char* getLocalTime() {
char currentTime[128];
memset(currentTime, 0, 128);
int64_t time = getCurrentTime();
sprintf(currentTime, "%lld", time);
return currentTime;
}
//创建视频路径
void create_video_path(char* path) {
memset(path, 0, 256);
strcpy(path, "/sdcard/DCIM/Record_");
strcat(path, getLocalTime());
strcat(path, ".mp4");
printf("---->path = %s\n", path);
}
//创建视频路径
void create_image_path(char* path) {
memset(path, 0, 256);
strcpy(path, "/sdcard/DCIM/capture_");
strcat(path, getLocalTime());
strcat(path, ".png");
printf("---->path = %s\n", path);
}
//创建截屏图片信息的节点
image_info* create_image_info_node(const void * in, FILE* out, int w, int h,
size_t size, int64_t ut) {
image_info *newInfo = (image_info*) malloc(sizeof(image_info));
//分配内存
newInfo->fb_in = malloc(size);
//拷贝内存
memcpy(newInfo->fb_in, in, size);
newInfo->fb_out = out;
newInfo->buffer_size = size;
newInfo->width = w;
newInfo->height = h;
newInfo->usedTime = ut;
newInfo->next = NULL;
printf("---->create a new image node \n");
return newInfo;
}
//释放内存
void release_image_node(image_info* node) {
if (node != NULL) {
free(node->fb_in);
node->fb_in = NULL;
free(node);
node = NULL;
printf("---->success to release a image node \n");
}
}
/*
* fb_base 屏幕左上角的第一个像素的内存地址
* fb_out 生成的png保存的地址
* w 屏幕的宽度
* h 屏幕的高度
* f png的文件格式
*/
//void take_screenshot(char *fb_base, FILE* fb_out, int w, int h, int f) {
int take_screenshot(image_info *argu) {
long result = 0;
//printf("take_screenshot is running! \n");
//image_info *argu = (image_info*) param;
//png结构
png_structp png;
//png info
png_infop info;
struct fb_var_screeninfo vinfo;
// 因为是一行一行的扫描屏幕，r是行数
unsigned int r;
//每一行的长度，是右屏幕的宽度(像素) * 每一个像素的大小(32位 4个字节)
unsigned int rowlen;
//每一个像素所占的大小，4个字节
unsigned int bytespp = 4;
//创建一个png结构
png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
//printf("1---> png_create_write_struct is runed \n");
if (png == NULL) {
ALOGE("failed png_create_write_struct\n");
}
png_init_io(png, argu->fb_out);
//printf("2---> png_init_io is runed \n");
info = png_create_info_struct(png);
//printf("3---> png_create_info_struct is runed \n");
if (info == NULL) {
ALOGE("failed png_create_info_struct\n");
png_destroy_write_struct(&png, NULL);
}
if (setjmp(png_jmpbuf(png))) {
ALOGE("failed png setjmp\n");
png_destroy_write_struct(&png, NULL);
}
//设置png的各种信息
png_set_IHDR(png, info, argu->width, argu->height, 8,
PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
//printf("4---> png_set_IHDR is runed \n");
png_write_info(png, info);
//printf("5---> png_write_info is runed \n");
//计算每一行的长度
rowlen = argu->width * bytespp;
//新建一个临时变量，保存图片的内存块地址
png_bytep temp = (png_bytep) argu->fb_in;
//循环扫描屏幕，一行一行的读取数据
for (r = 0; r < argu->height; r++) {
//将第r行写到png结构中
png_write_row(png, temp);
//计算下一行的起始位置
temp += rowlen;
}
//写png的信息
png_write_end(png, info);
//printf("6---> png_write_end is runed \n");
png_destroy_write_struct(&png, NULL);
//printf("7---> png_destroy_write_struct is runed \n");
//保存完图片，就把文件关闭掉
if (fclose(argu->fb_out) == -1) {
error("close file failed !");
} else {
//printf("---->success to save a image \n");
temp = NULL;
result = 1;
}
return result;
}
//保存图片，返回保存成功的图片数量，如果不等于24， 则说明保存失败, 成功返回1， 失败，返回0
void* save_image(void *start) {
long result = 0;
image_info * p = (image_info*) start;
image_info * next = NULL;
while (p != NULL) {
//先将下一个节点的指针保存在next里面
next = p->next;
//直接保存，如果成功，则释放该节点所占的内存
if (take_screenshot(p) == 1) {
release_image_node(p);
} else {
error("save image failed");
}
//最后再将next节点复制给p，继续操作
p = next;
}
result = 1;
return (void*) result;
}
/*截屏程序*/
image_info* screen_shot() {
static int64_t base_time = getCurrentTime();
//截屏的开始时间和结束时间
int64_t beginTime = 0, usedTime = 0;
const void* base;
size_t size;
uint32_t width, height;
FILE *fb_out = NULL;
//#ifdef ANDROID_KK
//ProcessState::self()->startThreadPool();
//#endif
//
//#ifdef ANDROID_KK
//int32_t displayId = DEFAULT_DISPLAY_ID;
//#endif
ScreenshotClient screenshot;
beginTime = getCurrentTime();
//#ifdef ANDROID_KK
//sp
//if (display != NULL && screenshot.update(display) == NO_ERROR) {
//#else
if (screenshot.update() == NO_ERROR) {
//#endif
base = screenshot.getPixels();
size = screenshot.getSize();
width = screenshot.getWidth();
height = screenshot.getHeight();
//计算截图时间
usedTime = getCurrentTime() - beginTime;
printf("---->Image: width = %d, height = %d, used time = % lld\n",
screenshot.getWidth(), screenshot.getHeight(), usedTime);
char image_path[256];
create_image_path(image_path);
fb_out = fopen(image_path, "w");
return create_image_info_node(base, fb_out, width, height, size,
usedTime);
}
return NULL;
}
//截屏并生成视频链表
void* capture_and_link(void *) {
image_info* start = NULL;
image_info* newNode = NULL;
image_info* tail = NULL;
//开始截屏并生成截屏链表
while (capture_flag) {
//保存视频流
newNode = screen_shot();
if (newNode != NULL) {
if (start == NULL) {
start = newNode;
}
if (tail != NULL) {
tail->next = newNode;
}
tail = newNode;
} else {
printf("---->screen_shot return NULL !\n");
return NULL;
}
//睡3秒，不然录制的太快
sleep(3);
}
return (void*) start;
}
#ifdef __cplusplus
extern "C" {
#endif
//设置截屏标志
void set_capture_flag_png(int flag) {
capture_flag = flag;
record_flag = flag;
}
//截屏并保存为图片
void screen_capture_png() {
//截屏线程,只负责截屏
pthread_t capture_thread;
if (pthread_create(&capture_thread, NULL, capture_and_link, NULL) == -1) {
error("create capture_thread failed !");
}
//截屏之后返回的结果，是一个包含截屏图片信息的链表,这个链表保存的东西关系到整个截屏程序的成败
void* capture_result;
if (pthread_join(capture_thread, &capture_result) == -1) {
error("waiting capture_thread failed !");
}
//截屏完了，开始保存图片
pthread_t save_thread;
if (pthread_create(&save_thread, NULL, save_image, capture_result) == -1) {
error("create save_thread failed !");
}
//等待保存图片的线程
void* save_result;
if (pthread_join(save_thread, &save_result) == -1) {
error("waiting save_thread failed !");
}
if ((long) save_result == 1) {
printf("---->success to save image !\n");
}
}
#ifdef __cplusplus
}
#endif
到此为止，这个截屏程序的主要代码是都将完了，虽然说将的很简单，但是做起来一点都不简单，里面涉及的东西还是很多的。这需要你对ndk编程很熟悉才可能把这个程序顺利的运行起来