├── app
    ├── .gitignore
    ├── src
    │   └── main
    │   │   ├── res
    │   │       ├── raw
    │   │       │   └── test.mp4
    │   │       ├── values
    │   │       │   ├── strings.xml
    │   │       │   ├── colors.xml
    │   │       │   └── styles.xml
    │   │       ├── mipmap-hdpi
    │   │       │   ├── ic_launcher.png
    │   │       │   └── ic_launcher_round.png
    │   │       ├── mipmap-mdpi
    │   │       │   ├── ic_launcher.png
    │   │       │   └── ic_launcher_round.png
    │   │       ├── mipmap-xhdpi
    │   │       │   ├── ic_launcher.png
    │   │       │   ├── img_cut_screen.png
    │   │       │   └── ic_launcher_round.png
    │   │       ├── mipmap-xxhdpi
    │   │       │   ├── background.png
    │   │       │   ├── ic_launcher.png
    │   │       │   └── ic_launcher_round.png
    │   │       ├── mipmap-xxxhdpi
    │   │       │   ├── ic_launcher.png
    │   │       │   └── ic_launcher_round.png
    │   │       └── layout
    │   │       │   ├── activity_player.xml
    │   │       │   ├── activity_tcp_send.xml
    │   │       │   └── activity_main.xml
    │   │   ├── java
    │   │       └── com
    │   │       │   └── ryan
    │   │       │       └── screenrecoder
    │   │       │           ├── application
    │   │       │               ├── SysValue.java
    │   │       │               └── ScreenApplication.java
    │   │       │           ├── bean
    │   │       │               └── EventLogBean.java
    │   │       │           ├── util
    │   │       │               ├── LogUtil.java
    │   │       │               ├── SharedUtil.java
    │   │       │               └── SysUtil.java
    │   │       │           ├── ui
    │   │       │               └── activity
    │   │       │               │   ├── PlayerActivity.java
    │   │       │               │   ├── MainActivity.java
    │   │       │               │   └── TcpSendActivity.java
    │   │       │           ├── conn
    │   │       │               ├── TcpServerThread.java
    │   │       │               └── TcpSendThread.java
    │   │       │           ├── glec
    │   │       │               ├── STextureRender.java
    │   │       │               ├── GlUtil.java
    │   │       │               └── EGLRender.java
    │   │       │           └── coder
    │   │       │               └── MediaEncoder.java
    │   │   └── AndroidManifest.xml
    ├── proguard-rules.pro
    └── build.gradle
├── settings.gradle
├── 脑图.png
├── show.jpg
├── .gitignore
├── README.md
├── gradle.properties
└── gradlew


/app/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 | 


--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | include ':app'
2 | 


--------------------------------------------------------------------------------
/脑图.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/脑图.png


--------------------------------------------------------------------------------
/show.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/show.jpg


--------------------------------------------------------------------------------
/app/src/main/res/raw/test.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/raw/test.mp4


--------------------------------------------------------------------------------
/app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <string name="app_name">ScreenRecoder</string>
3 | </resources>
4 | 


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/background.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/mipmap-xxhdpi/background.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/img_cut_screen.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/mipmap-xhdpi/img_cut_screen.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RyanRQ/ScreenRecoder/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.iml
 2 | /local.properties
 3 | .DS_Store
 4 | /build
 5 | /captures
 6 | .externalNativeBuild
 7 | .idea/
 8 | gradle/
 9 | gradlew.bat
10 | .gradle/
11 | 


--------------------------------------------------------------------------------
/app/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <color name="colorPrimary">#3F51B5</color>
4 |     <color name="colorPrimaryDark">#303F9F</color>
5 |     <color name="colorAccent">#FF4081</color>
6 | </resources>
7 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/application/SysValue.java:
--------------------------------------------------------------------------------
 1 | package com.ryan.screenrecoder.application;
 2 | 
 3 | /**
 4 |  * Created by zx315476228 on 17-3-10.
 5 |  */
 6 | 
 7 | public class SysValue {
 8 |     public static int api;//系统API版本号
 9 |     public static int screen_width;//屏幕宽度
10 |     public static int screen_height;//屏幕高度
11 |     public static int screen_dpi;//屏幕密度
12 | }
13 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/bean/EventLogBean.java:
--------------------------------------------------------------------------------
 1 | package com.ryan.screenrecoder.bean;
 2 | 
 3 | /**
 4 |  * Created by zx315476228 on 17-3-15.
 5 |  */
 6 | 
 7 | public class EventLogBean {
 8 |     private String log;
 9 | 
10 |     public EventLogBean(String log) {
11 |         this.log = log;
12 |     }
13 | 
14 |     public String getLog() {
15 |         return log;
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/app/src/main/res/values/styles.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 | 
 3 |     <!-- Base application theme. -->
 4 |     <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
 5 |         <!-- Customize your theme here. -->
 6 |         <item name="colorPrimary">@color/colorPrimary</item>
 7 |         <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
 8 |         <item name="colorAccent">@color/colorAccent</item>
 9 |     </style>
10 | 
11 | </resources>
12 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ScreenRecoder
 2 | 
 3 | ### 使用方法:
 4 | 两台安卓设备处于同一网段，设备1先开启接收端，另一台输入设备1的IP地址，开启发送端即可
 5 | 
 6 | ![image](https://github.com/RyanRQ/ScreenRecoder/blob/master/show.jpg)</br>
 7 | 
 8 | ### 思维脑图
 9 | ![image](https://github.com/RyanRQ/ScreenRecoder/blob/master/%E8%84%91%E5%9B%BE.png)
10 | 
11 | ## 版本
12 | ### V1.1.2 解决录屏时，截屏卡顿感
13 | ### V1.1 修复部分bug,接收端与发送端合并.
14 | 
15 | 
16 | ## Future：
17 | 1.支持摄像头获取数据
18 | 
19 | 2.增加滤镜
20 | 
21 | 3.支持RTMP推流
22 | 
23 | 
24 | # 如果该项目对你有帮助请点个赞~\(≧▽≦)/~吧!!!!
25 | 
26 | 


--------------------------------------------------------------------------------
/app/src/main/res/layout/activity_player.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     xmlns:app="http://schemas.android.com/apk/res-auto"
 4 |     xmlns:tools="http://schemas.android.com/tools"
 5 |     android:layout_width="match_parent"
 6 |     android:layout_height="match_parent"
 7 |     tools:context=".ui.activity.PlayerActivity">
 8 |     <SurfaceView
 9 |         android:id="@+id/surfaceview_play"
10 |         android:layout_width="match_parent"
11 |         android:layout_height="match_parent" />
12 | </FrameLayout>


--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
 1 | # Project-wide Gradle settings.
 2 | 
 3 | # IDE (e.g. Android Studio) users:
 4 | # Gradle settings configured through the IDE *will override*
 5 | # any settings specified in this file.
 6 | 
 7 | # For more details on how to configure your build environment visit
 8 | # http://www.gradle.org/docs/current/userguide/build_environment.html
 9 | 
10 | # Specifies the JVM arguments used for the daemon process.
11 | # The setting is particularly useful for tweaking memory settings.
12 | org.gradle.jvmargs=-Xmx1536m
13 | 
14 | # When configured, Gradle will run in incubating parallel mode.
15 | # This option should only be used with decoupled projects. More details, visit
16 | # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
17 | # org.gradle.parallel=true
18 | 


--------------------------------------------------------------------------------
/app/src/main/res/layout/activity_tcp_send.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:orientation="vertical"
 4 |     android:layout_width="match_parent"
 5 |     android:layout_height="match_parent"
 6 |     >
 7 |     <VideoView
 8 |         android:id="@+id/videoView_test"
 9 |         android:layout_width="match_parent"
10 |         android:layout_height="match_parent" />
11 |     <Button
12 |         android:id="@+id/button_cutscreen"
13 |         android:layout_width="wrap_content"
14 |         android:layout_height="wrap_content"
15 |         android:layout_alignParentBottom="true"
16 |         android:layout_centerHorizontal="true"
17 |         android:layout_marginBottom="20dp"
18 |         android:text="截图"/>
19 | </RelativeLayout>
20 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/util/LogUtil.java:
--------------------------------------------------------------------------------
 1 | package com.ryan.screenrecoder.util;
 2 | 
 3 | /**
 4 |  * Created by zx315476228 on 17-3-15.
 5 |  */
 6 | 
 7 | public class LogUtil {
 8 |     private static final int MAX_BUFFER=50;
 9 |     private static String[] buffer=new String[MAX_BUFFER];
10 |     private static int len=0;
11 |     public static String getInfo(String txt){
12 |         if(len==MAX_BUFFER){
13 |             for (int i = 1; i < MAX_BUFFER; i++) {
14 |                 buffer[i-1]=buffer[i];
15 |             }
16 |             len--;
17 |         }
18 |         buffer[len]=txt+"\n";
19 |         len++;
20 |         StringBuffer info=new StringBuffer();
21 |         for (int i = 0; i < len; i++) {
22 |             info.append(buffer[i]);
23 |         }
24 |         return info.toString();
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/app/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # By default, the flags in this file are appended to flags specified
 3 | # in F:\AndroidSdk/tools/proguard/proguard-android.txt
 4 | # You can edit the include path and order by changing the proguardFiles
 5 | # directive in build.gradle.
 6 | #
 7 | # For more details, see
 8 | #   http://developer.android.com/guide/developing/tools/proguard.html
 9 | 
10 | # Add any project specific keep options here:
11 | 
12 | # If your project uses WebView with JS, uncomment the following
13 | # and specify the fully qualified class name to the JavaScript interface
14 | # class:
15 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
16 | #   public *;
17 | #}
18 | 
19 | # Uncomment this to preserve the line number information for
20 | # debugging stack traces.
21 | #-keepattributes SourceFile,LineNumberTable
22 | 
23 | # If you keep the line number information, uncomment this to
24 | # hide the original source file name.
25 | #-renamesourcefileattribute SourceFile
26 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/util/SharedUtil.java:
--------------------------------------------------------------------------------
 1 | package com.ryan.screenrecoder.util;
 2 | 
 3 | import android.content.Context;
 4 | import android.content.SharedPreferences;
 5 | 
 6 | public class SharedUtil {
 7 |     private static SharedUtil preferenceUtil;
 8 |     private SharedPreferences shareditorPreferences;
 9 | 
10 |     private SharedUtil(Context context) {
11 |         if (shareditorPreferences == null) {
12 |             shareditorPreferences = context.getSharedPreferences(
13 |                     "screenRecoder", Context.MODE_PRIVATE);
14 |         }
15 |     }
16 | 
17 |     public static SharedUtil init(Context context) {
18 |         if (preferenceUtil == null)
19 |             preferenceUtil = new SharedUtil(context);
20 |         return preferenceUtil;
21 |     }
22 | 
23 |     public String getIp() {
24 |         return shareditorPreferences.getString("ip", "");
25 |     }
26 | 
27 |     public void setIp(String ip) {
28 |         shareditorPreferences.edit().putString("ip", ip).apply();
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/app/build.gradle:
--------------------------------------------------------------------------------
 1 | apply plugin: 'com.android.application'
 2 | 
 3 | android {
 4 |     compileSdkVersion 25
 5 |     buildToolsVersion "27.0.3"
 6 |     defaultConfig {
 7 |         applicationId "com.ryan.screenrecoder"
 8 |         minSdkVersion 19
 9 |         targetSdkVersion 25
10 |         versionCode 1
11 |         versionName "1.0"
12 |         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
13 |     }
14 |     buildTypes {
15 |         release {
16 |             minifyEnabled false
17 |             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
18 |         }
19 | 
20 |     }
21 | //    signingConfigs{
22 | //        debug{
23 | //            storeFile file("/media/zx315476228/软件/共享盘/bszh/sign/platfrom.keystore")
24 | //        }
25 | //    }
26 | }
27 | 
28 | dependencies {
29 |     compile fileTree(dir: 'libs', include: ['*.jar'])
30 |     androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
31 |         exclude group: 'com.android.support', module: 'support-annotations'
32 |     })
33 |     compile 'org.greenrobot:eventbus:3.0.0'
34 |     compile 'com.android.support:appcompat-v7:25.4.0'
35 |     compile 'com.android.support.constraint:constraint-layout:1.0.2'
36 |     testCompile 'junit:junit:4.12'
37 | }
38 | 


--------------------------------------------------------------------------------
/app/src/main/res/layout/activity_main.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     xmlns:tools="http://schemas.android.com/tools"
 4 |     android:layout_width="match_parent"
 5 |     android:layout_height="match_parent"
 6 |     android:orientation="vertical"
 7 |     tools:context="com.ryan.screenrecoder.ui.activity.MainActivity">
 8 |     <Button
 9 |         android:id="@+id/button_tcp_preview"
10 |         android:layout_width="wrap_content"
11 |         android:layout_height="wrap_content"
12 |         android:text="接收端"
13 |         />
14 |     <LinearLayout
15 |         android:layout_width="match_parent"
16 |         android:layout_height="wrap_content"
17 |         android:orientation="horizontal"
18 |         tools:layout_editor_absoluteY="0dp"
19 |         tools:layout_editor_absoluteX="8dp">
20 |         <Button
21 |             android:id="@+id/button_tcp_send"
22 |             android:layout_width="wrap_content"
23 |             android:layout_height="wrap_content"
24 |             android:text="发送端"/>
25 |         <EditText
26 |             android:id="@+id/edittext_tcp_send_ip"
27 |             android:layout_width="match_parent"
28 |             android:layout_height="wrap_content"
29 |             android:hint="请输入ip地址,默认192.168.0.132"/>
30 |     </LinearLayout>
31 | </LinearLayout>
32 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/util/SysUtil.java:
--------------------------------------------------------------------------------
 1 | package com.ryan.screenrecoder.util;
 2 | 
 3 | import android.content.Context;
 4 | import android.content.pm.PackageManager;
 5 | import android.os.Build;
 6 | import android.text.TextUtils;
 7 | 
 8 | /**
 9 |  * Created by zx315476228 on 17-3-10.
10 |  */
11 | 
12 | public class SysUtil {
13 |     private static String ipRegex = "^(1\\d{2}|2[0-4 ]\\d|25[0-5]|[1-9]\\d|[1-9])\\."
14 |             + "(1\\d{2}|2[0-4]\\ d|25[0-5]|[1-9]\\d|\\d)\\."
15 |             + "(1\\d{2}|2[0-4]\\ d|25[0-5]|[1-9]\\d|\\d)\\."
16 |             + "(1\\d{2}|2[0-4]\\ d|25[0-5]|[1-9]\\d|\\d)$";
17 | 
18 |     /**
19 |      * 获取手机高宽密度
20 |      */
21 |     public static int getScreenWidth(Context context) {
22 |         return context.getResources().getDisplayMetrics().widthPixels;
23 |     }
24 | 
25 |     /**
26 |      * 手机屏幕高度
27 |      *
28 |      * @param context
29 |      * @return
30 |      */
31 |     public static int getScreenHeight(Context context) {
32 |         return context.getResources().getDisplayMetrics().heightPixels;
33 |     }
34 | 
35 |     /**
36 |      * 手机屏幕DPI
37 |      *
38 |      * @param context
39 |      * @return
40 |      */
41 |     public static int getScreenDpi(Context context) {
42 |         return context.getResources().getDisplayMetrics().densityDpi;
43 | 
44 |     }
45 | 
46 |     public static int getVersionCode() {
47 |         return Build.VERSION.SDK_INT;
48 |     }
49 |     public static boolean isIpAddress(String ip){
50 |         return ip.matches(ipRegex);
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/application/ScreenApplication.java:
--------------------------------------------------------------------------------
 1 | package com.ryan.screenrecoder.application;
 2 | 
 3 | import android.app.Application;
 4 | import android.hardware.display.DisplayManager;
 5 | import android.media.projection.MediaProjection;
 6 | import android.util.Log;
 7 | 
 8 | import com.ryan.screenrecoder.util.SysUtil;
 9 | 
10 | import org.greenrobot.eventbus.EventBus;
11 | 
12 | import java.nio.IntBuffer;
13 | 
14 | /**
15 |  * Created by zx315476228 on 17-3-10.
16 |  */
17 | 
18 | public class ScreenApplication extends Application {
19 |     private MediaProjection mediaProjection;
20 |     private DisplayManager displayManager;
21 |     private  static ScreenApplication screenApplication;
22 |     public MediaProjection getMediaProjection() {
23 |         return mediaProjection;
24 |     }
25 | 
26 |     public void setMediaProjection(MediaProjection mediaProjection) {
27 |         this.mediaProjection = mediaProjection;
28 |     }
29 | 
30 |     public DisplayManager getDisplayManager() {
31 |         return displayManager;
32 |     }
33 | 
34 |     public void setDisplayManager(DisplayManager displayManager) {
35 |         this.displayManager = displayManager;
36 |     }
37 | 
38 |     public static ScreenApplication getInstance() {
39 |         return screenApplication;
40 |     }
41 | 
42 |     @Override
43 |     public void onCreate() {
44 |         super.onCreate();
45 |         screenApplication=this;
46 |         SysValue.api = SysUtil.getVersionCode();
47 |         SysValue.screen_width = SysUtil.getScreenWidth(this);
48 |         SysValue.screen_height = SysUtil.getScreenHeight(this);
49 |         SysValue.screen_dpi = SysUtil.getScreenDpi(this);
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     package="com.ryan.screenrecoder">
 4 | 
 5 |     <!-- android:sharedUserId="android.uid.system" -->
 6 |     <!-- 为了能使用OpenGLES 2.0 API，你必须在你的manifest中添加以下声明： -->
 7 |     <!-- <uses-feature android:glEsVersion="0x00020000" android:required="true" /> -->
 8 |     <!-- &lt;!&ndash; 如果你的应用要使用纹理压缩功能，你必须还要声明设备需要支持什么样的压缩格式&ndash;&gt; -->
 9 |     <!-- <supports-gl-texture android:name="GL_OES_compressed_ETC1_RGB8_texture" /> -->
10 |     <!-- <supports-gl-texture android:name="GL_OES_compressed_paletted_texture" /> -->
11 |     <uses-permission android:name="android.permission.CAMERA" />
12 |     <uses-permission android:name="android.permission.INTERNET" />
13 |     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
14 |     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
15 | 
16 |     <application
17 |         android:name=".application.ScreenApplication"
18 |         android:allowBackup="true"
19 |         android:icon="@mipmap/ic_launcher"
20 |         android:label="@string/app_name"
21 |         android:roundIcon="@mipmap/ic_launcher_round"
22 |         android:supportsRtl="true"
23 |         android:theme="@style/AppTheme">
24 |         <activity
25 |             android:name=".ui.activity.TcpSendActivity"
26 |             android:theme="@style/Theme.AppCompat.NoActionBar" />
27 |         <activity android:name=".ui.activity.MainActivity">
28 |             <intent-filter>
29 |                 <action android:name="android.intent.action.MAIN" />
30 | 
31 |                 <category android:name="android.intent.category.LAUNCHER" />
32 |             </intent-filter>
33 |         </activity>
34 |         <activity android:name=".ui.activity.PlayerActivity"
35 |             android:theme="@android:style/Theme.Translucent.NoTitleBar.Fullscreen"/>
36 |     </application>
37 | 
38 | </manifest>


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/ui/activity/PlayerActivity.java:
--------------------------------------------------------------------------------
 1 | package com.ryan.screenrecoder.ui.activity;
 2 | 
 3 | import android.app.Activity;
 4 | import android.media.MediaCodec;
 5 | import android.media.MediaFormat;
 6 | import android.support.v7.app.AppCompatActivity;
 7 | import android.os.Bundle;
 8 | import android.view.Surface;
 9 | import android.view.SurfaceHolder;
10 | import android.view.SurfaceView;
11 | 
12 | import com.ryan.screenrecoder.R;
13 | import com.ryan.screenrecoder.conn.TcpServerThread;
14 | 
15 | import java.io.IOException;
16 | import java.nio.ByteBuffer;
17 | 
18 | public class PlayerActivity extends Activity implements SurfaceHolder.Callback, TcpServerThread.onFrameCallBack {
19 | 
20 |     private SurfaceView surfaceview_play;
21 |     private MediaCodec decoder;
22 |     private int TIME_INTERNAL = 1000;
23 |     private int mCount = 0;
24 |     private TcpServerThread serverThread;
25 |     @Override
26 |     protected void onCreate(Bundle savedInstanceState) {
27 |         super.onCreate(savedInstanceState);
28 |         setContentView(R.layout.activity_player);
29 |         surfaceview_play = ((SurfaceView) findViewById(R.id.surfaceview_play));
30 |         surfaceview_play.getHolder().addCallback(this);
31 |     }
32 | 
33 |     @Override
34 |     public void surfaceCreated(SurfaceHolder holder) {
35 |         initMediaDecoder(holder.getSurface());
36 |         serverThread=new TcpServerThread(this);
37 |         serverThread.start();
38 |     }
39 | 
40 |     @Override
41 |     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
42 | 
43 |     }
44 | 
45 |     @Override
46 |     public void surfaceDestroyed(SurfaceHolder holder) {
47 | 
48 |     }
49 | 
50 |     @Override
51 |     public void onFrame(byte[] buf) {
52 |         ByteBuffer[] inputBuffers = decoder.getInputBuffers();
53 |         int inputBufferIndex = decoder.dequeueInputBuffer(0);
54 |         if (inputBufferIndex >= 0) {
55 |             ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
56 |             inputBuffer.clear();
57 |             inputBuffer.put(buf, 0, buf.length);
58 |             decoder.queueInputBuffer(inputBufferIndex, 0, buf.length, mCount * 1000000 / TIME_INTERNAL, 0);
59 |             mCount++;
60 |         }
61 | 
62 |         MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
63 |         int outputBufferIndex = decoder.dequeueOutputBuffer(bufferInfo,0);
64 |         while (outputBufferIndex >= 0) {
65 |             decoder.releaseOutputBuffer(outputBufferIndex, true);
66 |             outputBufferIndex = decoder.dequeueOutputBuffer(bufferInfo, 0);
67 |         }
68 |     }
69 |     private void initMediaDecoder(Surface surface) {
70 |         MediaFormat mediaFormat = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, 1080, 1920);
71 |         try {
72 |             decoder = MediaCodec.createDecoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
73 |             decoder.configure(mediaFormat, surface, null, 0);
74 |             decoder.start();
75 |         } catch (IOException e) {
76 |             e.printStackTrace();
77 |         }
78 |     }
79 | 
80 |     @Override
81 |     protected void onDestroy() {
82 |         super.onDestroy();
83 |         serverThread.close();
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/conn/TcpServerThread.java:
--------------------------------------------------------------------------------
  1 | package com.ryan.screenrecoder.conn;
  2 | 
  3 | import android.util.Log;
  4 | 
  5 | import java.io.BufferedInputStream;
  6 | import java.io.FileNotFoundException;
  7 | import java.io.IOException;
  8 | import java.net.ServerSocket;
  9 | import java.net.Socket;
 10 | import java.util.Timer;
 11 | import java.util.TimerTask;
 12 | 
 13 | /**
 14 |  * Created by zx315476228 on 17-3-14.
 15 |  */
 16 | 
 17 | public class TcpServerThread extends Thread {
 18 |     private final int PORT=6111;
 19 |     private BufferedInputStream dataInputStream;
 20 |     private onFrameCallBack callBack;
 21 |     private long timer_size;
 22 |     private boolean isStart=true;
 23 |     private Timer timer=new Timer();
 24 |     private TimerTask timerTask=new TimerTask() {
 25 |         @Override
 26 |         public void run() {
 27 |             Log.e("---","接收速度:"+(timer_size/1024)+"kb/s");
 28 |             timer_size=0;
 29 |         }
 30 |     };
 31 |     public TcpServerThread(onFrameCallBack callBack) {
 32 |         this.callBack = callBack;
 33 |     }
 34 | 
 35 |     public interface onFrameCallBack{
 36 |         void onFrame(byte[] data);
 37 |     }
 38 |     public void close(){
 39 |         isStart=false;
 40 |     }
 41 |     @Override
 42 |     public void run() {
 43 |         super.run();
 44 |         try {
 45 |             ServerSocket serverSocket=new ServerSocket(PORT);
 46 |             Socket clientSocket=serverSocket.accept();
 47 |             timer.schedule(timerTask,0,1000);
 48 |             dataInputStream=new BufferedInputStream(clientSocket.getInputStream());
 49 |             while (isStart){
 50 |                 int readsize = dataInputStream.available();
 51 |                 int ret = 0;
 52 |                 if (readsize < 4) {
 53 |                     try {
 54 |                         Thread.sleep(10);
 55 |                     } catch (InterruptedException e) {
 56 |                         e.printStackTrace();
 57 |                     }
 58 |                     continue;
 59 |                 }
 60 |                 byte[] tmpArray = new byte[4];
 61 |                 do {
 62 |                     ret += dataInputStream.read(tmpArray, ret, 4 - ret);
 63 |                 } while (ret < 4);
 64 |                 paseTeacherMessage(tmpArray);
 65 |             }
 66 |             if(dataInputStream!=null)
 67 |                 dataInputStream.close();
 68 |             if(clientSocket!=null)
 69 |                 clientSocket.close();
 70 |             if(serverSocket!=null)
 71 |                 serverSocket.close();
 72 |         } catch (IOException e) {
 73 |             e.printStackTrace();
 74 |         }
 75 |     }
 76 |     /**
 77 |      * 数据解析
 78 |      *
 79 |      * @param data
 80 |      */
 81 |     private void paseTeacherMessage(byte[] data) {
 82 |         int size = bytesToInt(data, 0);//帧大小
 83 |         timer_size+=size;
 84 |         byte[] tmpArray = new byte[size];
 85 |         int ret=0;
 86 |         try {
 87 |             do {
 88 |                 ret += dataInputStream.read(tmpArray, ret, size - ret);
 89 |             } while (ret < size);
 90 |             callBack.onFrame(tmpArray);
 91 |         } catch (FileNotFoundException e) {
 92 |             e.printStackTrace();
 93 |         } catch (IOException e) {
 94 |             e.printStackTrace();
 95 |         } catch (Exception e) {
 96 |         }
 97 |     }
 98 |     public static int bytesToInt(byte[] ary, int offset) {
 99 |         int value;
100 |         value = (int) ((ary[offset] & 0xFF)
101 |                 | ((ary[offset + 1] << 8) & 0xFF00)
102 |                 | ((ary[offset + 2] << 16) & 0xFF0000)
103 |                 | ((ary[offset + 3] << 24) & 0xFF000000));
104 |         return value;
105 |     }
106 |     public static long bytes2Long(byte[] byteNum,int offset) {
107 |         long num = 0;
108 |         for (int ix = 0; ix < 8; ++ix) {
109 |             num <<= 8;
110 |             num |= (byteNum[ix+offset] & 0xff);
111 |         }
112 |         return num;
113 |     }
114 | 
115 | }
116 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/conn/TcpSendThread.java:
--------------------------------------------------------------------------------
  1 | package com.ryan.screenrecoder.conn;
  2 | 
  3 | import android.util.Log;
  4 | 
  5 | import com.ryan.screenrecoder.bean.EventLogBean;
  6 | 
  7 | import org.greenrobot.eventbus.EventBus;
  8 | 
  9 | import java.io.BufferedInputStream;
 10 | import java.io.BufferedOutputStream;
 11 | import java.io.IOException;
 12 | import java.net.Socket;
 13 | 
 14 | /**
 15 |  * Created by zx315476228 on 17-3-14.
 16 |  */
 17 | 
 18 | public class TcpSendThread extends Thread {
 19 |     private final int port = 6111;
 20 |     private String ip = "192.168.0.132";
 21 |     private BufferedInputStream inputStream;
 22 |     private BufferedOutputStream outputStream;
 23 |     private OnConnCallBack onSendCallBack;
 24 |     private boolean isRuning;
 25 |     private Socket socket;
 26 | 
 27 |     public void setIp(String ip) {
 28 |         this.ip = ip;
 29 |     }
 30 | 
 31 |     public void setOnSendCallBack(OnConnCallBack onSendCallBack) {
 32 |         this.onSendCallBack = onSendCallBack;
 33 |     }
 34 | 
 35 |     public interface OnConnCallBack {
 36 |         void onConnSuccess(String ip);
 37 |     }
 38 | 
 39 |     public TcpSendThread(OnConnCallBack onSendCallBack) {
 40 |         this.onSendCallBack = onSendCallBack;
 41 |     }
 42 | 
 43 |     @Override
 44 |     public void run() {
 45 |         super.run();
 46 |         try {
 47 |             EventBus.getDefault().post(new EventLogBean("等待连接"));
 48 |             socket = new Socket(ip, port);
 49 |             Log.e("---", "连接成功");
 50 |             EventBus.getDefault().post(new EventLogBean("连接成功!!!"));
 51 |             inputStream = new BufferedInputStream(socket.getInputStream());
 52 |             outputStream = new BufferedOutputStream(socket.getOutputStream());
 53 |             onSendCallBack.onConnSuccess(ip);
 54 |             isRuning = true;
 55 |             while (isRuning) {
 56 |                 int readSize = inputStream.available();
 57 |                 if (readSize < 4) {
 58 |                     try {
 59 |                         Thread.sleep(10);
 60 |                     } catch (InterruptedException e) {
 61 |                         e.printStackTrace();
 62 |                     }
 63 |                 }
 64 |             }
 65 |         } catch (IOException e) {
 66 |             e.printStackTrace();
 67 |         }
 68 |         close();
 69 |     }
 70 | 
 71 |     private void closeConn() {
 72 | 
 73 |         try {
 74 |             if (inputStream != null) {
 75 |                 inputStream.close();
 76 |             }
 77 |             if (outputStream != null) {
 78 |                 outputStream.close();
 79 |             }
 80 |             if (socket != null) {
 81 |                 socket.close();
 82 |             }
 83 |         } catch (IOException e) {
 84 |             e.printStackTrace();
 85 |         }
 86 |     }
 87 | 
 88 |     public void sendMessage(byte[] data) {
 89 |         byte[] content = new byte[data.length + 4];
 90 |         System.arraycopy(intToBytes(data.length), 0, content, 0, 4);
 91 |         System.arraycopy(data, 0, content, 4, data.length);
 92 |         try {
 93 |             outputStream.write(content, 0, content.length);
 94 |             outputStream.flush();
 95 |         } catch (IOException e) {
 96 |             e.printStackTrace();
 97 |         }
 98 |     }
 99 | 
100 |     public static byte[] intToBytes(int value) {
101 |         byte[] byte_src = new byte[4];
102 |         byte_src[3] = (byte) ((value & 0xFF000000) >> 24);
103 |         byte_src[2] = (byte) ((value & 0x00FF0000) >> 16);
104 |         byte_src[1] = (byte) ((value & 0x0000FF00) >> 8);
105 |         byte_src[0] = (byte) ((value & 0x000000FF));
106 |         return byte_src;
107 |     }
108 | 
109 |     public static byte[] long2Bytes(long num) {
110 |         byte[] byteNum = new byte[8];
111 |         for (int ix = 0; ix < 8; ++ix) {
112 |             int offset = 64 - (ix + 1) * 8;
113 |             byteNum[ix] = (byte) ((num >> offset) & 0xff);
114 |         }
115 |         return byteNum;
116 |     }
117 | 
118 |     public void close() {
119 |         isRuning = false;
120 |     }
121 | }
122 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/ui/activity/MainActivity.java:
--------------------------------------------------------------------------------
  1 | package com.ryan.screenrecoder.ui.activity;
  2 | 
  3 | import android.Manifest;
  4 | import android.app.Activity;
  5 | import android.content.Context;
  6 | import android.content.Intent;
  7 | import android.content.pm.PackageManager;
  8 | import android.hardware.display.DisplayManager;
  9 | import android.media.projection.MediaProjectionManager;
 10 | import android.os.Build;
 11 | import android.os.Bundle;
 12 | import android.support.annotation.NonNull;
 13 | import android.support.v4.app.ActivityCompat;
 14 | import android.support.v7.app.AppCompatActivity;
 15 | import android.text.TextUtils;
 16 | import android.view.View;
 17 | import android.widget.Button;
 18 | import android.widget.EditText;
 19 | import android.widget.Toast;
 20 | 
 21 | import com.ryan.screenrecoder.R;
 22 | import com.ryan.screenrecoder.application.ScreenApplication;
 23 | import com.ryan.screenrecoder.application.SysValue;
 24 | import com.ryan.screenrecoder.util.SharedUtil;
 25 | import com.ryan.screenrecoder.util.SysUtil;
 26 | 
 27 | public class MainActivity extends Activity implements View.OnClickListener {
 28 |     private final int REQUEST_CODE = 0x11;
 29 |     private final int PERMISSION_CODE = 0x12;
 30 |     private static final String DEFAULT_IP = "192.168.0.132";
 31 | 
 32 |     private Button button_tcp_preview;
 33 |     private Button button_tcp_send;
 34 |     private EditText edittext_tcp_send_ip;
 35 | 
 36 |     private MediaProjectionManager mediaProjectionManager;
 37 | 
 38 |     @Override
 39 |     protected void onCreate(Bundle savedInstanceState) {
 40 |         super.onCreate(savedInstanceState);
 41 |         setContentView(R.layout.activity_main);
 42 |         button_tcp_preview = ((Button) findViewById(R.id.button_tcp_preview));
 43 |         button_tcp_send = ((Button) findViewById(R.id.button_tcp_send));
 44 |         edittext_tcp_send_ip = ((EditText) findViewById(R.id.edittext_tcp_send_ip));
 45 |         edittext_tcp_send_ip.setText(SharedUtil.init(this).getIp());
 46 |         button_tcp_preview.setOnClickListener(this);
 47 |         button_tcp_send.setOnClickListener(this);
 48 |         if (SysValue.api >= Build.VERSION_CODES.M) {
 49 |             getAppPermission();
 50 |         } else if (SysValue.api >= 21) {
 51 |             getMeidProjection();
 52 |         } else {
 53 |             //todo 需要root权限或系统签名
 54 |             ScreenApplication.getInstance().setDisplayManager(((DisplayManager) getSystemService(Context.DISPLAY_SERVICE)));
 55 |         }
 56 |     }
 57 | 
 58 |     private void getAppPermission() {
 59 |         ActivityCompat.requestPermissions(this,
 60 |                 new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
 61 |                 PERMISSION_CODE);
 62 |     }
 63 | 
 64 |     private void getMeidProjection() {
 65 |         mediaProjectionManager = (MediaProjectionManager) getSystemService(MEDIA_PROJECTION_SERVICE);
 66 |         startActivityForResult(mediaProjectionManager.createScreenCaptureIntent(), REQUEST_CODE);
 67 |     }
 68 | 
 69 |     @Override
 70 |     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
 71 |         super.onActivityResult(requestCode, resultCode, data);
 72 |         if (requestCode == REQUEST_CODE && resultCode == Activity.RESULT_OK) {
 73 |             ScreenApplication.getInstance().setMediaProjection(mediaProjectionManager.getMediaProjection(resultCode, data));
 74 |         } else {
 75 |             Toast.makeText(this, "无法录制屏幕", Toast.LENGTH_SHORT).show();
 76 |         }
 77 |     }
 78 | 
 79 |     @Override
 80 |     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
 81 |         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
 82 |         if (requestCode == PERMISSION_CODE) {
 83 |             if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
 84 |                 getMeidProjection();
 85 |             }
 86 |         }
 87 |     }
 88 | 
 89 |     @Override
 90 |     public void onClick(View v) {
 91 |         switch (v.getId()) {
 92 |             case R.id.button_tcp_preview:
 93 |                 //todo 接收端
 94 |                 startActivity(new Intent(this,PlayerActivity.class));
 95 |                 break;
 96 |             case R.id.button_tcp_send:
 97 |                 //todo 发送端
 98 |                 String ip = edittext_tcp_send_ip.getText().toString();
 99 |                 if (TextUtils.isEmpty(ip)) {
100 |                     ip = DEFAULT_IP;
101 |                 }
102 |                 if (!SysUtil.isIpAddress(ip)) {
103 |                     Toast.makeText(this, "请输入有效的IP地址", Toast.LENGTH_SHORT).show();
104 |                     return;
105 |                 }
106 |                 Intent intent = new Intent(this, TcpSendActivity.class);
107 |                 intent.putExtra("ip", ip);
108 |                 startActivity(intent);
109 |                 break;
110 |         }
111 |     }
112 | }
113 | 


--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env sh
  2 | 
  3 | ##############################################################################
  4 | ##
  5 | ##  Gradle start up script for UN*X
  6 | ##
  7 | ##############################################################################
  8 | 
  9 | # Attempt to set APP_HOME
 10 | # Resolve links: $0 may be a link
 11 | PRG="$0"
 12 | # Need this for relative symlinks.
 13 | while [ -h "$PRG" ] ; do
 14 |     ls=`ls -ld "$PRG"`
 15 |     link=`expr "$ls" : '.*-> \(.*\)$'`
 16 |     if expr "$link" : '/.*' > /dev/null; then
 17 |         PRG="$link"
 18 |     else
 19 |         PRG=`dirname "$PRG"`"/$link"
 20 |     fi
 21 | done
 22 | SAVED="`pwd`"
 23 | cd "`dirname \"$PRG\"`/" >/dev/null
 24 | APP_HOME="`pwd -P`"
 25 | cd "$SAVED" >/dev/null
 26 | 
 27 | APP_NAME="Gradle"
 28 | APP_BASE_NAME=`basename "$0"`
 29 | 
 30 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 31 | DEFAULT_JVM_OPTS=""
 32 | 
 33 | # Use the maximum available, or set MAX_FD != -1 to use that value.
 34 | MAX_FD="maximum"
 35 | 
 36 | warn () {
 37 |     echo "$*"
 38 | }
 39 | 
 40 | die () {
 41 |     echo
 42 |     echo "$*"
 43 |     echo
 44 |     exit 1
 45 | }
 46 | 
 47 | # OS specific support (must be 'true' or 'false').
 48 | cygwin=false
 49 | msys=false
 50 | darwin=false
 51 | nonstop=false
 52 | case "`uname`" in
 53 |   CYGWIN* )
 54 |     cygwin=true
 55 |     ;;
 56 |   Darwin* )
 57 |     darwin=true
 58 |     ;;
 59 |   MINGW* )
 60 |     msys=true
 61 |     ;;
 62 |   NONSTOP* )
 63 |     nonstop=true
 64 |     ;;
 65 | esac
 66 | 
 67 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 68 | 
 69 | # Determine the Java command to use to start the JVM.
 70 | if [ -n "$JAVA_HOME" ] ; then
 71 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
 72 |         # IBM's JDK on AIX uses strange locations for the executables
 73 |         JAVACMD="$JAVA_HOME/jre/sh/java"
 74 |     else
 75 |         JAVACMD="$JAVA_HOME/bin/java"
 76 |     fi
 77 |     if [ ! -x "$JAVACMD" ] ; then
 78 |         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
 79 | 
 80 | Please set the JAVA_HOME variable in your environment to match the
 81 | location of your Java installation."
 82 |     fi
 83 | else
 84 |     JAVACMD="java"
 85 |     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 86 | 
 87 | Please set the JAVA_HOME variable in your environment to match the
 88 | location of your Java installation."
 89 | fi
 90 | 
 91 | # Increase the maximum file descriptors if we can.
 92 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
 93 |     MAX_FD_LIMIT=`ulimit -H -n`
 94 |     if [ $? -eq 0 ] ; then
 95 |         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
 96 |             MAX_FD="$MAX_FD_LIMIT"
 97 |         fi
 98 |         ulimit -n $MAX_FD
 99 |         if [ $? -ne 0 ] ; then
100 |             warn "Could not set maximum file descriptor limit: $MAX_FD"
101 |         fi
102 |     else
103 |         warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
104 |     fi
105 | fi
106 | 
107 | # For Darwin, add options to specify how the application appears in the dock
108 | if $darwin; then
109 |     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
110 | fi
111 | 
112 | # For Cygwin, switch paths to Windows format before running java
113 | if $cygwin ; then
114 |     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
115 |     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
116 |     JAVACMD=`cygpath --unix "$JAVACMD"`
117 | 
118 |     # We build the pattern for arguments to be converted via cygpath
119 |     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
120 |     SEP=""
121 |     for dir in $ROOTDIRSRAW ; do
122 |         ROOTDIRS="$ROOTDIRS$SEP$dir"
123 |         SEP="|"
124 |     done
125 |     OURCYGPATTERN="(^($ROOTDIRS))"
126 |     # Add a user-defined pattern to the cygpath arguments
127 |     if [ "$GRADLE_CYGPATTERN" != "" ] ; then
128 |         OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
129 |     fi
130 |     # Now convert the arguments - kludge to limit ourselves to /bin/sh
131 |     i=0
132 |     for arg in "$@" ; do
133 |         CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
134 |         CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
135 | 
136 |         if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
137 |             eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
138 |         else
139 |             eval `echo args$i`="\"$arg\""
140 |         fi
141 |         i=$((i+1))
142 |     done
143 |     case $i in
144 |         (0) set -- ;;
145 |         (1) set -- "$args0" ;;
146 |         (2) set -- "$args0" "$args1" ;;
147 |         (3) set -- "$args0" "$args1" "$args2" ;;
148 |         (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
149 |         (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
150 |         (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
151 |         (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
152 |         (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
153 |         (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
154 |     esac
155 | fi
156 | 
157 | # Escape application args
158 | save () {
159 |     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
160 |     echo " "
161 | }
162 | APP_ARGS=$(save "$@")
163 | 
164 | # Collect all arguments for the java command, following the shell quoting and substitution rules
165 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
166 | 
167 | # by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
168 | if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
169 |   cd "$(dirname "$0")"
170 | fi
171 | 
172 | exec "$JAVACMD" "$@"
173 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/ui/activity/TcpSendActivity.java:
--------------------------------------------------------------------------------
  1 | package com.ryan.screenrecoder.ui.activity;
  2 | 
  3 | import android.graphics.Bitmap;
  4 | import android.hardware.display.DisplayManager;
  5 | import android.media.MediaPlayer;
  6 | import android.media.projection.MediaProjection;
  7 | import android.net.Uri;
  8 | import android.os.Bundle;
  9 | import android.os.Environment;
 10 | import android.os.Handler;
 11 | import android.os.Message;
 12 | import android.support.v7.app.AppCompatActivity;
 13 | import android.view.View;
 14 | import android.widget.Toast;
 15 | import android.widget.VideoView;
 16 | 
 17 | import com.ryan.screenrecoder.R;
 18 | import com.ryan.screenrecoder.application.ScreenApplication;
 19 | import com.ryan.screenrecoder.application.SysValue;
 20 | import com.ryan.screenrecoder.bean.EventLogBean;
 21 | import com.ryan.screenrecoder.coder.MediaEncoder;
 22 | import com.ryan.screenrecoder.conn.TcpSendThread;
 23 | import com.ryan.screenrecoder.util.SharedUtil;
 24 | 
 25 | import org.greenrobot.eventbus.EventBus;
 26 | import org.greenrobot.eventbus.Subscribe;
 27 | import org.greenrobot.eventbus.ThreadMode;
 28 | 
 29 | import java.io.FileNotFoundException;
 30 | import java.io.FileOutputStream;
 31 | import java.lang.ref.WeakReference;
 32 | 
 33 | 
 34 | public class TcpSendActivity extends AppCompatActivity implements TcpSendThread.OnConnCallBack, MediaEncoder.OnScreenCallBack {
 35 |     private static final int HANDLER_CONN_SUCCESS = 0;
 36 |     private static final int HANDLER_CUT_SCRENN_SUCCESS = 1;
 37 | 
 38 |     private static final int BIT = 3000000;
 39 |     private static final int FPS = 8;//FPS
 40 | 
 41 |     private MediaEncoder encoder;
 42 | 
 43 |     private TcpSendThread tcpSendThread;
 44 |     private MHandler handler = new MHandler(this);
 45 | 
 46 |     private static class MHandler extends Handler {
 47 |         private final WeakReference<TcpSendActivity> mActivity;
 48 | 
 49 |         MHandler(TcpSendActivity activity) {
 50 |             mActivity = new WeakReference<>(activity);
 51 |         }
 52 | 
 53 |         @Override
 54 |         public void handleMessage(Message msg) {
 55 |             super.handleMessage(msg);
 56 |             switch (msg.what) {
 57 |                 case HANDLER_CUT_SCRENN_SUCCESS:
 58 |                     try {
 59 |                         FileOutputStream outputStream = new FileOutputStream(Environment.getExternalStorageDirectory().getAbsolutePath() + "/111.png");
 60 |                         Bitmap bitmap = (Bitmap) msg.obj;
 61 |                         bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
 62 |                         Toast.makeText(mActivity.get(), "截图已保存至:sdCard/111.png", Toast.LENGTH_LONG).show();
 63 |                     } catch (FileNotFoundException e) {
 64 |                         e.printStackTrace();
 65 |                     }
 66 |                     break;
 67 |                 case HANDLER_CONN_SUCCESS:
 68 |                     Toast.makeText(mActivity.get(), "连接成功，开始录屏", Toast.LENGTH_SHORT).show();
 69 |                     break;
 70 |             }
 71 |         }
 72 |     }
 73 | 
 74 |     private VideoView videoView_test;
 75 | 
 76 |     @Override
 77 |     protected void onCreate(Bundle savedInstanceState) {
 78 |         super.onCreate(savedInstanceState);
 79 |         EventBus.getDefault().register(this);
 80 |         setContentView(R.layout.activity_tcp_send);
 81 |         videoView_test = ((VideoView) findViewById(R.id.videoView_test));
 82 | 
 83 | 
 84 |         String uri = "android.resource://" + getPackageName() + "/" + R.raw.test;
 85 |         videoView_test.setVideoURI(Uri.parse(uri));
 86 |         videoView_test.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
 87 |             @Override
 88 |             public void onPrepared(MediaPlayer mediaPlayer) {
 89 |                 mediaPlayer.start();
 90 |                 mediaPlayer.setLooping(true);
 91 |             }
 92 |         });
 93 | 
 94 |          findViewById(R.id.button_cutscreen).setOnClickListener(new View.OnClickListener() {
 95 |             @Override
 96 |             public void onClick(View v) {
 97 |                 if (encoder != null)
 98 |                     encoder.cutScreen();
 99 |             }
100 | 
101 |         });
102 | 
103 |         tcpSendThread = new TcpSendThread(this);
104 |         tcpSendThread.setIp(getIntent().getStringExtra("ip"));
105 |         tcpSendThread.start();
106 |     }
107 | 
108 |     /**
109 |      * 连接成功后开始录屏
110 |      */
111 |     private void startRecording() {
112 |         if (SysValue.api >= 21) {
113 |             MediaProjection mediaProjection = ScreenApplication.getInstance().getMediaProjection();
114 |             if (mediaProjection != null) {
115 |                 encoder = new MediaEncoder(mediaProjection, 1080, 1920, SysValue.screen_dpi)
116 |                         .setVideoBit(BIT)
117 |                         .setVideoFPS(FPS);
118 |             }
119 |         } else {
120 |             DisplayManager displayManager = ScreenApplication.getInstance().getDisplayManager();
121 |             if (displayManager != null) {
122 |                 encoder = new MediaEncoder(displayManager, SysValue.screen_width, SysValue.screen_height, SysValue.screen_dpi)
123 |                         .setVideoBit(BIT)
124 |                         .setVideoFPS(FPS);
125 |             }
126 |         }
127 |         if (encoder != null) {
128 |             encoder.setOnScreenCallBack(this);
129 |             encoder.start();
130 |         }
131 |         videoView_test.start();
132 |     }
133 | 
134 |     @Subscribe(threadMode = ThreadMode.MAIN)
135 |     public void onEvent(EventLogBean logBean) {
136 |     }
137 | 
138 |     @Override
139 |     protected void onDestroy() {
140 |         super.onDestroy();
141 |         tcpSendThread.close();//关闭连接
142 |         if (encoder != null)
143 |             encoder.stopScreen();//关闭截屏
144 |         if (videoView_test.isPlaying())
145 |             videoView_test.stopPlayback();
146 |         EventBus.getDefault().unregister(this);
147 |     }
148 | 
149 |     @Override
150 |     public void onConnSuccess(String ip) {
151 |         startRecording();
152 |         SharedUtil.init(this).setIp(ip);
153 |         handler.sendEmptyMessage(HANDLER_CONN_SUCCESS);
154 | 
155 |     }
156 | 
157 |     @Override
158 |     public void onScreenInfo(byte[] bytes) {
159 |         tcpSendThread.sendMessage(bytes);
160 |     }
161 | 
162 |     @Override
163 |     public void onCutScreen(Bitmap bitmap) {
164 |         handler.obtainMessage(HANDLER_CUT_SCRENN_SUCCESS, bitmap).sendToTarget();
165 |     }
166 | }
167 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/glec/STextureRender.java:
--------------------------------------------------------------------------------
  1 | package com.ryan.screenrecoder.glec;
  2 | 
  3 | import android.graphics.SurfaceTexture;
  4 | import android.opengl.GLES11Ext;
  5 | import android.opengl.GLES20;
  6 | import android.opengl.Matrix;
  7 | import android.util.Log;
  8 | 
  9 | import java.nio.FloatBuffer;
 10 | import java.nio.IntBuffer;
 11 | 
 12 | /**
 13 |  * Created by guoheng on 2016/8/31.
 14 |  */
 15 | public  class STextureRender {
 16 |     private static final int FLOAT_SIZE_BYTES = 4;
 17 |     private static final String TAG = "STextureRendering";
 18 | 
 19 | 
 20 |     private static final float FULL_RECTANGLE_COORDS[] = {
 21 |             -1.0f, -1.0f,1.0f,   // 0 bottom left
 22 |             1.0f, -1.0f,1.0f,   // 1 bottom right
 23 |             -1.0f,  1.0f,1.0f,   // 2 top left
 24 |             1.0f,  1.0f,1.0f   // 3 top right
 25 |     };
 26 | 
 27 |     private static final float FULL_RECTANGLE_TEX_COORDS[] = {
 28 |             0.0f, 1.0f, 1f,1.0f,    // 0 bottom left
 29 |             1.0f, 1.0f,1f,1.0f,     // 1 bottom right
 30 |             0.0f, 0.0f, 1f,1.0f,    // 2 top left
 31 |             1.0f, 0.0f ,1f,1.0f     // 3 top right
 32 |     };
 33 | 
 34 |     private static final FloatBuffer FULL_RECTANGLE_BUF =
 35 |             GlUtil.createFloatBuffer(FULL_RECTANGLE_COORDS);
 36 |     private static final FloatBuffer FULL_RECTANGLE_TEX_BUF =
 37 |             GlUtil.createFloatBuffer(FULL_RECTANGLE_TEX_COORDS);
 38 | 
 39 | 
 40 |     private static final String VERTEX_SHADER =
 41 |             "uniform mat4 uMVPMatrix;\n" +
 42 |                     "uniform mat4 uSTMatrix;\n" +
 43 |                     "attribute vec4 aPosition;\n" +
 44 |                     "attribute vec4 aTextureCoord;\n" +
 45 |                     "varying vec4 vTextureCoord;\n" +
 46 |                     "void main() {\n" +
 47 |                     "    gl_Position = uMVPMatrix * aPosition;\n" +
 48 |                     "    vTextureCoord = uSTMatrix * aTextureCoord;\n" +
 49 |                     "}\n";
 50 | 
 51 |     private static final String FRAGMENT_SHADER =
 52 |             "#extension GL_OES_EGL_image_external : require\n" +
 53 |                     "precision mediump float;\n" +      // highp here doesn't seem to matter
 54 |                     "varying vec4 vTextureCoord;\n" +
 55 |                     "uniform samplerExternalOES sTexture;\n" +
 56 |                     "void main() {\n" +
 57 |                     "    gl_FragColor = texture2D(sTexture, vTextureCoord.xy/vTextureCoord.z);" +
 58 |                     "}\n";
 59 | 
 60 | 
 61 | 
 62 | 
 63 |     private float[] mMVPMatrix = new float[16];
 64 |     private float[] mSTMatrix = new float[16];
 65 | 
 66 |     private int mProgram;
 67 |     private int mTextureID = -12345;
 68 |     private int muMVPMatrixHandle;
 69 |     private int muSTMatrixHandle;
 70 |     private int maPositionHandle;
 71 |     private int maTextureHandle;
 72 |     private int mWidth;
 73 |     private int mHeight;
 74 | 
 75 |     public STextureRender(int mwidth, int mHeight) {
 76 |         this();
 77 |         this.mWidth = mwidth;
 78 |         this.mHeight = mHeight;
 79 |     }
 80 | 
 81 |     public STextureRender() {
 82 |         Matrix.setIdentityM(mSTMatrix, 0);
 83 |     }
 84 | 
 85 |     public int getTextureId() {
 86 |         return mTextureID;
 87 |     }
 88 | 
 89 | 
 90 | 
 91 |     /**
 92 |      * Initializes GL state.  Call this after the EGL surface has been created and made current.
 93 |      */
 94 |     public void surfaceCreated() {
 95 |         mProgram = GlUtil.createProgram(VERTEX_SHADER, FRAGMENT_SHADER);
 96 |         if (mProgram == 0) {
 97 |             throw new RuntimeException("failed creating program");
 98 |         }
 99 | 
100 | 
101 |         maPositionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition");
102 |         maTextureHandle = GLES20.glGetAttribLocation(mProgram, "aTextureCoord");
103 |         muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
104 |         muSTMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uSTMatrix");
105 | 
106 | 
107 |         mTextureID = initTex();
108 | 
109 | //        GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MIN_FILTER,
110 | //                GLES20.GL_NEAREST);
111 | //        GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER,
112 | //                GLES20.GL_LINEAR);
113 | //        GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_S,
114 | //                GLES20.GL_CLAMP_TO_EDGE);
115 | //        GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_T,
116 | //                GLES20.GL_CLAMP_TO_EDGE);
117 |     }
118 |     /**
119 |      * create external texture
120 |      *
121 |      * @return texture ID
122 |      */
123 |     public static int initTex() {
124 |         int[] tex = new int[1];
125 |         GLES20.glGenTextures(1, tex, 0);
126 |         GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
127 |         GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,tex[0]);
128 |         GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
129 |                 GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
130 |         GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
131 |                 GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
132 |         GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
133 |                 GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
134 |         GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
135 |                 GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_NEAREST);
136 |         return tex[0];
137 |     }
138 | 
139 | 
140 |     /**
141 |      * Draws the external texture in SurfaceTexture onto the current EGL surface.
142 |      */
143 |     public void drawFrame() {
144 |         GLES20.glUseProgram(mProgram);
145 | 
146 |         // Enable the "aPosition" vertex attribute.
147 |         GLES20.glEnableVertexAttribArray(maPositionHandle);
148 | 
149 |         // Connect vertexBuffer to "aPosition".
150 |         GLES20.glVertexAttribPointer(maPositionHandle, 3,
151 |                 GLES20.GL_FLOAT, false, 3*FLOAT_SIZE_BYTES, FULL_RECTANGLE_BUF);
152 | 
153 |         // Enable the "aTextureCoord" vertex attribute.
154 |         GLES20.glEnableVertexAttribArray(maTextureHandle);
155 | 
156 |         // Connect texBuffer to "aTextureCoord".
157 |         GLES20.glVertexAttribPointer(maTextureHandle, 4,
158 |                 GLES20.GL_FLOAT, false, 4*FLOAT_SIZE_BYTES, FULL_RECTANGLE_TEX_BUF);
159 | 
160 |         Matrix.setIdentityM(mMVPMatrix, 0);
161 |         GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0);
162 |         GLES20.glUniformMatrix4fv(muSTMatrixHandle, 1, false, mSTMatrix, 0);
163 | 
164 | 
165 |         // Draw the rect.
166 |         GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
167 | 
168 |         // Done -- disable vertex array, texture, and program.
169 |         GLES20.glDisableVertexAttribArray(maPositionHandle);
170 |         GLES20.glDisableVertexAttribArray(maTextureHandle);
171 |         GLES20.glUseProgram(0);
172 | 
173 |     }
174 | 
175 | 
176 | }
177 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/glec/GlUtil.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2014 Google Inc. All rights reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *      http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | package com.ryan.screenrecoder.glec;
 18 | 
 19 | import android.opengl.GLES20;
 20 | import android.opengl.GLES30;
 21 | import android.opengl.Matrix;
 22 | import android.util.Log;
 23 | 
 24 | import java.nio.ByteBuffer;
 25 | import java.nio.ByteOrder;
 26 | import java.nio.FloatBuffer;
 27 | 
 28 | /**
 29 |  * Some OpenGL utility functions.
 30 |  */
 31 | public class GlUtil {
 32 |     public static final String TAG = "EncodeDecodeSurface";
 33 | 
 34 |     /** Identity matrix for general use.  Don't modify or life will get weird. */
 35 |     public static final float[] IDENTITY_MATRIX;
 36 |     static {
 37 | 
 38 |         IDENTITY_MATRIX = new float[16];
 39 |         Matrix.setIdentityM(IDENTITY_MATRIX, 0);
 40 |         //Matrix.scaleM(IDENTITY_MATRIX,0,0.5f,0.5f,1);
 41 |     }
 42 | 
 43 |     private static final int SIZEOF_FLOAT = 4;
 44 | 
 45 | 
 46 |     private GlUtil() {}     // do not instantiate
 47 | 
 48 |     /**
 49 |      * Creates a new program from the supplied vertex and fragment shaders.
 50 |      *
 51 |      * @return A handle to the program, or 0 on failure.
 52 |      */
 53 |     public static int createProgram(String vertexSource, String fragmentSource) {
 54 |         int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
 55 |         if (vertexShader == 0) {
 56 |             return 0;
 57 |         }
 58 |         int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
 59 |         if (pixelShader == 0) {
 60 |             return 0;
 61 |         }
 62 | 
 63 |         int program = GLES20.glCreateProgram();
 64 |         checkGlError("glCreateProgram");
 65 |         if (program == 0) {
 66 |             Log.e(TAG, "Could not create program");
 67 |         }
 68 |         GLES20.glAttachShader(program, vertexShader);
 69 |         checkGlError("glAttachShader");
 70 |         GLES20.glAttachShader(program, pixelShader);
 71 |         checkGlError("glAttachShader");
 72 |         GLES20.glLinkProgram(program);
 73 |         int[] linkStatus = new int[1];
 74 |         GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
 75 |         if (linkStatus[0] != GLES20.GL_TRUE) {
 76 |             Log.e(TAG, "Could not link program: ");
 77 |             Log.e(TAG, GLES20.glGetProgramInfoLog(program));
 78 |             GLES20.glDeleteProgram(program);
 79 |             program = 0;
 80 |         }
 81 |         return program;
 82 |     }
 83 | 
 84 |     /**
 85 |      * Compiles the provided shader source.
 86 |      *
 87 |      * @return A handle to the shader, or 0 on failure.
 88 |      */
 89 |     public static int loadShader(int shaderType, String source) {
 90 |         int shader = GLES20.glCreateShader(shaderType);
 91 |         checkGlError("glCreateShader type=" + shaderType);
 92 |         GLES20.glShaderSource(shader, source);
 93 |         GLES20.glCompileShader(shader);
 94 |         int[] compiled = new int[1];
 95 |         GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
 96 |         if (compiled[0] == 0) {
 97 |             Log.e(TAG, "Could not compile shader " + shaderType + ":");
 98 |             Log.e(TAG, " " + GLES20.glGetShaderInfoLog(shader));
 99 |             GLES20.glDeleteShader(shader);
100 |             shader = 0;
101 |         }
102 |         return shader;
103 |     }
104 | 
105 |     /**
106 |      * Checks to see if a GLES error has been raised.
107 |      */
108 |     public static void checkGlError(String op) {
109 |         int error = GLES20.glGetError();
110 |         if (error != GLES20.GL_NO_ERROR) {
111 |             String msg = op + ": glError 0x" + Integer.toHexString(error);
112 |             Log.e(TAG, msg);
113 |             throw new RuntimeException(msg);
114 |         }
115 |     }
116 | 
117 |     /**
118 |      * Checks to see if the location we obtained is valid.  GLES returns -1 if a label
119 |      * could not be found, but does not set the GL error.
120 |      * <p>
121 |      * Throws a RuntimeException if the location is invalid.
122 |      */
123 |     public static void checkLocation(int location, String label) {
124 |         if (location < 0) {
125 |             throw new RuntimeException("Unable to locate '" + label + "' in program");
126 |         }
127 |     }
128 | 
129 |     /**
130 |      * Creates a texture from raw data.
131 |      *
132 |      * @param data Image data, in a "direct" ByteBuffer.
133 |      * @param width Texture width, in pixels (not bytes).
134 |      * @param height Texture height, in pixels.
135 |      * @param format Image data format (use constant appropriate for glTexImage2D(), e.g. GL_RGBA).
136 |      * @return Handle to texture.
137 |      */
138 |     public static int createImageTexture(ByteBuffer data, int width, int height, int format) {
139 |         int[] textureHandles = new int[1];
140 |         int textureHandle;
141 | 
142 |         GLES20.glGenTextures(1, textureHandles, 0);
143 |         textureHandle = textureHandles[0];
144 |         GlUtil.checkGlError("glGenTextures");
145 | 
146 |         // Bind the texture handle to the 2D texture target.
147 |         GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureHandle);
148 | 
149 |         // Configure min/mag filtering, i.e. what scaling method do we use if what we're rendering
150 |         // is smaller or larger than the source image.
151 |         GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER,
152 |                 GLES20.GL_LINEAR);
153 |         GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER,
154 |                 GLES20.GL_LINEAR);
155 |         GlUtil.checkGlError("loadImageTexture");
156 | 
157 |         // Load the data from the buffer into the texture handle.
158 |         GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, /*level*/ 0, format,
159 |                 width, height, /*border*/ 0, format, GLES20.GL_UNSIGNED_BYTE, data);
160 |         GlUtil.checkGlError("loadImageTexture");
161 | 
162 |         return textureHandle;
163 |     }
164 | 
165 |     /**
166 |      * Allocates a direct float buffer, and populates it with the float array data.
167 |      */
168 |     public static FloatBuffer createFloatBuffer(float[] coords) {
169 |         // Allocate a direct ByteBuffer, using 4 bytes per float, and copy coords into it.
170 |         ByteBuffer bb = ByteBuffer.allocateDirect(coords.length * SIZEOF_FLOAT);
171 |         bb.order(ByteOrder.nativeOrder());
172 |         FloatBuffer fb = bb.asFloatBuffer();
173 |         fb.put(coords);
174 |         fb.position(0);
175 |         return fb;
176 |     }
177 | 
178 |     /**
179 |      * Writes GL version info to the log.
180 |      */
181 |     public static void logVersionInfo() {
182 |         Log.i(TAG, "vendor  : " + GLES20.glGetString(GLES20.GL_VENDOR));
183 |         Log.i(TAG, "renderer: " + GLES20.glGetString(GLES20.GL_RENDERER));
184 |         Log.i(TAG, "version : " + GLES20.glGetString(GLES20.GL_VERSION));
185 | 
186 |         if (false) {
187 |             int[] values = new int[1];
188 |             GLES30.glGetIntegerv(GLES30.GL_MAJOR_VERSION, values, 0);
189 |             int majorVersion = values[0];
190 |             GLES30.glGetIntegerv(GLES30.GL_MINOR_VERSION, values, 0);
191 |             int minorVersion = values[0];
192 |             if (GLES30.glGetError() == GLES30.GL_NO_ERROR) {
193 |                 Log.i(TAG, "iversion: " + majorVersion + "." + minorVersion);
194 |             }
195 |         }
196 |     }
197 | }
198 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/coder/MediaEncoder.java:
--------------------------------------------------------------------------------
  1 | package com.ryan.screenrecoder.coder;
  2 | 
  3 | import android.graphics.Bitmap;
  4 | import android.hardware.display.DisplayManager;
  5 | import android.hardware.display.VirtualDisplay;
  6 | import android.media.MediaCodec;
  7 | import android.media.MediaCodecInfo;
  8 | import android.media.MediaFormat;
  9 | import android.media.MediaMuxer;
 10 | import android.media.projection.MediaProjection;
 11 | import android.os.Environment;
 12 | import android.os.Handler;
 13 | import android.os.Looper;
 14 | import android.os.Message;
 15 | import android.util.Log;
 16 | import android.view.Surface;
 17 | 
 18 | import com.ryan.screenrecoder.application.SysValue;
 19 | import com.ryan.screenrecoder.bean.EventLogBean;
 20 | import com.ryan.screenrecoder.glec.EGLRender;
 21 | 
 22 | import org.greenrobot.eventbus.EventBus;
 23 | 
 24 | import java.io.IOException;
 25 | import java.nio.ByteBuffer;
 26 | 
 27 | /**
 28 |  * Created by ryan on 2017/2/23 0023.
 29 |  */
 30 | 
 31 | public class MediaEncoder extends Thread {
 32 | 
 33 | 
 34 |     private final String TAG = "MediaEncoder";
 35 | 
 36 |     private final String mime_type = MediaFormat.MIMETYPE_VIDEO_AVC;
 37 | 
 38 | 
 39 |     private DisplayManager displayManager;
 40 |     private MediaProjection projection;
 41 |     private MediaCodec mEncoder;
 42 |     private VirtualDisplay virtualDisplay;
 43 |     private MediaCodec.BufferInfo mBufferInfo = new MediaCodec.BufferInfo();
 44 |     private EGLRender eglRender;
 45 |     private Surface surface;
 46 | 
 47 | 
 48 |     //屏幕相关
 49 |     private int screen_width;
 50 |     private int screen_height;
 51 |     private int screen_dpi;
 52 | 
 53 | 
 54 |     //编码参数相关
 55 |     private int frame_bit = 2000000;//2MB
 56 |     private int frame_rate = 20;//这里指的是Mediacodec30张图为1组 ，并不是视屏本身的FPS
 57 |     private int frame_internal = 1;//关键帧间隔 一组加一个关键帧
 58 |     private final int TIMEOUT_US = 10000;
 59 |     private int video_fps = 30;
 60 |     private byte[] sps=null;
 61 |     private byte[] pps=null;
 62 | 
 63 | 
 64 |     private OnScreenCallBack onScreenCallBack;
 65 | 
 66 |     public void setOnScreenCallBack(OnScreenCallBack onScreenCallBack) {
 67 |         this.onScreenCallBack = onScreenCallBack;
 68 |     }
 69 | 
 70 |     public interface OnScreenCallBack {
 71 |         void onScreenInfo(byte[] bytes);
 72 |         void onCutScreen(Bitmap bitmap);
 73 |     }
 74 | 
 75 |     public MediaEncoder(MediaProjection projection, int screen_width, int screen_height, int screen_dpi) {
 76 |         this.projection = projection;
 77 |         initScreenInfo(screen_width, screen_height, screen_dpi);
 78 |     }
 79 | 
 80 |     public MediaEncoder(DisplayManager displayManager, int screen_width, int screen_height, int screen_dpi) {
 81 |         this.displayManager = displayManager;
 82 |         initScreenInfo(screen_width, screen_height, screen_dpi);
 83 |     }
 84 | 
 85 |     private void initScreenInfo(int screen_width, int screen_height, int screen_dpi) {
 86 |         this.screen_width = screen_width;
 87 |         this.screen_height = screen_height;
 88 |         this.screen_dpi = screen_dpi;
 89 |     }
 90 | 
 91 |     /**
 92 |      * 设置视频FPS
 93 |      *
 94 |      * @param fps
 95 |      */
 96 |     public MediaEncoder setVideoFPS(int fps) {
 97 |         video_fps = fps;
 98 |         return this;
 99 |     }
100 | 
101 |     /**
102 |      * 设置视屏编码采样率
103 |      *
104 |      * @param bit
105 |      */
106 |     public MediaEncoder setVideoBit(int bit) {
107 |         frame_bit = bit;
108 |         return this;
109 |     }
110 | 
111 |     @Override
112 |     public void run() {
113 |         super.run();
114 |         try {
115 |             prepareEncoder();
116 |         } catch (IOException e) {
117 |             e.printStackTrace();
118 |         }
119 |         if (projection != null) {
120 |             virtualDisplay = projection.createVirtualDisplay("screen", screen_width, screen_height, screen_dpi,
121 |                     DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC, eglRender.getDecodeSurface(), null, null);
122 |         } else {
123 |             virtualDisplay = displayManager.createVirtualDisplay("screen", screen_width, screen_height, screen_dpi,
124 |                     eglRender.getDecodeSurface(), DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC);
125 |         }
126 |         startRecordScreen();
127 |         release();
128 |     }
129 | 
130 | 
131 |     /**
132 |      * 初始化编码器
133 |      */
134 |     private void prepareEncoder() throws IOException {
135 |         MediaFormat mediaFormat = MediaFormat.createVideoFormat(mime_type, screen_width, screen_height);
136 |         mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
137 |         mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, frame_bit);
138 |         mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, frame_rate);
139 |         mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, frame_internal);
140 |         mEncoder = MediaCodec.createEncoderByType(mime_type);
141 |         mEncoder.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
142 |         surface = mEncoder.createInputSurface();
143 |         eglRender = new EGLRender(surface, screen_width, screen_height, video_fps);
144 |         eglRender.setCallBack(new EGLRender.onFrameCallBack() {
145 |             @Override
146 |             public void onUpdate() {
147 |                 startEncode();
148 |             }
149 | 
150 |             @Override
151 |             public void onCutScreen(Bitmap bitmap) {
152 |                 onScreenCallBack.onCutScreen(bitmap);
153 |             }
154 |         });
155 |         mEncoder.start();
156 |     }
157 |     /**
158 |      * 开始录屏
159 |      */
160 |     private void startRecordScreen() {
161 |         eglRender.start();
162 |         release();
163 |     }
164 | 
165 |     private void startEncode() {
166 |         ByteBuffer[] byteBuffers = null;
167 |         if (SysValue.api < 21) {
168 |             byteBuffers = mEncoder.getOutputBuffers();
169 |         }
170 |         int index = mEncoder.dequeueOutputBuffer(mBufferInfo, TIMEOUT_US);
171 |         if (index == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
172 |             resetOutputFormat();
173 |         } else if (index == MediaCodec.INFO_TRY_AGAIN_LATER) {
174 | //            Log.d("---", "retrieving buffers time out!");
175 | //            try {
176 | //                // wait 10ms
177 | //                Thread.sleep(10);
178 | //            } catch (InterruptedException e) {
179 | //            }
180 |         } else if (index >= 0) {
181 |             if (SysValue.api < 21) {
182 |                 encodeToVideoTrack(byteBuffers[index]);
183 |             } else {
184 |                 encodeToVideoTrack(mEncoder.getOutputBuffer(index));
185 |             }
186 |             mEncoder.releaseOutputBuffer(index, false);
187 |         }
188 |     }
189 | 
190 |     private void encodeToVideoTrack(ByteBuffer encodeData) {
191 | 
192 | //        ByteBuffer encodeData = mEncoder.getOutputBuffer(index);
193 |         if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
194 |             Log.d(TAG, "ignoring BUFFER_FLAG_CODEC_CONFIG");
195 |             mBufferInfo.size = 0;
196 |         }
197 |         if (mBufferInfo.size == 0) {
198 |             Log.d(TAG, "info.size == 0, drop it.");
199 |             encodeData = null;
200 |         } else {
201 |             Log.d(TAG, "got buffer, info: size=" + mBufferInfo.size
202 |                     + ", presentationTimeUs=" + mBufferInfo.presentationTimeUs
203 |                     + ", offset=" + mBufferInfo.offset);
204 |         }
205 |         if (encodeData != null) {
206 |             encodeData.position(mBufferInfo.offset);
207 |             encodeData.limit(mBufferInfo.offset + mBufferInfo.size);
208 | //            muxer.writeSampleData(mVideoTrackIndex, encodeData, mBufferInfo);//写入文件
209 |             byte[] bytes;
210 |             if (mBufferInfo.flags == MediaCodec.BUFFER_FLAG_KEY_FRAME) {
211 |                 //todo 关键帧上添加sps,和pps信息
212 |                 bytes = new byte[mBufferInfo.size + sps.length + pps.length];
213 |                 System.arraycopy(sps, 0, bytes, 0, sps.length);
214 |                 System.arraycopy(pps, 0, bytes, sps.length, pps.length);
215 |                 encodeData.get(bytes, sps.length + pps.length, mBufferInfo.size);
216 |             } else {
217 |                 bytes = new byte[mBufferInfo.size];
218 |                 encodeData.get(bytes, 0, mBufferInfo.size);
219 |             }
220 |             onScreenCallBack.onScreenInfo(bytes);
221 |             EventBus.getDefault().post(new EventLogBean("send:" + mBufferInfo.size +"\tflag:" + mBufferInfo.flags));
222 |             Log.e("---", "send:" + mBufferInfo.size +"\tflag:" + mBufferInfo.flags);
223 |         }
224 |     }
225 | 
226 |     private int mVideoTrackIndex;
227 | 
228 |     private void resetOutputFormat() {
229 |         MediaFormat newFormat = mEncoder.getOutputFormat();
230 |         Log.i(TAG, "output format changed.\n new format: " + newFormat.toString());
231 |         getSpsPpsByteBuffer(newFormat);
232 |         Log.i(TAG, "started media muxer, videoIndex=" + mVideoTrackIndex);
233 |     }
234 | 
235 | 
236 |     /**
237 |      * 获取编码SPS和PPS信息
238 |      * @param newFormat
239 |      */
240 |     private void getSpsPpsByteBuffer(MediaFormat newFormat) {
241 |         sps = newFormat.getByteBuffer("csd-0").array();
242 |         pps = newFormat.getByteBuffer("csd-1").array();
243 |         EventBus.getDefault().post(new EventLogBean("编码器初始化完成"));
244 |     }
245 | 
246 |     public void stopScreen() {
247 |         if (eglRender != null) {
248 |             eglRender.stop();
249 |         }
250 |     }
251 | 
252 |     public void release() {
253 |         if (mEncoder != null) {
254 |             mEncoder.stop();
255 |             mEncoder.release();
256 |             mEncoder = null;
257 |         }
258 |         if (virtualDisplay != null) {
259 |             virtualDisplay.release();
260 |         }
261 |     }
262 |     public void cutScreen(){
263 |         eglRender.cutScreen();
264 |     }
265 | }
266 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/ryan/screenrecoder/glec/EGLRender.java:
--------------------------------------------------------------------------------
  1 | package com.ryan.screenrecoder.glec;
  2 | 
  3 | import android.content.Context;
  4 | import android.graphics.Bitmap;
  5 | import android.graphics.SurfaceTexture;
  6 | import android.opengl.EGL14;
  7 | import android.opengl.EGLConfig;
  8 | import android.opengl.EGLContext;
  9 | import android.opengl.EGLDisplay;
 10 | import android.opengl.EGLExt;
 11 | import android.opengl.EGLSurface;
 12 | import android.opengl.GLES20;
 13 | import android.opengl.Matrix;
 14 | import android.os.Handler;
 15 | import android.os.Looper;
 16 | import android.os.Message;
 17 | import android.util.Log;
 18 | import android.view.Surface;
 19 | 
 20 | import java.nio.ByteBuffer;
 21 | import java.nio.IntBuffer;
 22 | import java.util.concurrent.ExecutorService;
 23 | import java.util.concurrent.Executors;
 24 | 
 25 | 
 26 | /**
 27 |  * Created by zx315476228 on 17-3-3.
 28 |  */
 29 | 
 30 | public class EGLRender implements SurfaceTexture.OnFrameAvailableListener {
 31 |     private final int HANDLER_PHOTO_CALLBACK = 0;
 32 |     private static final String TAG = "EncodeDecodeSurface";
 33 |     private static final boolean VERBOSE = false;           // lots of logging
 34 | 
 35 |     private STextureRender mTextureRender;
 36 |     private SurfaceTexture mSurfaceTexture;
 37 | 
 38 |     private EGLDisplay mEGLDisplay = EGL14.EGL_NO_DISPLAY;
 39 |     private EGLContext mEGLContext = EGL14.EGL_NO_CONTEXT;
 40 |     private EGLContext mEGLContextEncoder = EGL14.EGL_NO_CONTEXT;
 41 |     private EGLSurface mEGLSurface = EGL14.EGL_NO_SURFACE;
 42 |     private EGLSurface mEGLSurfaceEncoder = EGL14.EGL_NO_SURFACE;
 43 | 
 44 |     private Surface decodeSurface;
 45 | 
 46 |     private int mWidth;
 47 |     private int mHeight;
 48 |     private int fps;
 49 |     private int video_interval;
 50 |     private boolean mFrameAvailable = true;
 51 |     private onFrameCallBack callBack;
 52 |     private boolean hasCutScreen = false;
 53 | 
 54 |     private boolean start;
 55 |     private long time = 0;
 56 |     private long current_time;
 57 | 
 58 |     private Handler handler = new Handler(Looper.getMainLooper()) {
 59 |         @Override
 60 |         public void handleMessage(Message msg) {
 61 |             super.handleMessage(msg);
 62 |             switch (msg.what) {
 63 |                 case HANDLER_PHOTO_CALLBACK:
 64 |                     if (callBack != null && msg.obj != null)
 65 |                         callBack.onCutScreen((Bitmap) msg.obj);
 66 |                     break;
 67 |             }
 68 |         }
 69 |     };
 70 |     private ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
 71 | 
 72 |     private class CutScreeenThread implements Runnable {
 73 |         private int[] modelData;
 74 | 
 75 |         public CutScreeenThread(int[] modelData) {
 76 |             this.modelData = modelData;
 77 |         }
 78 | 
 79 |         @Override
 80 |         public void run() {
 81 | 
 82 |             int[] ArData = new int[modelData.length];
 83 |             int offset1, offset2;
 84 |             for (int i = 0; i < mHeight; i++) {
 85 |                 offset1 = i * mWidth;
 86 |                 offset2 = (mHeight - i - 1) * mWidth;
 87 |                 for (int j = 0; j < mWidth; j++) {
 88 |                     int texturePixel = modelData[offset1 + j];
 89 |                     int blue = (texturePixel >> 16) & 0xff;
 90 |                     int red = (texturePixel << 16) & 0x00ff0000;
 91 |                     int pixel = (texturePixel & 0xff00ff00) | red | blue;
 92 |                     ArData[offset2 + j] = pixel;
 93 |                 }
 94 |             }
 95 |             Bitmap bitmap = Bitmap.createBitmap(ArData, mWidth, mHeight, Bitmap.Config.ARGB_8888);
 96 |             modelData = null;
 97 |             ArData = null;
 98 | 
 99 |             handler.obtainMessage(HANDLER_PHOTO_CALLBACK, bitmap).sendToTarget();
100 |         }
101 |     }
102 |     public void setCallBack(onFrameCallBack callBack) {
103 |         this.callBack = callBack;
104 |     }
105 | 
106 |     public interface onFrameCallBack {
107 |         void onUpdate();
108 |         void onCutScreen(Bitmap bitmap);
109 |     }
110 | 
111 | 
112 |     public EGLRender(Surface surface, int mWidth, int mHeight, int fps) {
113 |         this.mWidth = mWidth;
114 |         this.mHeight = mHeight;
115 |         initFPs(fps);
116 |         eglSetup(surface);
117 |         makeCurrent();
118 |         setup();
119 |     }
120 | 
121 |     private void initFPs(int fps) {
122 |         this.fps = fps;
123 |         video_interval = 1000 / fps;
124 |     }
125 | 
126 |     /**
127 |      * Prepares EGL.  We want a GLES 2.0 context and a surface that supports pbuffer.
128 |      */
129 |     private void eglSetup(Surface surface) {
130 |         mEGLDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
131 |         if (mEGLDisplay == EGL14.EGL_NO_DISPLAY) {
132 |             throw new RuntimeException("unable to get EGL14 display");
133 |         }
134 |         int[] version = new int[2];
135 |         if (!EGL14.eglInitialize(mEGLDisplay, version, 0, version, 1)) {
136 |             mEGLDisplay = null;
137 |             throw new RuntimeException("unable to initialize EGL14");
138 |         }
139 | 
140 |         // Configure EGL for pbuffer and OpenGL ES 2.0, 24-bit RGB.
141 |         int[] attribList = {
142 |                 EGL14.EGL_RED_SIZE, 8,
143 |                 EGL14.EGL_GREEN_SIZE, 8,
144 |                 EGL14.EGL_BLUE_SIZE, 8,
145 |                 EGL14.EGL_ALPHA_SIZE, 8,
146 |                 EGL14.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,
147 |                 EGL14.EGL_SURFACE_TYPE, EGL14.EGL_PBUFFER_BIT,
148 |                 EGL14.EGL_NONE
149 |         };
150 |         EGLConfig[] configs = new EGLConfig[1];
151 |         int[] numConfigs = new int[1];
152 |         if (!EGL14.eglChooseConfig(mEGLDisplay, attribList, 0, configs, 0, configs.length,
153 |                 numConfigs, 0)) {
154 |             throw new RuntimeException("unable to find RGB888+recordable ES2 EGL config");
155 |         }
156 | 
157 |         EGLConfig configEncoder = getConfig(2);
158 | 
159 |         // Configure context for OpenGL ES 2.0.
160 |         int[] attrib_list = {
161 |                 EGL14.EGL_CONTEXT_CLIENT_VERSION, 2,
162 |                 EGL14.EGL_NONE
163 |         };
164 |         mEGLContext = EGL14.eglCreateContext(mEGLDisplay, configs[0], EGL14.EGL_NO_CONTEXT,
165 |                 attrib_list, 0);
166 |         checkEglError("eglCreateContext");
167 |         if (mEGLContext == null) {
168 |             throw new RuntimeException("null context");
169 |         }
170 | 
171 |         mEGLContextEncoder = EGL14.eglCreateContext(mEGLDisplay, configEncoder, mEGLContext,
172 |                 attrib_list, 0);
173 |         checkEglError("eglCreateContext");
174 |         if (mEGLContextEncoder == null) {
175 |             throw new RuntimeException("null context2");
176 |         }
177 | 
178 |         // Create a pbuffer surface.
179 |         int[] surfaceAttribs = {
180 |                 EGL14.EGL_WIDTH, mWidth,
181 |                 EGL14.EGL_HEIGHT, mHeight,
182 |                 EGL14.EGL_NONE
183 |         };
184 |         mEGLSurface = EGL14.eglCreatePbufferSurface(mEGLDisplay, configs[0], surfaceAttribs, 0);
185 | 
186 | 
187 |         checkEglError("eglCreatePbufferSurface");
188 |         if (mEGLSurface == null) {
189 |             throw new RuntimeException("surface was null");
190 |         }
191 | 
192 | 
193 |         int[] surfaceAttribs2 = {
194 |                 EGL14.EGL_NONE
195 |         };
196 |         mEGLSurfaceEncoder = EGL14.eglCreateWindowSurface(mEGLDisplay, configEncoder, surface,
197 |                 surfaceAttribs2, 0);   //creates an EGL window surface and returns its handle
198 |         checkEglError("eglCreateWindowSurface");
199 |         if (mEGLSurfaceEncoder == null) {
200 |             throw new RuntimeException("surface was null");
201 |         }
202 |     }
203 | 
204 |     /**
205 |      * Makes our EGL context and surface current.
206 |      */
207 |     public void makeCurrent() {
208 |         if (!EGL14.eglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext)) {
209 |             throw new RuntimeException("eglMakeCurrent failed");
210 |         }
211 |     }
212 | 
213 |     /**
214 |      * Creates interconnected instances of TextureRender, SurfaceTexture, and Surface.
215 |      */
216 |     private void setup() {
217 |         mTextureRender = new STextureRender(mWidth, mHeight);
218 |         mTextureRender.surfaceCreated();
219 | 
220 |         if (VERBOSE) Log.d(TAG, "textureID=" + mTextureRender.getTextureId());
221 |         mSurfaceTexture = new SurfaceTexture(mTextureRender.getTextureId());
222 |         mSurfaceTexture.setDefaultBufferSize(mWidth, mHeight);
223 |         mSurfaceTexture.setOnFrameAvailableListener(this);
224 |         decodeSurface = new Surface(mSurfaceTexture);
225 |     }
226 | 
227 |     public Surface getDecodeSurface() {
228 |         return decodeSurface;
229 |     }
230 | 
231 |     private EGLConfig getConfig(int version) {
232 |         int renderableType = EGL14.EGL_OPENGL_ES2_BIT;
233 |         if (version >= 3) {
234 |             renderableType |= EGLExt.EGL_OPENGL_ES3_BIT_KHR;
235 |         }
236 | 
237 |         // The actual surface is generally RGBA or RGBX, so situationally omitting alpha
238 |         // doesn't really help.  It can also lead to a huge performance hit on glReadPixels()
239 |         // when reading into a GL_RGBA buffer.
240 |         int[] attribList = {
241 |                 EGL14.EGL_RED_SIZE, 8,
242 |                 EGL14.EGL_GREEN_SIZE, 8,
243 |                 EGL14.EGL_BLUE_SIZE, 8,
244 |                 EGL14.EGL_ALPHA_SIZE, 8,
245 |                 EGL14.EGL_RENDERABLE_TYPE, renderableType,
246 |                 EGL14.EGL_NONE, 0,      // placeholder for recordable [@-3]
247 |                 EGL14.EGL_NONE
248 |         };
249 |         EGLConfig[] configs = new EGLConfig[1];
250 |         int[] numConfigs = new int[1];
251 |         if (!EGL14.eglChooseConfig(mEGLDisplay, attribList, 0, configs, 0, configs.length,
252 |                 numConfigs, 0)) {
253 |             Log.w(TAG, "unable to find RGB8888 / " + version + " EGLConfig");
254 |             return null;
255 |         }
256 |         return configs[0];
257 |     }
258 | 
259 |     private void checkEglError(String msg) {
260 |         int error;
261 |         if ((error = EGL14.eglGetError()) != EGL14.EGL_SUCCESS) {
262 |             throw new RuntimeException(msg + ": EGL error: 0x" + Integer.toHexString(error));
263 |         }
264 |     }
265 | 
266 |     public void makeCurrent(int index) {
267 | 
268 |         if (index == 0) {
269 |             if (!EGL14.eglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext)) {
270 |                 throw new RuntimeException("eglMakeCurrent failed");
271 |             }
272 |         } else {
273 |             if (!EGL14.eglMakeCurrent(mEGLDisplay, mEGLSurfaceEncoder, mEGLSurfaceEncoder, mEGLContextEncoder)) {
274 |                 throw new RuntimeException("eglMakeCurrent failed");
275 |             }
276 |         }
277 | 
278 |     }
279 | 
280 |     public void setPresentationTime(long nsecs) {
281 |         EGLExt.eglPresentationTimeANDROID(mEGLDisplay, mEGLSurfaceEncoder, nsecs);
282 |         checkEglError("eglPresentationTimeANDROID");
283 |     }
284 | 
285 |     public void awaitNewImage() {
286 |         if (mFrameAvailable) {
287 |             mFrameAvailable = false;
288 |             mSurfaceTexture.updateTexImage();
289 |         }
290 |     }
291 | 
292 |     public boolean swapBuffers() {
293 |         boolean result = EGL14.eglSwapBuffers(mEGLDisplay, mEGLSurfaceEncoder);
294 |         checkEglError("eglSwapBuffers");
295 |         return result;
296 |     }
297 | 
298 |     private int count = 1;
299 | 
300 |     @Override
301 |     public void onFrameAvailable(SurfaceTexture surfaceTexture) {
302 |         mFrameAvailable = true;
303 |     }
304 | 
305 |     private long computePresentationTimeNsec(int frameIndex) {
306 |         final long ONE_BILLION = 1000000000;
307 |         return frameIndex * ONE_BILLION / fps;
308 |     }
309 | 
310 |     public void drawImage() {
311 |         mTextureRender.drawFrame();
312 |     }
313 | 
314 |     /**
315 |      * 开始录屏
316 |      */
317 |     public void start() {
318 |         start = true;
319 |         while (start) {
320 |             makeCurrent(1);
321 |             awaitNewImage();
322 |             current_time = System.currentTimeMillis();
323 |             if (current_time - time >= video_interval) {
324 |                 //todo 帧率控制
325 |                 drawImage();
326 |                 callBack.onUpdate();
327 |                 setPresentationTime(computePresentationTimeNsec(count++));
328 |                 swapBuffers();
329 |                 if (hasCutScreen) {
330 |                     getScreen();
331 |                     hasCutScreen = false;
332 |                 }
333 |                 time = current_time;
334 |             }
335 |         }
336 |     }
337 | 
338 | 
339 |     /**
340 |      * 获取当前屏幕信息
341 |      */
342 |     private void getScreen() {
343 |         IntBuffer buffer = IntBuffer.allocate(mWidth * mHeight);
344 |         buffer.position(0);
345 |         GLES20.glReadPixels(0, 0, mWidth, mHeight, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, buffer);
346 |         int[] modelData = buffer.array();
347 |         buffer.clear();
348 |         singleThreadExecutor.execute(new CutScreeenThread(modelData));
349 |     }
350 |     public void cutScreen(){
351 |         hasCutScreen=true;
352 |     }
353 |     public void stop() {
354 |         start = false;
355 |     }
356 | }
357 | 


--------------------------------------------------------------------------------