6.9 CAEAGLLayer

当iOS要处理高性能图形绘制，必要时就是OpenGL。应该说它应该是最后的杀手锏，至少对于非游戏的应用来说是的。因为相比Core Animation和UIkit框架，它不可思议地复杂。

OpenGL提供了Core Animation的基础，它是底层的C接口，直接和iPhone，iPad的硬件通信，极少地抽象出来的方法。OpenGL没有对象或是图层的继承概念。它只是简单地处理三角形。OpenGL中所有东西都是3D空间中有颜色和纹理的三角形。用起来非常复杂和强大，但是用OpenGL绘制iOS用户界面就需要很多很多的工作了。

为了能够以高性能使用Core Animation，你需要判断你需要绘制哪种内容（矢量图形，例子，文本，等等），但后选择合适的图层去呈现这些内容，Core Animation中只有一些类型的内容是被高度优化的；所以如果你想绘制的东西并不能找到标准的图层类，想要得到高性能就比较费事情了。

因为OpenGL根本不会对你的内容进行假设，它能够绘制得相当快。利用OpenGL，你可以绘制任何你知道必要的集合信息和形状逻辑的内容。所以很多游戏都喜欢用OpenGL（这些情况下，Core Animation的限制就明显了：它优化过的内容类型并不一定能满足需求），但是这样依赖，方便的高度抽象接口就没了。

在iOS 5中，苹果引入了一个新的框架叫做GLKit，它去掉了一些设置OpenGL的复杂性，提供了一个叫做CLKView的UIView的子类，帮你处理大部分的设置和绘制工作。前提是各种各样的OpenGL绘图缓冲的底层可配置项仍然需要你用CAEAGLLayer完成，它是CALayer的一个子类，用来显示任意的OpenGL图形。

大部分情况下你都不需要手动设置CAEAGLLayer（假设用GLKView），过去的日子就不要再提了。特别的，我们将设置一个OpenGL ES 2.0的上下文，它是现代的iOS设备的标准做法。

尽管不需要GLKit也可以做到这一切，但是GLKit囊括了很多额外的工作，比如设置顶点和片段着色器，这些都以类C语言叫做GLSL自包含在程序中，同时在运行时载入到图形硬件中。编写GLSL代码和设置EAGLayer没有什么关系，所以我们将用GLKBaseEffect类将着色逻辑抽象出来。其他的事情，我们还是会有以往的方式。

在开始之前，你需要将GLKit和OpenGLES框架加入到你的项目中，然后就可以实现清单6.14中的代码，里面是设置一个GAEAGLLayer的最少工作，它使用了OpenGL ES 2.0 的绘图上下文，并渲染了一个有色三角（见图6.15）.

清单6.14 用CAEAGLLayer绘制一个三角形

#import "ViewController.h"

#import 

#import 



@interface ViewController ()



@property (nonatomic, weak) IBOutlet UIView *glView;

@property (nonatomic, strong) EAGLContext *glContext;

@property (nonatomic, strong) CAEAGLLayer *glLayer;

@property (nonatomic, assign) GLuint framebuffer;

@property (nonatomic, assign) GLuint colorRenderbuffer;

@property (nonatomic, assign) GLint framebufferWidth;

@property (nonatomic, assign) GLint framebufferHeight;

@property (nonatomic, strong) GLKBaseEffect *effect;



@end



@implementation ViewController



- (void)setUpBuffers

{

    //set up frame buffer

    glGenFramebuffers(1, &_framebuffer);

    glBindFramebuffer(GL_FRAMEBUFFER, _framebuffer);



    //set up color render buffer

    glGenRenderbuffers(1, &_colorRenderbuffer);

    glBindRenderbuffer(GL_RENDERBUFFER, _colorRenderbuffer);

    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, _colorRenderbuffer);

    [self.glContext renderbufferStorage:GL_RENDERBUFFER fromDrawable:self.glLayer];

    glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &_framebufferWidth);

    glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, &_framebufferHeight);



    //check success

    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {

        NSLog(@"Failed to make complete framebuffer object: %i", glCheckFramebufferStatus(GL_FRAMEBUFFER));

    }

}



- (void)tearDownBuffers

{

    if (_framebuffer) {

        //delete framebuffer

        glDeleteFramebuffers(1, &_framebuffer);

        _framebuffer = 0;

    }



    if (_colorRenderbuffer) {

        //delete color render buffer

        glDeleteRenderbuffers(1, &_colorRenderbuffer);

        _colorRenderbuffer = 0;

    }

}



- (void)drawFrame {

    //bind framebuffer & set viewport

    glBindFramebuffer(GL_FRAMEBUFFER, _framebuffer);

    glViewport(0, 0, _framebufferWidth, _framebufferHeight);



    //bind shader program

    [self.effect prepareToDraw];



    //clear the screen

    glClear(GL_COLOR_BUFFER_BIT); glClearColor(0.0, 0.0, 0.0, 1.0);



    //set up vertices

    GLfloat vertices[] = {

        -0.5f, -0.5f, -1.0f, 0.0f, 0.5f, -1.0f, 0.5f, -0.5f, -1.0f,

    };



    //set up colors

    GLfloat colors[] = {

        0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f,

    };



    //draw triangle

    glEnableVertexAttribArray(GLKVertexAttribPosition);

    glEnableVertexAttribArray(GLKVertexAttribColor);

    glVertexAttribPointer(GLKVertexAttribPosition, 3, GL_FLOAT, GL_FALSE, 0, vertices);

    glVertexAttribPointer(GLKVertexAttribColor,4, GL_FLOAT, GL_FALSE, 0, colors);

    glDrawArrays(GL_TRIANGLES, 0, 3);



    //present render buffer

    glBindRenderbuffer(GL_RENDERBUFFER, _colorRenderbuffer);

    [self.glContext presentRenderbuffer:GL_RENDERBUFFER];

}



- (void)viewDidLoad

{

    [super viewDidLoad];

    //set up context

    self.glContext = [[EAGLContext alloc] initWithAPI: kEAGLRenderingAPIOpenGLES2];

    [EAGLContext setCurrentContext:self.glContext];



    //set up layer

    self.glLayer = [CAEAGLLayer layer];

    self.glLayer.frame = self.glView.bounds;

    [self.glView.layer addSublayer:self.glLayer];

    self.glLayer.drawableProperties = @{kEAGLDrawablePropertyRetainedBacking:@NO, kEAGLDrawablePropertyColorFormat: kEAGLColorFormatRGBA8};



    //set up base effect

    self.effect = [[GLKBaseEffect alloc] init];



    //set up buffers

    [self setUpBuffers];



    //draw frame

    [self drawFrame];

}



- (void)viewDidUnload

{

    [self tearDownBuffers];

    [super viewDidUnload];

}



- (void)dealloc

{

    [self tearDownBuffers];

    [EAGLContext setCurrentContext:nil];

}

@end

图6.15 用OpenGL渲染的CAEAGLLayer图层

在一个真正的OpenGL应用中，我们可能会用NSTimer或CADisplayLink周期性地每秒钟调用-drawRrame方法60次，同时会将几何图形生成和绘制分开以便不会每次都重新生成三角形的顶点（这样也可以让我们绘制其他的一些东西而不是一个三角形而已），不过上面这个例子已经足够演示了绘图原则了。

引言

上一个阶段我们开始进入插件/热修的领域，了解了热修的前世今生，下面我们来学习下热修中的ClassLoader方案设计；

ClassLoader主要是用来加载插件用的，在启动插件前首先要把插件加载进来，下面我们通过不同方案分析，了解加载的不同姿势～

方案1:合并Dex（hook方式）

谁用了这个方案？

QQ团队的空间换肤功能

原理

将我们插件dex和宿主apk的class.dex合并，都放到宿主dexElements数组中。App每次启动从该数组中加载。

实战流程

1）获取宿主，dexElements

2）获取插件，dexElements

3）合并两个dexElements

4）将新的dexElements 赋值到 宿主dexElements

代码

Class<?> clazz = Class.forName("dalvik.system.BaseDexClassLoader");

Field pathListField = clazz.getDeclaredField("pathList");

pathListField.setAccessible(true);



Class<?> dexPathListClass = Class.forName("dalvik.system.DexPathList");

Field dexElementsField = dexPathListClass.getDeclaredField("dexElements");

dexElementsField.setAccessible(true);

        

 // 宿主的 类加载器

ClassLoader pathClassLoader = context.getClassLoader();

// DexPathList类的对象

Object hostPathList = pathListField.get(pathClassLoader);

// 宿主的 dexElements

Object[] hostDexElements = (Object[]) dexElementsField.get(hostPathList);



// 插件的 类加载器

ClassLoader dexClassLoader = new DexClassLoader(apkPath, context.getCacheDir().getAbsolutePath(),null, pathClassLoader);

// DexPathList类的对象

Object pluginPathList = pathListField.get(dexClassLoader);

// 插件的 dexElements

Object[] pluginDexElements = (Object[]) dexElementsField.get(pluginPathList);



// 宿主dexElements = 宿主dexElements + 插件dexElements

// 创建一个新数组

Object[] newDexElements = (Object[]) Array.newInstance(hostDexElements.getClass().getComponentType(),hostDexElements.length + pluginDexElements.length);

// 拷贝

System.arraycopy(hostDexElements, 0, newDexElements,0, hostDexElements.length);

System.arraycopy(pluginDexElements, 0,newDexElements,hostDexElements.length, pluginDexElements.length);



// 赋值

dexElementsField.set(hostPathList, newDexElements);

特点

此乃单ClassLoader方案，插件和宿主程序的类全部都通过宿主的ClasLoader加载，存在的短板为“插件之间或者插件与宿主之间使用的类库有相同的时候，那么就会加载乱序等问题”

方案2:替换 PathClassloader 的 parent

谁用了这个方案？

微店、Instant-Run

知识基础

安装在手机里的apk（宿主）的ClassLoader链路关系

1）代码：

ClassLoader classLoader = getClassLoader();

ClassLoader parentClassLoader = classLoader.getParent();

ClassLoader pParentClassLoader = parentClassLoader.getParent();

2）关系：

==classLoader==：dalvik.system.PathClassLoader

==parentClassLoader==：java.lang.BootClassLoader

==pParentClassLoader==：null

可以看出，当前的classLoader是PathClassLoader，parent的ClassLoader是BootClassLoader，而BootClassLoader没有parent的ClassLoader

实现思想

如何利用上面的宿主链路基础原理设计？

ClassLoader的构造方法中有一个参数是parent； 如果把PathClassLoader的parent替换成我们==插件的classLoader==； 再把==插件的classLoader的parent==设置成BootClassLoader； 加上父委托的机制，查找插件类的过程就变成：BootClassLoader->==插件的classLoader==->PathClassLoader

代码实现

public static void loadApk(Context context, String apkPath) {

    File dexFile = context.getDir("dex", Context.MODE_PRIVATE);

    File apkFile = new File(apkPath);

    //找到 PathClassLoader

    ClassLoader classLoader = context.getClassLoader();

    //构建插件的 ClassLoader

    //PathClassLoader 的父亲 传递给 插件的ClassLoader

    //到这里，顺序为：BootClassLoader->插件的classLoader

    DexClassLoader dexClassLoader = new DexClassLoader(apkFile.getAbsolutePath(),dexFile.getAbsolutePath(), null,classLoader.getParent());

    try {

        //PathClassLoader 的父亲设置为 插件的ClassLoader

        //顺序为：BootClassLoader->插件的classLoader->PathClassLoader

        Field fieldClassLoader = ClassLoader.class.getDeclaredField("parent");

        if (fieldClassLoader != null) {

            fieldClassLoader.setAccessible(true);

            fieldClassLoader.set(classLoader, dexClassLoader);

        }

    } catch (Exception e) {

        e.printStackTrace();

    }

}

特点

此乃单ClassLoader方案，插件和宿主程序的类全部都通过宿主的ClasLoader加载，存在的短板为“插件之间或者插件与宿主之间使用的类库有相同的时候，那么就会加载乱序等问题”

方案3:利用LoadedApk的缓存机制

谁用了这个方案？

360的DroidPlugin

实现原理

java.lang.ClassLoader cl = r.packageInfo.getClassLoader();

activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);

StrictMode.incrementExpectedActivityCount(activity.getClass());

r.intent.setExtrasClassLoader(cl);

上面代码做了两件事：

1）系统用packageInfo.getClassLoader()来加载已安装app的Activity

2）实例化的Activity

其中packageInfo为LoadedApk类型，是APK文件在内存中的表示，Apk文件的相关信息，诸如Apk文件的代码和资源，甚至代码里面的Activity，Service等组件的信息我们都可以通过此对象获取。

packageInfo怎么生成的？通过阅读源码得出：

1）先在ActivityThread中的mPackages缓存（Map，key为包名，value为LoadedApk）中获取

2）如果缓存没有，new LoadedApk 生成一个，然后放到缓存mPackages中

基于上面系统的原理，实现的关键点步骤：

1）构建插件 ApplicationInfo 信息

ApplicationInfo applicationInfo = (ApplicationInfo) generateApplicationInfoMethod.invoke(packageParser,packageObj, 0, defaultPackageUserState);

String apkPath = apkFile.getPath();

applicationInfo.sourceDir = apkPath;

applicationInfo.publicSourceDir = apkPath;

2）构建 CompatibilityInfo

Class<?> compatibilityInfoClass = Class.forName("android.content.res.CompatibilityInfo");

Field defaultCompatibilityInfoField = compatibilityInfoClass.getDeclaredField("DEFAULT_COMPATIBILITY_INFO");

defaultCompatibilityInfoField.setAccessible(true);

Object defaultCompatibilityInfo = defaultCompatibilityInfoField.get(null);

3）根据 ApplicationInfo 和 CompatibilityInfo，构建插件的 loadedApk

Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");

Method getPackageInfoNoCheckMethod = activityThreadClass.getDeclaredMethod("getPackageInfoNoCheck", ApplicationInfo.class, compatibilityInfoClass);

Object loadedApk = getPackageInfoNoCheckMethod.invoke(currentActivityThread, applicationInfo, defaultCompatibilityInfo);

4）构建插件的ClassLoader，然后把它替换到插件loadedApk的ClassLoader中

String odexPath = Utils.getPluginOptDexDir(applicationInfo.packageName).getPath();

String libDir = Utils.getPluginLibDir(applicationInfo.packageName).getPath();

ClassLoader classLoader = new DexClassLoader(apkFile.getPath(), odexPath, libDir, ClassLoader.getSystemClassLoader());

Field mClassLoaderField = loadedApk.getClass().getDeclaredField("mClassLoader");

mClassLoaderField.setAccessible(true);

mClassLoaderField.set(loadedApk, classLoader);

5）把插件loadedApk添加进ActivityThread的mPackages中

// 先获取到当前的ActivityThread对象

Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");

Method currentActivityThreadMethod = activityThreadClass.getDeclaredMethod("currentActivityThread");

currentActivityThreadMethod.setAccessible(true);

Object currentActivityThread = currentActivityThreadMethod.invoke(null);

// 获取到 mPackages 这个静态成员变量, 这里缓存了dex包的信息

Field mPackagesField = activityThreadClass.getDeclaredField("mPackages");

mPackagesField.setAccessible(true);

Map mPackages = (Map) mPackagesField.get(currentActivityThread);



// 由于是弱引用, 因此我们必须在某个地方存一份, 不然容易被GC; 那么就前功尽弃了.

sLoadedApk.put(applicationInfo.packageName, loadedApk);

WeakReference weakReference = new WeakReference(loadedApk);

mPackages.put(applicationInfo.packageName, weakReference);

6）绕过系统检查，让系统觉得插件已经安装在系统上了

private static void hookPackageManager() throws Exception {

    // 这一步是因为 initializeJavaContextClassLoader 这个方法内部无意中检查了这个包是否在系统安装

    // 如果没有安装, 直接抛出异常, 这里需要临时Hook掉 PMS, 绕过这个检查.

    Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");

    Method currentActivityThreadMethod = activityThreadClass.getDeclaredMethod("currentActivityThread");

    currentActivityThreadMethod.setAccessible(true);

    Object currentActivityThread = currentActivityThreadMethod.invoke(null);



    // 获取ActivityThread里面原始的 sPackageManager

    Field sPackageManagerField = activityThreadClass.getDeclaredField("sPackageManager");

    sPackageManagerField.setAccessible(true);

    Object sPackageManager = sPackageManagerField.get(currentActivityThread);



    // 准备好代理对象, 用来替换原始的对象

    Class<?> iPackageManagerInterface = Class.forName("android.content.pm.IPackageManager");

    Object proxy = Proxy.newProxyInstance(iPackageManagerInterface.getClassLoader(),

            new Class<?>[] { iPackageManagerInterface },

            new IPackageManagerHookHandler(sPackageManager));



    // 1. 替换掉ActivityThread里面的 sPackageManager 字段

    sPackageManagerField.set(currentActivityThread, proxy);

}

特点

1）自定义了插件的ClassLoader，并且绕开了Framework的检测

2）Hook的地方也有点多：不仅需要Hook AMS和H，还需要Hook ActivityThread的mPackages和PackageManager！

3）多ClassLoader构架，每一个插件都有一个自己的ClassLoader，隔离性好，如果不同的插件使用了同一个库的不同版本，它们相安无事

4）真正完成代码的热加载！

插件需要升级，直接重新创建一个自定的ClassLoader加载新的插件，然后替换掉原来的版本即可（Java中，不同ClassLoader加载的同一个类被认为是不同的类）

单ClassLoader的话实现非常麻烦，有可能需要重启进程。

方案4:自定义ClassLoader逻辑

谁用了？

腾讯视频等事业群中的Shadow热修框架

实现原理

1）先了解下宿主（已经安装App）的ClassLoader链路： BootClassLoader -> PathClassLoader

2）插件可以加载宿主的类实现：

构建插件的ClassLoader，名字为ApkClassLoader，其中父加载器传的是宿主的ClassLoader，代码片段为：

class ApkClassLoader extends DexClassLoader {



    static final String TAG = "daviAndroid";

    private ClassLoader mGrandParent;

    private final String[] mInterfacePackageNames;



    @Deprecated

    ApkClassLoader(InstalledApk installedApk,

                   ClassLoader parent,////parent  =  宿主ClassLoader

                   String[] mInterfacePackageNames,

                   int grandTimes) {



        super(installedApk.apkFilePath, installedApk.oDexPath, installedApk.libraryPath, parent);

在这个流程下，插件查找的流程变为： BootClassLoader -> PathClassLoader -> ApkClassLoader（其实就是双亲委托）

3）插件不需要加载宿主的类实现：

class ApkClassLoader extends DexClassLoader {



............

//1）系统里面找

Class<?> clazz = findLoadedClass(className);

 if (clazz == null) {

    //2）从自己的dexPath中查找

   clazz = findClass(className);

   if (clazz == null) {

     //3）从parent的parent找（BootClassLoader）ClassLoader中查找。

     clazz = mGrandParent.loadClass(className);

   }

} 



............

}

这个逻辑插件不需要加载宿主的类，所以加载逻辑中不会去加载宿主的类（也就是会经过PathClassLoader），这种情况下，即使插件和宿主用到了同一个类，那么插件加载的时候不会因为委托加载机制而去加载了宿主的，导致插件的加载错了；

代码实现

class ApkClassLoader extends DexClassLoader {

    private ClassLoader mGrandParent;

    private final String[] mInterfacePackageNames;



    ApkClassLoader(InstalledApk installedApk,

                   ClassLoader parent, String[] mInterfacePackageNames, int grandTimes) {

        super(installedApk.apkFilePath, installedApk.oDexPath, installedApk.libraryPath, parent);

        ClassLoader grand = parent;

        for (int i = 0; i < grandTimes; i++) {

            grand = grand.getParent();

        }

        mGrandParent = grand;

        this.mInterfacePackageNames = mInterfacePackageNames;

    }



    @Override

    protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {

        String packageName;

        int dot = className.lastIndexOf('.');

        if (dot != -1) {

            packageName = className.substring(0, dot);

        } else {

            packageName = "";

        }



        boolean isInterface = false;

        for (String interfacePackageName : mInterfacePackageNames) {

            if (packageName.equals(interfacePackageName)) {

                isInterface = true;

                break;

            }

        }



        if (isInterface) {

            return super.loadClass(className, resolve);

        } else {

            Class<?> clazz = findLoadedClass(className);



            if (clazz == null) {

                ClassNotFoundException suppressed = null;

                try {

                    clazz = findClass(className);

                } catch (ClassNotFoundException e) {

                    suppressed = e;

                }



                if (clazz == null) {

                    try {

                        clazz = mGrandParent.loadClass(className);

                    } catch (ClassNotFoundException e) {

                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {

                            e.addSuppressed(suppressed);

                        }

                        throw e;

                    }

                }

            }



            return clazz;

        }

    }



    /**

     * 从apk中读取接口的实现

     *

     * @param clazz     接口类

     * @param className 实现类的类名

     * @param <T>       接口类型

     * @return 所需接口

     * @throws Exception

     */

    <T> T getInterface(Class<T> clazz, String className) throws Exception {

        try {

            Class<?> interfaceImplementClass = loadClass(className);

            Object interfaceImplement = interfaceImplementClass.newInstance();

            return clazz.cast(interfaceImplement);

        } catch (ClassNotFoundException | InstantiationException

                | ClassCastException | IllegalAccessException e) {

            throw new Exception(e);

        }

    }



}

该代码实现不正常的双亲委派逻辑，既能和parent隔离类加载（和宿主），也能通过白名单复用一些宿主的类

特点

1）属于多ClassLoader方案

2）插件可以选择加载宿主的类和绕过宿主加载，选择性强

结尾

哈哈，该篇就写到这里（一起体系化学习，一起成长）

相对于一般布局方式的笛卡尔坐标系，MotionLayout还拓展了ConstraintLayout中的相对中心布局方式，我们暂且称之为「极坐标布局」方式。

极坐标布局方式在某些场景下，比笛卡尔坐标系的建立更加方便，特别是涉及到一些圆周运动和相对中心点运动的场景。

Rotational OnSwipe

在OnSwipe的基础上，极坐标方式拓展了运动的方向，给dragDirection增加了dragClockwise和dragAnticlockwise参数，用于设置OnSwipe的顺时针滑动和逆时针滑动，这两个属性，在设置rotationCenterId后才会生效。那么借助这个，就可以很方便的实现一些圆形路径的滑动效果和动画。

通过下面这个例子，我们来看下Rotational OnSwipe的使用方法。

首先，极坐标的布局还是借助ConstraintLayout，代码如下所示。

<?xml version="1.0" encoding="utf-8"?>

<androidx.constraintlayout.motion.widget.MotionLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    android:id="@+id/motionLayout"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:background="#cfc"

    app:layoutDescription="@xml/motion_01_dial_scene"

    app:motionDebug="SHOW_ALL">



    <TextView

        android:id="@+id/number1"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="1"

        android:textSize="24sp"

        app:layout_constraintCircle="@id/dial"

        app:layout_constraintCircleAngle="73"

        app:layout_constraintCircleRadius="112dp"

        app:layout_constraintTag="hop" />



   ......



    <TextView

        android:id="@+id/number0"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="0"

        android:textSize="24sp"

        app:layout_constraintCircle="@id/dial"

        app:layout_constraintCircleAngle="172"

        app:layout_constraintCircleRadius="112dp"

        app:layout_constraintTag="hop" />



    <ImageView

        android:id="@+id/dial"

        android:layout_width="300dp"

        android:layout_height="300dp"

        android:src="@drawable/dial"

        app:layout_constraintBottom_toBottomOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintHorizontal_bias="0.6"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintTag="center"

        app:layout_constraintTop_toTopOf="parent"

        app:layout_constraintVertical_bias="0.8" />



    <ImageView

        android:id="@+id/dialhook"

        android:layout_width="70dp"

        android:layout_height="70dp"

        android:src="@drawable/dial_hook"

        app:layout_constraintCircle="@id/dial"

        app:layout_constraintCircleAngle="122"

        app:layout_constraintCircleRadius="112dp"

        app:layout_constraintTag="hop" />



</androidx.constraintlayout.motion.widget.MotionLayout>

极坐标布局就是借助layout_constraintCircle、layout_constraintCircleAngle、layout_constraintCircleRadius来确定圆心、角度和半径，从而实现极坐标的布局，接下来，再通过OnSwipe来实现圆形滑动效果。

<?xml version="1.0" encoding="utf-8"?>

<MotionScene xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:motion="http://schemas.android.com/apk/res-auto"

    motion:defaultDuration="2000">



    <ConstraintSet android:id="@+id/start">

        <Constraint android:id="@+id/dial">

            <Transform android:rotation="0" />

        </Constraint>

    </ConstraintSet>



    <ConstraintSet android:id="@+id/end">

        <Constraint android:id="@+id/dial">

            <Transform android:rotation="300" />

        </Constraint>

    </ConstraintSet>



    <Transition

        motion:autoTransition="animateToStart"

        motion:constraintSetEnd="@+id/end"

        motion:constraintSetStart="@+id/start"

        motion:duration="1000"

        motion:motionInterpolator="easeIn">



        <OnSwipe

            motion:dragDirection="dragClockwise"

            motion:dragScale=".9"

            motion:maxAcceleration="10"

            motion:maxVelocity="50"

            motion:onTouchUp="autoCompleteToStart"

            motion:rotationCenterId="@id/dial" />

        <KeyFrameSet>



        </KeyFrameSet>

    </Transition>

</MotionScene>

核心就在OnSwipe中，设置rotationCenterId后，再设置滑动的方向为顺时针即可，展示如下所示。

Relative Animation

在MotionLayout中，它进一步加强了在动画中对极坐标运动的支持，特别是一些极坐标的相对运动动画，可以通过MotionLayout，以非常简单的方式表现出来。我们举个简单的例子，一个行星环绕的动画，如下所示。

我们可以发现，这个动画的轨迹是非常复杂的，太阳以自己为中心自传，地球绕着太阳旋转的同时还在自传，月球绕着地球旋转，卫星绕着地球旋转的同时，逐渐远离地球，靠近月球。

这样一个复杂的极坐标动画效果，虽然借助ConstraintLayout可以很方便的实现定位布局，但是运动时，却无法继续保持极坐标的依赖关系，所以，这里需要使用MotionLayout来维持运动时的极坐标约束关系。

首先，使用ConstraintLayout来完成起始布局的建立，代码如下所示。

<?xml version="1.0" encoding="utf-8"?>

<androidx.constraintlayout.motion.widget.MotionLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    android:id="@+id/motionLayout"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:background="#FF003b60"

    app:layoutDescription="@xml/motion_01_motion_scene"

    app:motionDebug="SHOW_ALL">



    <ImageView

        android:id="@+id/sun"

        android:layout_width="180dp"

        android:layout_height="180dp"

        android:src="@drawable/sun"

        app:layout_constraintBottom_toBottomOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintTop_toBottomOf="parent" />



    <TextView

        android:id="@+id/rocket"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="?"

        android:textSize="28sp"

        app:layout_constraintCircle="@id/earth"

        app:layout_constraintCircleAngle="0"

        app:layout_constraintCircleRadius="60dp" />



    <androidx.constraintlayout.utils.widget.ImageFilterView

        android:id="@+id/moon"

        android:layout_width="16dp"

        android:layout_height="16dp"

        android:rotation="-240"

        android:src="@drawable/moon"

        app:layout_constraintCircle="@id/earth"

        app:layout_constraintCircleAngle="0"

        app:layout_constraintCircleRadius="180dp" />



    <androidx.constraintlayout.utils.widget.ImageFilterView

        android:id="@+id/earth"

        android:layout_width="160dp"

        android:layout_height="160dp"

        android:src="@drawable/earth"

        app:layout_constraintCircle="@id/sun"

        app:layout_constraintCircleAngle="315"

        app:layout_constraintCircleRadius="200dp" />



</androidx.constraintlayout.motion.widget.MotionLayout>

接下来，在Scene文件中，设置相对运动关系，代码如下所示。

<ConstraintSet android:id="@+id/start">



    <Constraint android:id="@id/earth">

        <Motion motion:animateRelativeTo="@+id/sun" />

    </Constraint>



    <Constraint android:id="@id/moon">

        <Motion motion:animateRelativeTo="@+id/earth" />

    </Constraint>



    <Constraint android:id="@+id/rocket">

        <Motion

            motion:animateRelativeTo="@+id/earth"

            motion:motionPathRotate="45" />

    </Constraint>

</ConstraintSet>

借助animateRelativeTo来实现Motion中的相对中心点，使用motionPathRotate来设置旋转的角度。

Motion标签中的motionPathRotate和Constraint标签中的transitionPathRotate的作用，都是让其相对于Path旋转一定角度。

MotionLayout中新增的属性非常多，大家可以参考我的这些文章，从各个方面，逐个击破MotionLayout的各个难点。

要在 Google Play 上发布，开发者需要将应用的 目标 API 级别 (targetSdkVersion) 更新到 API 级别 30 (Android 11) 或者更高版本。针对新上架的应用，这个政策自 8 月开始生效；现有应用更新新的版本，这个政策的要求将自 11 月开始生效。

API 30 所带来的一个巨大变更是，应用需要使用分区存储 (Scoped Storage)。

变更之大，对于大型应用来说堪称恐怖。更糟糕的是，我们在网上看到的有关如何适配分区存储的建议，有一些建议十分令人迷惑，甚至会误导我们。

为了帮您排忧解难，我们收集了一些有关分区存储的常见问题，同时也为如何适配您的应用提供了一些建议和可能的替代方案。

Q: android:requestLegacyStorage 会被移除吗？

A: 部分移除。

如果您的应用当前已经设置了 android:requestLegacyStorage="true"，就应该在 targetSdkVersion 设置为 30 后保持现状。该标记在 Android 11 设备中没有任何效果，但是可以继续让应用在 Android 10 设备上以旧的方式访问存储。

如果您需要针对 Android 10 设备在 AndroidManifest.xml 中设置 android:requestLegacyStorage="true"，那在应用的目标版本改为 Android 11 后应当保留此设置。它仍会在 Android 10 设备上生效。

Q: android:preserveLegacyStorage 是如何工作的？

A: 如果您的应用安装在 Android 10 设备上，并设置了 android:requestLegacyStorage="true"，那在设备升级至 Android 11 后，此设置会继续保持旧的存储访问方式。

?? 如果应用被卸载，或者是第一次在 Android 11 上安装，那么就无法使用旧的存储访问方式。此标记仅适用于进一步帮助设备从传统存储升级到分区存储。

Q: 如果我的应用没有访问照片、视频或音频文件，是否仍然需要请求 READ_EXTERNAL_STORAGE 权限？

A: 不需要，从 Android 11 开始，仅在访问其他应用所属的媒体文件时才需要请求 READ_EXTERNAL_STORAGE 权限。如果您的应用仅使用自身创建的非媒体文件 (或自身创建的媒体文件)，那么就不再需要请求该权限。

如需在 Android 11 后停止请求该权限，仅需修改应用 AndroidManifest.xml 文件中的 <uses-permission> 标签，添加 android:maxSdkVersion="29" 即可:

<uses-permission

   android:name="android.permission.READ_EXTERNAL_STORAGE"

   android:maxSdkVersion="29" />

Q: 我想要访问不属于我应用的照片、视频或一段音频，我必须使用系统文件选择器吗？

A: 不。但如果您想用就可以用，ACTION_OPEN_DOCUMENT 最早可支持至 Android KitKat (API 19)，而 ACTION_GET_CONTENT 则支持至 API 1，二者使用的都是系统文件选择器。由于不需要任何权限，这仍然是首选的解决方案。

如果您不想使用系统文件选择器，您仍然可以请求 READ_EXTERNAL_STORAGE 权限，它会使您的应用可以访问所有的照片、视频以及音频文件，同时也包含访问 File API 的权限！

如果您需要使用 File API 访问媒体内容，记得设置 android:requestLegacyStorage="true"，否则 File API 在 Android 10 中将无法工作。

Q: 我想保存非媒体文件，但我不想在卸载我的应用时删除它们。我需要使用 SAF 吗？

A: 也许需要。

如果这些文件允许在应用外打开而无需通过您的应用，那么系统文件选择器是较好的选择。您可以使用 ACTION_CREATE_DOCUMENT 创建文件。当然也可以使用 ACTION_OPEN_DOCUMENT 来打开一个现有文件。

如果应用曾经创建了一个目录用于存储所有这些文件，那最好的选择就是使用系统文件选择器和 ACTION_OPEN_DOCUMENT_TREE，以便用户可以选择要使用的特定文件夹。

如果这些文件只对您的应用有意义，可以考虑在应用 AndroidManifest.xml 文件的 <application> 标签中设置 android:hasFragileUserData="true"。这将使用户可以保留这些数据，即使在卸载应用时亦是如此。

△ 上图为拥有 "脆弱用户数据" 应用的卸载对话框。对话框中包含了一个复选框，用于指示系统是否应该保留应用数据。

设置了该标记后，存储文件的最佳位置将取决于其内容。包含敏感或私人信息的文件应当存储在 Context#getFilesDir() 所返回的目录中；而不敏感的数据则应存储于 Context#getExternalFilesDir() 所返回的目录中。

Q: 我可以将非媒体文件放置于其他文件夹中 (例如 Downloads 文件夹)，而无需任何权限。这是一个 Bug 吗？

A: 不是。应用可能会向这类集合提供文件，而且最好的方式是对非媒体文件同时使用 Downloads 和 Documents 集合。不过请记得，默认情况下只有创建该文件的应用才可以访问它们。其他应用需要通过系统文件选择器获得访问权限或者拥有对外部存储的广泛访问权限 (即: MANAGE_EXTERNAL_STORAGE 权限) 才行。

?? 对 MANAGE_EXTERNAL_STORAGE 权限的访问受到 Play 政策 监管。

Q: 如果我需要保存一个文档，是否需要使用 SAF？

A: 不用。应用可以向 Documents 与 Downloads 集合提供非媒体文件，而无需任何特殊权限。只要没被卸载，那么向这些集合提供文档的应用拥有这些文档的完全访问权限。

? 如果您的应用为了上面提到的方式保存文档而请求 READ_EXTERNAL_STORAGE 权限的话，在 Android 11 及更高版本中将不必再请求该权限。您可以参考下面的示例修改对该权限的请求 (设定 maxSdkVersion 为 API 版本 29):

<uses-permission

   android:name="android.permission.READ_EXTERNAL_STORAGE"

   android:maxSdkVersion="29" />

如要访问其他应用添加的文档，或者在您的应用卸载重装后访问其卸载前添加的文档，就需要通过 ACTION_OPEN_DOCUMENT Intent 来使用系统文件选择器。

Q: 我想要与其他应用共享文件，是否需要使用 SAF？

A: 不需要。如下是一些与其他应用共享文件的方式:

• 直接分享: 使用 Intent.ACTION_SEND 可以让您的用户通过各种格式与设备上的其他应用共享数据。如果您使用这种方式，使用 AndroidX 的 FileProvider 来将 file:// Uri 自动转换为 content:// Uri 可能会对您有所帮助。


• 创建您自己的 DocumentProvider: 这可以让您的应用继续处理应用的私有目录 ( Context#getFilesDirs() 或 Context#getExternalFilesDirs()) 中内容的同时，仍可以向使用系统文件选择器的其他应用提供访问权限。(请注意，可以在卸载应用后继续保存这些文件——参阅上文中的 android:hasFragileUserData="true" 设置来了解其使用方式。)

最后的思考

Scoped Storage 是一项旨在改善用户隐私保护的重大变更。不过仍然有很多方法可以处理不依赖使用存储访问框架 (Storage Access Framework) 的内容。

如果要存储的数据仅适用于您的应用，那么我们强烈建议使用 应用特定目录。

如果数据是媒体文件，例如照片、视频或者音频，那么可以 使用 MediaStore。注意，从 Android 10 开始，提供内容 不再需要请求权限。

也别忘了可以通过 ACTION_SEND 来与 其他应用共享数据 (或允许它们 与您的应用共享数据)！

公众号：字节数组，希望对你有所帮助 ??

关于 Android 的屏幕适配现在已经有很多成熟的方案了，已经不是一个热门话题了。印象中 2018 年是讨论适配方案最火热的一段时间，那时候字节跳动技术团队发文介绍了其适配方案，之后就带动起了很多位大佬陆续发表文章进行讨论。当时我刚工作不久，在面试时也有被问到过关于屏幕适配的问题，因为对于一些概念认识不清导致回答得并不好 ?? 所以本篇文章就想要从头到尾讲清楚关于屏幕适配的主要知识点，希望对你有所帮助，有错误也希望读者能够指出来 ??

一、ppi & dpi

关于屏幕适配有两个绕不开的概念：ppi 和 dpi，两者在含义上很类似，很容易混淆，但其实是属于不同领域上的概念

ppi

ppi（Pixels Per Inch）即像素密度，指每英寸包含的物理像素的数量。ppi 是设备在物理上的属性值，取决于屏幕自身，计算公式如下所示。被除数和除数都属于客观不可改变的值，所以 ppi 也是无法修改的，是硬件上一个客观存在无法改变的值

dpi

dpi（Dots Per Inch）原先用于在印刷行业中描述每英寸包含有多少个点，在 Android 开发中则用来描述屏幕像素密度。屏幕像素密度决定了在软件概念上单位距离对应的像素总数，是手机在出厂时就会被写入系统配置文件中的一个属性值，一般情况下用户是无法修改该值的，但在开发者模式中有修改该值的入口，是软件上一个可以修改的值

我们知道，在不同手机屏幕上 1 dp 所对应的 px 值可能是会有很大差异的。例如，在小屏幕手机上 1 dp 可能对应 1 px，在大屏幕手机上对应的可能是 3 px，这也是我们实现屏幕适配的基础原理。决定了在特定一台手机上 1 dp 对应多少 px 的正是该设备的 dpi 值，这可以通过 DisplayMetrics 来获取

val displayMetrics = applicationContext.resources.displayMetrics

Log.e("TAG", "densityDpi: " + displayMetrics.densityDpi)

Log.e("TAG", "density: " + displayMetrics.density)

Log.e("TAG", "widthPixels: " + displayMetrics.widthPixels)

Log.e("TAG", "heightPixels: " + displayMetrics.heightPixels)



TAG: densityDpi: 480

TAG: density: 3.0

TAG: widthPixels: 1080

TAG: heightPixels: 2259

从中就可以提取出几点信息：

1. 屏幕像素密度为 480 dpi


2. density 等于 3，说明在该设备上 1 dp 等于 3 px


3. 屏幕宽高大小为 2259 x 1080 px，即 753 x 360 dp

Android 系统定义的屏幕像素密度基准值是 160 dpi，该基准值下 1 dp 就等于 1 px，依此类推 480 dpi 下 1 dp 就等于 3 px，计算公式：

px = dp * (dpi / 160)

不同屏幕像素密度的设备就对应了不同的配置限定符。例如，在 320 到 480 dpi 之间的设备就对应 xxhdpi，该类型设备在取图片时就会优先从 drawable-xxhdpi 文件夹下取

二、为什么要适配

不管我们在布局文件中使用的是什么单位，最终系统在使用时都需要将其转换为 px，由于不同手机的屏幕像素尺寸会相差很大，我们自然不能在布局文件中直接使用 px 进行硬编码。因此 Google 官方也推荐开发者尽量使用 dp 作为单位值，因为系统会根据屏幕的实际情况自动完成 dp 与 px 之间的对应换算

举个例子。假设设计师给出来的设计稿是按照 1080 x 1920 px，420 dpi 的标准来进行设计的，那么设计稿的宽高即 411 x 731 dp，那对于一个希望占据屏幕一半宽度的 ImageView 来说，在设计稿中的宽即 205.5 dp

那么，对于一台 1440 x 2880 px，560 dpi 的真机来说，其宽高即 411 x 822 dp，此时我们在布局文件中就可以直接使用设计稿中给出来的宽度值，使得 ImageView 在这台真机上也占据了屏幕一半宽度。虽然设计稿和真机的屏幕像素并不相同，但由于屏幕像素密度的存在，使得两者的 dp 宽度是一样的，从而令开发者可以只使用同一套 dp 尺寸值就完成设计要求了

既然有了 dp，那我们为什么还需要进行屏幕适配呢？当然也是因为 dp 只适用于大部分正常情况了。以上情况之所以能够完美适配，那也是因为举的例子刚好也是完美的：1440 / 1080 = 560 / 420 = 1.3333，设计稿和真机的 px 宽度和 dp 宽度刚好具有相同比例，此时使用 dp 才能刚好适用

再来看一个不怎么完美的例子。以两台真机为例：

• 华为 nova5：1080 x 2259 px，480 dpi，屏幕宽度为 1080 / (480 / 160) = 360 dp


• 三星 Galaxy S10：1080 x 2137 px，420 dpi，屏幕宽度为 1080 / (420 / 160) = 411 dp

可以看到，在像素宽度相同的情况下，不同手机的像素密度是有可能不一样的。手机厂家有可能是根据屏幕像素和屏幕尺寸来共同决定该值的大小，但不管怎样，这就造成了应用的实际效果与设计稿之间无法对应的情况：对于一个 180 dp 宽度的 View 来说，在华为 nova5 上能占据一半的屏幕宽度，但在三星 Galaxy S10 上却只有 180 / 411 = 0.43，这就造成了一定偏差

以上情况就是直接使用 dp 值无法解决的问题，使用 dp 只能适配大部分宽高比例比较常规的机型，对于特殊机型就无能为力了……

屏幕适配就是要来解决上述问题。对于屏幕适配，开发者希望实现的效果主要有两个：

• 在声明宽高值时，能够直接套用设计稿上给出来的尺寸值，这个尺寸值映射到项目中可能是对应一个具体的值，也可能是对应多套 dimens 文件中的值，但不管是哪一种，在开发阶段都希望能够直接套用而无需再来进行手动计算。这关乎进行屏幕适配的效率


• 适配后的界面最终在不同屏幕上的空间比例都能保持一致。这关乎进行屏幕适配的最终成效

下面就来介绍三种当前比较主流或曾经是主流的的适配方案 ~~

三、今日头条方案

字节跳动技术团队曾经发布过一篇文章介绍了其适配方案：一种极低成本的Android屏幕适配方式

其适配思路基于以下几条换算公式：

• px = density * dp


• density = dpi / 160


• px = dp * (dpi / 160)

在布局文件中声明的 dp 值，最终都需要通过 TypedValue 的 applyDimension 方法来转换为 px，转换公式即：density * dp

    public static float applyDimension(int unit, float value, DisplayMetrics metrics) {

        switch (unit) {

        case COMPLEX_UNIT_PX:

            return value;

        case COMPLEX_UNIT_DIP:

            return value * metrics.density;

        case COMPLEX_UNIT_SP:

            return value * metrics.scaledDensity;

        case COMPLEX_UNIT_PT:

            return value * metrics.xdpi * (1.0f/72);

        case COMPLEX_UNIT_IN:

            return value * metrics.xdpi;

        case COMPLEX_UNIT_MM:

            return value * metrics.xdpi * (1.0f/25.4f);

        }

        return 0;

    }

那么，如果我们能够动态修改 density 值的大小，要求修改后计算出的屏幕宽度就等于设计稿的宽度，不就可以在布局文件中直接使用设计稿给出的各个 dp 宽高值，且使得 View 在不同手机屏幕上都能占据同样的比例吗？

举个例子，假设设计师给出来的设计稿是按照 **1080 x 1920 px，density 2.625，420 dpi ** 的标准来进行设计的，设计稿的宽高即 411 x 731 dp。那么对于一个宽度为 100 dp 的 View，占据设计稿的宽度比例是：100 * 2.625 / 1080 = 0.2430

用以下两台真机的数据为例，在适配前：

• 华为 nova5：1080 x 2259 px，480 dpi。正常情况下其 density 为 3，View 占据的屏幕宽度比例是：100 x 3 / 1080 = 0.2777


• Pixel 2 XL：1440 x 2800 px，560 dpi。正常情况下其 density 为 3.5，View 占据的屏幕宽度比例是：100 x 3.5 / 1440 = 0.2430

采用字节跳动技术团队的方案动态改变 density 进行适配，适配后的 density = 设备真实宽度(单位 px) / 设计稿的宽度（单位 dp）：

• 华为 nova5：适配后 density 变成 1080 / 411 = 2.6277，View 占据的屏幕宽度比例是：100 x 2.6277 / 1080 = 0.2433


• Pixel 2 XL：适配后 density 变成 1440 / 411 = 3.5036，View 占据的屏幕宽度比例是：100 x 3.5036 / 1440 = 0.2433

可以看出来，虽然由于除法运算会导致一点点精度丢失，但完全可以忽略不计，只要我们能动态改变手机的 density，最终 View 在宽度上就都能保持和设计稿完全相同的比例了

实际上 density 只是 DisplayMetrics 类中的一个 public 变量，不涉及任何私有 API，修改后理论上也不会影响到应用的稳定性。因此，只要我们在 Activity 的 onCreate 方法中完成对 density 和 densityDpi 的修改，我们就可以在布局文件中直接使用设计稿给出的 dp 值，不用准备多套 dimens 就能完成适配，十分简洁

    fun setCustomDensity(activity: Activity, application: Application, designWidthDp: Int) {

        val appDisplayMetrics = application.resources.displayMetrics

        val targetDensity = 1.0f * appDisplayMetrics.widthPixels / designWidthDp

        val targetDensityDpi = (targetDensity * 160).toInt()

        appDisplayMetrics.density = targetDensity

        appDisplayMetrics.densityDpi = targetDensityDpi

        val activityDisplayMetrics = activity.resources.displayMetrics

        activityDisplayMetrics.density = targetDensity

        activityDisplayMetrics.densityDpi = targetDensityDpi

    }



    override fun onCreate(savedInstanceState: Bundle?) {

        setCustomDensity(this, application, 420)

        super.onCreate(savedInstanceState)

    }

字节跳动技术团队的文章只给出了示例代码，并没有给出最终落地可用的代码，但在 GitHub 上有一个挺出名的落地实践库，读者值得一看：AndroidAutoSize

四、宽高限定符

宽高限定符是系统原生支持的一种适配方案，通过穷举市面上所有 Android 手机的屏幕像素尺寸来实现适配。实现思路很简单，就是通过比例换算来为不同分辨率的屏幕分别生成一套 dimens 文件

首先，以设计稿的尺寸作为基准分辨率，假设设计稿是 1920 x 1080 px，那么就可以先生成默认的 dimens 文件，生成规则：

• 将屏幕宽度均分为 1080 份，每份 1 px，声明 1080 个 key 值，值从 1 px 开始递增，每次递增 1 px


• 将屏幕高度均分为 1920 份，每份 1 px，声明 1920 个 key 值，值从 1 px 开始递增，每次递增 1 px

最终 dimens 文件就像以下这样：

<resources>

	<dimen name="x1">1px</dimen>

	<dimen name="x2">2px</dimen>

	···

	<dimen name="x1080">1080px</dimen>



	<dimen name="y1">1px</dimen>

	<dimen name="y2">2px</dimen>

	···

	<dimen name="y1920">1920px</dimen>

</resources>

类似地，再来为屏幕尺寸为 1440 x 720 px 的手机生成专属的 dimens 文件，生成规则：

• 将屏幕宽度均分为 1080 份，每份 720 / 1080 = 0.666 px，声明 1080 个 key 值，值从 0.666 px 开始递增，每次递增 0.666 px


• 将屏幕高度均分为 1920 份，每份 1440 / 1920 = 0.75 px，声明 1920 个 key 值，值从 0.75 px 开始递增，每次递增 0.75 px

最终 dimens 文件就像以下这样：

<resources>

	<dimen name="x1">0.666px</dimen>

	<dimen name="x2">1.332px</dimen>

	···

	<dimen name="x1080">720px</dimen>



	<dimen name="y1">0.75px</dimen>

	<dimen name="y2">1.5px</dimen>

	···

	<dimen name="y1920">1440px</dimen>

</resources>

最终，为市面上主流的屏幕尺寸均按照如上规则生成一套专属的 dimens 文件，每套文件均放到以像素尺寸进行命名的 value 文件夹下，就像以下这样：

values

values-1440x720

values-1920x1080

values-2400x1080

values-2408x1080

values-2560x1440

之后，我们就可以直接套用设计稿中的像素尺寸进行开发了，设计稿写的是 100 x 200 px，那么我们在布局文件中就可以直接引用 x100 和 y200。当应用运行在不同分辨率的手机中时，应用会自动去引用相同分辨率的 dimens 文件，此时引用到的实际 px 值具有和设计稿相同的比例大小，这样就实现了适配需求了

需要注意，宽高限定符方案有一个致命缺陷：需要精准命中分辨率才能实现适配。比如 1920 x 1080 px 的手机就一定要引用到 values-1920x1080文件夹内的 dimens 文件，否则就只能去引用默认的 values 文件夹，此时引用到的尺寸值就有可能和实际需求有很大出入，从而导致界面变形。而对于市面上层出不穷的各种分辨率，开发者想穷举完其实很麻烦，所以说，宽高限定符方案的容错率很低

五、smallestWidth

smallestWidth 也是系统原生支持的一种适配方案。smallestWidth 即最小宽度，指的是最短的那一个边长，而不考虑屏幕的方向，适配原理和宽高限定符方案一样，本质上都是通过比例换算来为不同尺寸的屏幕分别准备一套 dimens 文件，应用在运行时再去引用相匹配的 dimens 文件，以此来实现屏幕适配

首先，我们要以设计稿的尺寸作为基准分辨率，假设设计师给出来的设计稿是按照 **1080 x 1920 px **的标准来进行设计的，那么基准分辨率就是设计稿的宽度 1080 px

先为宽度为 360 dp 的设备生成 dimens 文件，生成规则：

• 将 360 dp 均分为 1080 份，每份 360 / 1080 dp，声明 1080 个 key 值，值从 360 / 1080 dp 开始递增，每次递增 360 / 1080 dp

最终 dimens 文件就像以下这样：

<?xml version="1.0" encoding="utf-8"?>

<resources>

    <dimen name="DIMEN_1PX">0.33dp</dimen>

    <dimen name="DIMEN_2PX">0.67dp</dimen>

    ···

    <dimen name="DIMEN_1078PX">359.33dp</dimen>

    <dimen name="DIMEN_1079PX">359.67dp</dimen>

    <dimen name="DIMEN_1080PX">360.00dp</dimen>

</resources>

类似地，我们再按照上述规则为宽度为 380 dp 的设备生成 dimens 文件：

<?xml version="1.0" encoding="utf-8"?>

<resources>

    <dimen name="DIMEN_1PX">0.35dp</dimen>

    <dimen name="DIMEN_2PX">0.70dp</dimen>

    ···

    <dimen name="DIMEN_1078PX">379.30dp</dimen>

    <dimen name="DIMEN_1079PX">379.65dp</dimen>

    <dimen name="DIMEN_1080PX">380.00dp</dimen>

</resources>

最终，为市面上主流的屏幕宽度均按照如上规则生成一套专属的 dimens 文件，每套文件均放到以宽度进行命名的 value 文件夹内，就像以下这样：

values

values-sw360dp

values-sw380dp

values-sw400dp

values-sw420dp

这样，我们就可以直接在布局文件中套用设计稿的 px 值了，应用在运行时就会自动去匹配最符合当前屏幕宽度的资源文件。例如，如果我们引用了 DIMEN_1080PX，那么不管是在宽度为 360 dp 还是 380 dp 的设备中，该引用对应的 dp 值都是刚好占满屏幕宽度，这样就实现了适配需求了

smallestWidth 方案和宽高限定符方案最大的差别就在于容错率，smallestWidth 方案具有很高的容错率，即使应用中没有找到符合当前屏幕宽度的 dimens 文件，应用也会向下寻找并采用最接近当前屏幕宽度的 dimens 文件，只有都找不到时才会去引用默认的 dimens 文件。只要我们准备的 dimens 足够多，且每套 dimens 文件以 5 ~ 10 dp 作为步长递增，那么就能够很好地满足市面上的绝大部分手机了。此外，我们不仅可以使用设计稿的 px 宽度作为基准分辨率，也可以改为使用 dp 宽度，计算规则还是保持一致

六、总结

以上介绍的三种方案各有特点，这里来做个总结

• 今日头条方案。优点：可以直接使用设计稿中的 dp 值，无需生成多套 dimens 文件进行映射，因此不会增大 apk 体积。此外，此方案的 UI 还原度在三种方案中应该是最高的了，其它两种方案都需要精准命中屏幕尺寸后才能达到此方案的还原度。缺点：由于此方案会影响到应用全局，因此如果我们引入了一些第三方库的话，三方库中的界面也会随之被影响到，可能会造成效果变形，此时就需要进行额外处理了


• 宽高限定符方案。容错率太低，且需要准备很多套 dimens 文件，在 Android 刚兴起，屏幕类型还比较少的时候比较吃香，目前应该已经很少有项目采用此方案了，读者可以直接忽略


• smallestWidth 方案。优点：容错率高，在 320 ~ 460 dp 之间每 10 dp 就提供一套 dimens 文件就足够使用了，想要囊括更多设备的话也可以再缩短步长，基本不用担心最终效果会与设计稿相差太多，且此方案不会影响到三方库。缺点：需要生成多套 dimens 文件，增大了 apk 体积

需要强调下，以上三种方案其实都存在一个问题：我们只能实现对单个方向的适配，无法同时兼顾宽高。之所以只能单个方向，是因为当前手机屏幕的宽高比并不是按照一个固定的比例进行递增的，4 : 3、16 : 9、甚至其它宽高比都有，这种背景下我们要达到百分百还原设计稿是不现实的，我们只能选择一个维度来进行适配。幸运的是大部分情况下我们也只需要根据屏幕宽度来进行适配，以上方案已经能够满足我们绝大多数时候的开发需求了。对于少部分需要根据高度进行适配的页面，今日头条方案可以很灵活的进行切换，smallestWidth 方案就比较麻烦了，此时可以通过 ConstraintLayout 来精准按比例控制控件的宽高大小或者是位置，同样也能达到适配要求 ~

此外，我看到网络上很多开发者都在说 dpi 的存在就是为了让大屏幕手机能够显示更多内容，屏幕适配导致 dpi 失去了其原有的意义，但我其实并不理解这和屏幕适配有什么关系。现在的现实背景就是存在某些屏幕像素宽度相同的手机，其 dpi 却不一样，如果单纯直接使用 dp 而不进行额外适配的话，那在这类机型下控件就会相比设计稿多出一些空白或者是超出屏幕范围，这是开发者不得不解决的问题。如果说显示更多内容指的是让控件在大屏幕手机上能够占据更多的物理空间，那么前提也是要让各个控件的大小和位置都符合设计稿的要求，屏幕适配要做到的就是这一点，同等比例下控件在大屏幕手机上自然就会有更多物理空间。而如果说显示更多内容指的是当在大屏幕手机上有剩余空间时就相比小屏幕多显示其它控件，那么我觉得不仅开发要疯，设计师都要疯……

最后，这里再提供一份用于生成 dimens 文件的代码，基于 smallestWidth 方案，代码总的不到一百行，实现思路在前文讲的很清楚了。仅需要填入设计稿的宽高像素大小就可以，默认基于 1080 x 1920 px 的设计稿，生成范围从 320 到 460 dp 之间，步长 10 dp，读者可以按需调整

有需要的同学自取：SmallestWidthGenerator

本文介绍Android端如何连接环信MQTT消息云快速实现消息的自收自发。

一、前提条件

//使用okhttp实现的获取token
JSONObject reqBody = new JSONObject();
reqBody.put("grant_type", "password");
reqBody.put("username", "hxtest");
reqBody.put("password", "1");
OkHttpClient okHttpClient = new OkHttpClient.Builder().build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody requestBody = RequestBody.create(mediaType, reqBody.toString());
Request request = new Request.Builder()
    .url("https://{token域名}/{org_name}/{app_name}/token")
    .post(requestBody)
    .build();
Call call = okHttpClient.newCall(request);
call.enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        Log.e(TAG, "okhttp_onFailure:" + e.getMessage());
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        String responseBody = response.body().string();
        if (response.code() == 200) {
            try {
                JSONObject result = new JSONObject(responseBody);
                String token = result.getString("access_token");
                } catch (JSONException e) {
                    e.printStackTrace();
            }
        }
    }
});

//连接时使用的clientId, 必须唯一
String clientId = String.format("%s@%s", userName, appId);
MqttAndroidClient mMqttClient = new MqttAndroidClient(context, String.format("tcp://%s:%s", mqttUri, mqttPort), clientId);

//连接参数
MqttConnectOptions options;
options = new MqttConnectOptions();
 //设置自动重连
options.setAutomaticReconnect(true);
// 缓存
options.setCleanSession(true);
// 设置超时时间，单位：秒
options.setConnectionTimeout(15);
// 心跳包发送间隔，单位：秒
options.setKeepAliveInterval(15);
// 用户名
options.setUserName(userName);
// 密码
options.setPassword(token.toCharArray());
options.setMqttVersion(MqttConnectOptions.MQTT_VERSION_3_1_1);
//进行连接
mMqttClient.connect(options, null, new IMqttActionListener() {
    @Override
    public void onSuccess(IMqttToken asyncActionToken) {
                    
    }

    @Override
    public void onFailure(IMqttToken asyncActionToken, Throwable exception) {

    }
});

try {
    //连接成功后订阅主题
    mMqttClient.subscribe(topic, qos, null, new IMqttActionListener() {
        @Override
        public void onSuccess(IMqttToken asyncActionToken) {
                    
        }

        @Override
        public void onFailure(IMqttToken asyncActionToken, Throwable exception) {

        }
    });
} catch (MqttException e) {
    e.printStackTrace();
}

try {
    mMqttClient.unsubscribe(topic);
} catch (MqttException e) {
    e.printStackTrace();
}

MqttMessage msg=new MqttMessage();
msg.setPayload(content.getBytes());//设置消息内容
msg.setQos(qos);//设置消息发送质量，可为0,1,2.
//设置消息的topic，并发送。
mMqttClient.publish(topic, msg, null, new IMqttActionListener() {
    @Override
    public void onSuccess(IMqttToken asyncActionToken) {
        Log.d(TAG, "onSuccess: 发送成功");
    }

    @Override
    public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
        Log.d(TAG, "onFailure: 发送失败="+ exception.getMessage());
    }
});

// 设置MQTT监听
mMqttClient.setCallback(new MqttCallback() {
    @Override
    public void connectionLost(Throwable cause) {
        Log.d(TAG, "connectionLost: 连接断开");
    }

    @Override
    public void messageArrived(String topic, MqttMessage message) throws Exception {
        Log.d(TAG, "收到消息:"+message.toString());
    }

    @Override
    public void deliveryComplete(IMqttDeliveryToken token) {
                
    }
});

Context 获取系统服务

    @Override

    public Object getSystemService(String name) {

        return SystemServiceRegistry.getSystemService(this, name);

    }

 

private static final HashMap<String, ServiceFetcher<?>> SYSTEM_SERVICE_FETCHERS =

            new HashMap<String, ServiceFetcher<?>>();



public static Object getSystemService(ContextImpl ctx, String name) {

        ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);

        return fetcher != null ? fetcher.getService(ctx) : null;

    }

 

        registerService(Context.WINDOW_SERVICE, WindowManager.class,

                new CachedServiceFetcher<WindowManager>() {

            @Override

            public WindowManager createService(ContextImpl ctx) {

                return new WindowManagerImpl(ctx);

            }});

 

public void addView(View view, ViewGroup.LayoutParams params,

            Display display, Window parentWindow) {

       ...

        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;

        if (parentWindow != null) {

         parentWindow.adjustLayoutParamsForSubWindow(wparams);

        } else {

            // If there's no parent, then hardware acceleration for this view is

            // set from the application's hardware acceleration setting.

            final Context context = view.getContext();

            if (context != null

                    && (context.getApplicationInfo().flags

                            & ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) {

                wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;

            }

        }



        ViewRootImpl root;

        View panelParentView = null;



        synchronized (mLock) {

            // Start watching for system property changes.

            ...

            int index = findViewLocked(view, false);

            if (index >= 0) {

                if (mDyingViews.contains(view)) {

                    // Don't wait for MSG_DIE to make it's way through root's queue.

                    mRoots.get(index).doDie();

                } else {

                    throw new IllegalStateException("View " + view

                            + " has already been added to the window manager.");

                }

                // The previous removeView() had not completed executing. Now it has.

            }



            // If this is a panel window, then find the window it is being

            // attached to for future reference.

            if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&

                    wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {

                final int count = mViews.size();

                for (int i = 0; i < count; i++) {

                    if (mRoots.get(i).mWindow.asBinder() == wparams.token) {

                        panelParentView = mViews.get(i);

                    }

                }

            }



            root = new ViewRootImpl(view.getContext(), display);



            view.setLayoutParams(wparams);



            mViews.add(view);

            mRoots.add(root);

            mParams.add(wparams);



            // do this last because it fires off messages to start doing things

            try {

                root.setView(view, wparams, panelParentView);

            } catch (RuntimeException e) {

                // BadTokenException or InvalidDisplayException, clean up.

                if (index >= 0) {

                    removeViewLocked(index, true);

                }

                throw e;

            }

        }

    }

 

class Session extends IWindowSession.Stub implements IBinder.DeathRecipient

 

    @Override

    public IWindowSession openSession(IWindowSessionCallback callback, IInputMethodClient client,

            IInputContext inputContext) {

        if (client == null) throw new IllegalArgumentException("null client");

        if (inputContext == null) throw new IllegalArgumentException("null inputContext");

        Session session = new Session(this, callback, client, inputContext);

        return session;

    }

 

@Override

    public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,

            int viewVisibility, int displayId, Rect outFrame, Rect outContentInsets,

            Rect outStableInsets, Rect outOutsets,

            DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel) {

        return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId, outFrame,

                outContentInsets, outStableInsets, outOutsets, outDisplayCutout, outInputChannel);

    }

 

public ViewRootImpl(Context context, Display display) {

        mContext = context;

        mWindowSession = WindowManagerGlobal.getWindowSession();

        mDisplay = display;

        mBasePackageName = context.getBasePackageName();

        mThread = Thread.currentThread();

        mLocation = new WindowLeaked(null);

        mLocation.fillInStackTrace();

        mWidth = -1;

        mHeight = -1;

        mDirty = new Rect();

        mTempRect = new Rect();

        mVisRect = new Rect();

        mWinFrame = new Rect();

        mWindow = new W(this);

        mTargetSdkVersion = context.getApplicationInfo().targetSdkVersion;

        mViewVisibility = View.GONE;

        mTransparentRegion = new Region();

        mPreviousTransparentRegion = new Region();

        mFirst = true; // true for the first time the view is added

        mAdded = false;

        mAttachInfo = new View.AttachInfo(mWindowSession, mWindow, display, this, mHandler, this,

                context);

...

        mViewConfiguration = ViewConfiguration.get(context);

        mDensity = context.getResources().getDisplayMetrics().densityDpi;

        mNoncompatDensity = context.getResources().getDisplayMetrics().noncompatDensityDpi;

        mFallbackEventHandler = new PhoneFallbackEventHandler(context);

        mChoreographer = Choreographer.getInstance();

        mDisplayManager = (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE);



        if (!sCompatibilityDone) {

            sAlwaysAssignFocus = mTargetSdkVersion < Build.VERSION_CODES.P;



            sCompatibilityDone = true;

        }



        loadSystemProperties();

    }

 

static class W extends IWindow.Stub

 

final WindowState windowForClientLocked(Session session, IBinder client, boolean throwOnError) {

        WindowState win = mWindowMap.get(client);

        if (localLOGV) Slog.v(TAG_WM, "Looking up client " + client + ": " + win);

        if (win == null) {

            if (throwOnError) {

                throw new IllegalArgumentException(

                        "Requested window " + client + " does not exist");

            }

            Slog.w(TAG_WM, "Failed looking up window callers=" + Debug.getCallers(3));

            return null;

        }

        if (session != null && win.mSession != session) {

            if (throwOnError) {

                throw new IllegalArgumentException("Requested window " + client + " is in session "

                        + win.mSession + ", not " + session);

            }

            Slog.w(TAG_WM, "Failed looking up window callers=" + Debug.getCallers(3));

            return null;

        }



        return win;

    }

 

            AppWindowToken atoken = null;

            final boolean hasParent = parentWindow != null;

//从DisplayContent找到对应的WIndowToken

            WindowToken token = displayContent.getWindowToken(

                    hasParent ? parentWindow.mAttrs.token : attrs.token);

 

WindowToken getWindowToken(IBinder binder) {

        return mTokenMap.get(binder);

    }

 

            boolean addToastWindowRequiresToken = false;



            if (token == null) {

            //校验窗口参数是否合法  

            ...

                

                final IBinder binder = attrs.token != null ? attrs.token : client.asBinder();

                final boolean isRoundedCornerOverlay =

                        (attrs.privateFlags & PRIVATE_FLAG_IS_ROUNDED_CORNERS_OVERLAY) != 0;

                token = new WindowToken(this, binder, type, false, displayContent,

                        session.mCanAddInternalSystemWindow, isRoundedCornerOverlay);

            } else if (rootType >= FIRST_APPLICATION_WINDOW && rootType <= LAST_APPLICATION_WINDOW) {

                atoken = token.asAppWindowToken();

                  if (atoken == null) {

                    return WindowManagerGlobal.ADD_NOT_APP_TOKEN;

                } 

...

                } else if (atoken.removed) {

...

                } else if (type == TYPE_APPLICATION_STARTING && atoken.startingWindow != null) {

...

                 

                }

            } else if (rootType == TYPE_INPUT_METHOD) {

...

                   

            } else if (rootType == TYPE_VOICE_INTERACTION) {

...

            } else if (rootType == TYPE_WALLPAPER) {

 ...

            } else if (rootType == TYPE_DREAM) {

...

            } else if (rootType == TYPE_ACCESSIBILITY_OVERLAY) {

...

            } else if (type == TYPE_TOAST) {

....

           } else if (type == TYPE_QS_DIALOG) {

...

            } else if (token.asAppWindowToken() != null) {



                attrs.token = null;

                token = new WindowToken(this, client.asBinder(), type, false, displayContent,

                        session.mCanAddInternalSystemWindow);

            }

 

            final WindowState win = new WindowState(this, session, client, token, parentWindow,

                    appOp[0], seq, attrs, viewVisibility, session.mUid,

                    session.mCanAddInternalSystemWindow);

            if (win.mDeathRecipient == null) {

...

                return WindowManagerGlobal.ADD_APP_EXITING;

            }



            if (win.getDisplayContent() == null) {

...

                return WindowManagerGlobal.ADD_INVALID_DISPLAY;

            }



            final boolean hasStatusBarServicePermission =

                    mContext.checkCallingOrSelfPermission(permission.STATUS_BAR_SERVICE)

                            == PackageManager.PERMISSION_GRANTED;

            mPolicy.adjustWindowParamsLw(win, win.mAttrs, hasStatusBarServicePermission);

            win.setShowToOwnerOnlyLocked(mPolicy.checkShowToOwnerOnly(attrs));



            res = mPolicy.prepareAddWindowLw(win, attrs);

            if (res != WindowManagerGlobal.ADD_OKAY) {

                return res;

            }

            // From now on, no exceptions or errors allowed!



            res = WindowManagerGlobal.ADD_OKAY;

            if (mCurrentFocus == null) {

                mWinAddedSinceNullFocus.add(win);

            }



            if (excludeWindowTypeFromTapOutTask(type)) {

                displayContent.mTapExcludedWindows.add(win);

            }



            origId = Binder.clearCallingIdentity();



            win.attach();

//以IWindow为key，WindowState为value存放到WindowMap中

            mWindowMap.put(client.asBinder(), win);



            win.initAppOpsState();



....

            win.mToken.addWindow(win);

 

    void attach() {

        mSession.windowAddedLocked(mAttrs.packageName);

    }

 

void windowAddedLocked(String packageName) {

        mPackageName = packageName;

        mRelayoutTag = "relayoutWindow: " + mPackageName;

        if (mSurfaceSession == null) {

            if (WindowManagerService.localLOGV) Slog.v(

                TAG_WM, "First window added to " + this + ", creating SurfaceSession");

            mSurfaceSession = new SurfaceSession();

            if (SHOW_TRANSACTIONS) Slog.i(

                    TAG_WM, "  NEW SURFACE SESSION " + mSurfaceSession);

            mService.mSessions.add(this);

            if (mLastReportedAnimatorScale != mService.getCurrentAnimatorScale()) {

                mService.dispatchNewAnimatorScaleLocked(this);

            }

        }

        mNumWindow++;

    }

 

前言

    public TouchSurfaceView(Context context) {

        super(context);

    }



    public TouchSurfaceView(Context context, AttributeSet attrs) {

        super(context, attrs);

    }

 

    @Override

    public boolean onTouchEvent(MotionEvent e) {

        float x = e.getX();

        float y = e.getY();

        switch (e.getAction()) {

            case MotionEvent.ACTION_MOVE:

                float dx = x - mPreviousX;

                float dy = y - mPreviousY;

                mRenderer.mAngleX += dx * TOUCH_SCALE_FACTOR;

                mRenderer.mAngleY += dy * TOUCH_SCALE_FACTOR;

                requestRender();

        }

        mPreviousX = x;

        mPreviousY = y;

        return true;

    }

 

    @Override

    public boolean onTrackballEvent(MotionEvent e) {

        mRenderer.mAngleX += e.getX() * TRACKBALL_SCALE_FACTOR;

        mRenderer.mAngleY += e.getY() * TRACKBALL_SCALE_FACTOR;

        requestRender();

        return true;

    }

 

  mGLSurfaceView = new TouchSurfaceView(this);

        setContentView(mGLSurfaceView);

        mGLSurfaceView.requestFocus();

        mGLSurfaceView.setFocusableInTouchMode(true);

 

    @Override

    protected void onResume() {

        super.onResume();

        mGLSurfaceView.onResume();

    }



    @Override

    protected void onPause() {

        super.onPause();

        mGLSurfaceView.onPause();

    }

 

public class TouchSurfaceView extends GLSurfaceView {

    private final float TOUCH_SCALE_FACTOR = 180.0f / 320;

    private final float TRACKBALL_SCALE_FACTOR = 36.0f;

    private CubeRenderer mRenderer;

    private float mPreviousX;

    private float mPreviousY;



    public TouchSurfaceView(Context context) {

        super(context);

        mRenderer = new CubeRenderer();

        setRenderer(mRenderer);

        setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);

    }



    public TouchSurfaceView(Context context, AttributeSet attrs) {

        super(context, attrs);

    }





    @Override

    public boolean onTrackballEvent(MotionEvent e) {

        mRenderer.mAngleX += e.getX() * TRACKBALL_SCALE_FACTOR;

        mRenderer.mAngleY += e.getY() * TRACKBALL_SCALE_FACTOR;

        requestRender();

        return true;

    }



    @Override

    public boolean onTouchEvent(MotionEvent e) {

        float x = e.getX();

        float y = e.getY();

        switch (e.getAction()) {

            case MotionEvent.ACTION_MOVE:

                float dx = x - mPreviousX;

                float dy = y - mPreviousY;

                mRenderer.mAngleX += dx * TOUCH_SCALE_FACTOR;

                mRenderer.mAngleY += dy * TOUCH_SCALE_FACTOR;

                requestRender();

        }

        mPreviousX = x;

        mPreviousY = y;

        return true;

    }





    private class CubeRenderer implements GLSurfaceView.Renderer {



        private Cube mCube;

        public float mAngleX;

        public float mAngleY;

        public CubeRenderer() {

            mCube =new Cube();

        }



        public void onDrawFrame(GL10 gl) {

// | GL10.GL_DEPTH_BUFFER_BIT

            gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

            gl.glMatrixMode(GL10.GL_MODELVIEW);

            gl.glLoadIdentity();

            gl.glTranslatef(0, 0, -3.0f);

            gl.glRotatef(mAngleX, 0, 1, 0);

            gl.glRotatef(mAngleY, 1, 0, 0);

            gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

            gl.glEnableClientState(GL10.GL_COLOR_ARRAY);

            mCube.draw(gl);

        }





        @Override

        public void onSurfaceCreated(GL10 gl, javax.microedition.khronos.egl.EGLConfig config) {

            gl.glDisable(GL10.GL_DITHER);

            gl.glClearColor(1,1,1,1);

        }



        public void onSurfaceChanged(GL10 gl, int width, int height) {

            gl.glViewport(0, 0, width, height);

            //设置投影矩阵。但并不需要在每次绘制时都做，通常情况下，当视图调整大小时，需要设置一个新的投影。

            float ratio = (float) width / height;

            gl.glMatrixMode(GL10.GL_PROJECTION);

            gl.glLoadIdentity();

            gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);

        }



    }







    public class Cube {

        //opengl坐标系中采用的是3维坐标:

        private FloatBuffer mVertexBuffer;

        private FloatBuffer mColorBuffer;

        private ByteBuffer mIndexBuffer;



        public Cube() {

            final float vertices[] = {

                    -1, -1, -1,		 1, -1, -1,

                    1,  1, -1,	    -1,  1, -1,

                    -1, -1,  1,      1, -1,  1,

                    1,  1,  1,     -1,  1,  1,

            };



            final float colors[] = {

                    0,  1,  1,  1,  1,  1,  1,  1,

                    1,  1,  0,  1,  1,  1,  1,  1,

                    1,  1,  1,  1,  0,  1,  1,  1,

                    1,  1,  1,  1,  1,  1,  0,  1,

            };



            final byte indices[] = {

                    0, 4, 5,    0, 5, 1,

                    1, 5, 6,    1, 6, 2,

                    2, 6, 7,    2, 7, 3,

                    3, 7, 4,    3, 4, 0,

                    4, 7, 6,    4, 6, 5,

                    3, 0, 1,    3, 1, 2

            };



            ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length*4);

            vbb.order(ByteOrder.nativeOrder());

            mVertexBuffer = vbb.asFloatBuffer();

            mVertexBuffer.put(vertices);

            mVertexBuffer.position(0);



            ByteBuffer cbb = ByteBuffer.allocateDirect(colors.length*4);

            cbb.order(ByteOrder.nativeOrder());

            mColorBuffer = cbb.asFloatBuffer();

            mColorBuffer.put(colors);

            mColorBuffer.position(0);



            mIndexBuffer = ByteBuffer.allocateDirect(indices.length);

            mIndexBuffer.put(indices);

            mIndexBuffer.position(0);

        }



        public void draw(GL10 gl) {

            //启用服务器端GL功能。

            gl.glEnable(GL10.GL_CULL_FACE);

            //定义多边形的正面和背面。

            //参数:

            //mode——多边形正面的方向。GL_CW和GL_CCW被允许，初始值为GL_CCW。

            gl.glFrontFace(GL10.GL_CW);

            //选择恒定或光滑着色模式。

            //GL图元可以采用恒定或者光滑着色模式，默认值为光滑着色模式。当图元进行光栅化的时候，将引起插入顶点颜色计算，不同颜色将被均匀分布到各个像素片段。

            //参数：

            //mode——指明一个符号常量来代表要使用的着色技术。允许的值有GL_FLAT 和GL_SMOOTH，初始值为GL_SMOOTH。

            gl.glShadeModel(GL10.GL_SMOOTH);

            //定义一个顶点坐标矩阵。

            //参数：

            //

            //size——每个顶点的坐标维数，必须是2, 3或者4，初始值是4。

            //

            //type——指明每个顶点坐标的数据类型，允许的符号常量有GL_BYTE, GL_SHORT, GL_FIXED和GL_FLOAT，初始值为GL_FLOAT。

            //

            //stride——指明连续顶点间的位偏移，如果为0，顶点被认为是紧密压入矩阵，初始值为0。

            //

            //pointer——指明顶点坐标的缓冲区，如果为null，则没有设置缓冲区。

            gl.glVertexPointer(3, GL10.GL_FLOAT, 0, mVertexBuffer);

            //定义一个颜色矩阵。

            //size指明每个颜色的元素数量，必须为4。type指明每个颜色元素的数据类型，stride指明从一个颜色到下一个允许的顶点的字节增幅，并且属性值被挤入简单矩阵或存储在单独的矩阵中（简单矩阵存储可能在一些版本中更有效率）。

            gl.glColorPointer(4, GL10.GL_FLOAT, 0, mColorBuffer);

            //由矩阵数据渲染图元

            //可以事先指明独立的顶点、法线、颜色和纹理坐标矩阵并且可以通过调用glDrawElements方法来使用它们创建序列图元。

            gl.glDrawElements(GL10.GL_TRIANGLES, 36, GL10.GL_UNSIGNED_BYTE, mIndexBuffer);

        }

    }

}

 

public class MainActivity extends AppCompatActivity {

    private GLSurfaceView mGLSurfaceView;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        mGLSurfaceView = new TouchSurfaceView(this);

        setContentView(mGLSurfaceView);

        mGLSurfaceView.requestFocus();

        mGLSurfaceView.setFocusableInTouchMode(true);

    }



    @Override

    protected void onResume() {

        super.onResume();

        mGLSurfaceView.onResume();

    }



    @Override

    protected void onPause() {

        super.onPause();

        mGLSurfaceView.onPause();

    }





}