openglandroidapi

A. 移动应用软件的程序开发 需要学什么语言

基础：java基础+j2me
针对不同的系统，可能还需要看一下特殊的接口，不过多数应用层（咱们开发手机软件的）都使用JAVA。
android手机（也是现在最火的系统，在手机及平板电脑占有量巨大），需要再专门看Android开发，或Google Android API，其实他是C实现的底层，Java实现的上层，但对于开发应用软件来说java足够了，不需要改底层的东西，但如果想自己的程序更高效，更加定制话，那还等需要一些C的基础，及OpenGL等基础（主要是2D，3D界面）。Android系统上的应用层的开发，其实是Java与XML的综合应用。

B. Android SDK 各版本之间有什么差异

一、Android1、1
2008 年9月发布的Android第一版
二、Android1、5 Cupcake （纸杯蛋糕）
2009年4月30日，官方1、5版本（Cupcake 纸杯蛋糕）的Android发布。主要的更新如下：
1、拍摄/播放影片，并支持上传到Youtube
2、支持立体声蓝牙耳机，同时改善自动配对性能
3、最新的采用WebKit技术的浏览器，支持复制/贴上和页面中搜索
4、GPS性能大大提高
5、提供屏幕虚拟键盘
6、主屏幕增加音乐播放器和相框widgets
7、应用程序自动随着手机旋转
8、短信、Gmail、日暦，浏览器的用户接口大幅改进，如Gmail可以批量删除邮件
9、相机启动速度加快，拍摄图片可以直接上传到Picasa
10、来电照片显示
三、Android1、6 Donut （甜甜圈）
2009年9月15日，1、6（Donut 甜甜圈）版本软件开发工具包发布。主要的更新如下：
1、重新设计的Android Market手势
2、支持支持CDMA网络
3、文字转语音系统（Text-to-Speech）
4、快速搜索框
5、全新的拍照接口
6、查看应用程序耗电
7、支持虚拟私人网络（VPN）
8、支持更多的屏幕分辨率。
9、支持OpenCore2媒体引擎
10、新增面向视觉或听觉困难人群的易用性插件
四、Android2、0/2、0、1/2、1 Eclair （松饼）
2009年10月26日，2、0（Eclair 松饼）版本软件开发工具包发布。主要的更新如下：
1、优化硬件速度
2、"Car Home"程序
3、支持更多的屏幕分辨率
4、改良的用户界面
5、新的浏览器的用户接口和支持HTML5
6、新的联系人名单
7、更好的白色/黑色背景比率
8、改进Google Maps3、1、2
9、支持Microsoft Exchange
10、支持内置相机闪光灯
11、支持数码变焦
12、改进的虚拟键盘
13、支持蓝牙2、1
14、支持动态桌面的设计
五、Android2、2/2、2、1Froyo(冻酸奶）
2010年5月20日，2、2（Froyo 冻酸奶）版本软件开发工具包发布。主要的更新如下：
1、整体性能大幅度的提升
2、3G网络共享功能。
3、Flash的支持。
4、App2sd功能。
5、全新的软件商店。
6、更多的Web应用API接口的开发。
六、Android2、3 Gingerbread （姜饼）
2011年2月2日， 3、0（Honeycomb 蜂巢）版本主要更新如下：
1·优化针对平板
2·全新设计的UI增强网页浏览功能
3、·n-app purchases功能
七、Android3、1 Honeycomb （蜂巢）
2011年5月11日在Google I/O开发者大会宣布发布，版本主要更新如下：
1、Honeycomb 蜂巢（改进3、0BUG）
2、经过优化的Gmail电子邮箱；
3、全面支持GoogleMaps
4、将Android手机系统跟平板系统再次合并从而方便开发者。
5、任务管理器可滚动，支持USB 输入设备（键盘、鼠标等）。
6、支持 Google TV、可以支持XBOX 360无线手柄
7、widget支持的变化，能更加容易的定制屏幕widget插件。
八、Android3、2 Honeycomb （蜂巢）
2011年7月13日发布，版本更新如下：
1、支持7英寸设备
2、引入了应用显示缩放功能.
九、Android4、0 Ice Cream “冰激凌三明治”
2011年10月19日 在香港发布，4、0（Ice Cream Sandwich 冰激凌三明治）版本主要更新如下：
1、蓝色主题
2、接近于桌面版的Chrome Lite浏览器，有离线阅读，同步Chrome书签，新的标签样式等。
3、截图功能
4、更强大的图片编辑功能
5、自带照片应用堪比Instagram，可以加滤镜、加相框，进行360度全景拍摄，照片还能根据地点来排序
6、Gmail加入手势、离线搜索功能，UI更强大。
7、新功能People：以联系人照片为核心，界面偏重滑动而非点击，集成了Twitter、Linkedin、Google+等通讯工具。有望支持用户自定义添加第三方服务。
8、新增流量管理工具，可具体查看每个应用产生的流量。
9、正在运行的程序可以像电脑一样的互相切换
10、人脸识别功能
11、系统优化、速度更快
12、支持虚拟按键，手机可以不再拥有任何按键
13、专为3D优化的驱动
14、平板电脑和智能手机通用
十、Android 4、3 Jelly Bean“果冻豆”
2013年7月15日 发布，4、3（ Jelly Bean 果冻豆）版本主要更新如下：
1、Nexus 装置在 Google Play 播放影片时，可开启 Fraunhofer Cingo 提供的虚拟环绕音效效果。
2、 在拨号盘上输入数字，会自动建议符合名字或号码的联系人。此功能可开启或关闭。
3、 屏幕触控输入的算法做了改进，让输入文字变得更容易。
4、 游戏手把或游戏杆的输入延迟（latency）降低。
5、 无需开启 Wi-Fi，即可利用 Wi-Fi 做定位的辅助。
6、 支持 BluetoothSmart（先前称为 Bluetooth Low Energy），Nexus 4 与新 Nexus 7 现在已经是 Bluetooth Smart Ready 装置。
7、 支持蓝牙 AVRCP 1.3 版，可在车用音响上显示歌名。
8、 “已停用”应用程序分页：在“设定”→“应用程序”中新增“已停用”分页，可统一管理已停用的应用程序。
9、 支持 OpenGL ES 3.0，可提供下一代画质更佳的 3D 游戏体验。
10、支持新 Nexus 7 与 Nexus 10 的屏幕无线传输功能，可将屏幕画面无线投射到电视上。
11、支持更多语言：南非语（Afrikanns）、阿姆哈拉语（Amharic）、印地语（Hindi）、斯瓦希里语（Swahili）、祖鲁语（Zulu）。
12、主画面、设定、电话、联系人应用程序可支持右向左写语言（RTL，如希伯来语、阿拉伯语）
13、支持“限制账号”，可设定让装置只能使用特定应用程序与内容。
14、简化设定精灵，让首次开机的设定更容易
15、在锁定画面切换用户账号的速度更快

C. Android 重学系列 View的绘制流程(六) 硬件渲染(上)

本文开始聊聊Android中的硬件渲染。如果跟着我的文章顺序，从SF进程到App进程的绘制流程一直阅读，我们到这里已经有了一定的基础，可以试着进行横向比对如Chrome浏览器渲染流程，看看软件渲染，硬件渲染，SF合成都做了什么程度的优化。

先让我们回顾一下负责硬件渲染的主体对象ThreadedRenderer在整个绘制流程中做了哪几个步骤。

在硬件渲染的过程中，有一个很核心的对象RenderNode，作为每一个View绘制的节点对象。

当每一次进行准备进行绘制的时候，都会雷打不动执行如下三个步骤：

如果遇到什么问题欢迎来到 https://www.jianshu.com/p/c84bfa909810 下进行讨论

实际上整个硬件渲染的设计还是比较庞大。因此本文先聊聊ThreadedRender整个体系中主要对象的构造以及相关的原理。

首先来认识下面几个重要的对象有一个大体的印象。

在Java层中面向Framework中，只有这么多，下面是一一映射的简图。

能看到实际上RenderNode也会跟着View 树的构建同时一起构建整个显示层级。也是因此ThreadedRender也能以RenderNode为线索构建出一套和软件渲染一样的渲染流程。

仅仅这样？如果只是这么简单，知道我习惯的都知道，我喜欢把相关总结写在最后。如果把总揽写在正文开头是因为设计比较繁多。因为我们如果以流水线的形式进行剖析容易造成迷失细节的困境。

让我继续介绍一下，在硬件渲染中native层的核心对象。

如下是一个思维导图：

有这么一个大体印象后，就不容易迷失在源码中。我们先来把这些对象的实例化以及上面列举的ThreadedRenderer在ViewRootImpl中执行行为的顺序和大家来聊聊其原理，先来看看ThreadedRenderer的实例化。

当发现mSurfaceHolder为空的时候会调用如下函数：

而这个方法则调用如下的方法对ThreadedRenderer进行创建：

文件：/ frameworks / base / core / java / android / view / ThreadedRenderer.java

能不能创建的了ThreadedRenderer则决定于全局配置。如果ro.kernel.qemu的配置为0，说明支持OpenGL 则可以直接返回true。如果qemu.gles为-1说明不支持OpenGL es返回false，只能使用软件渲染。如果设置了qemu.gles并大于0，才能打开硬件渲染。

我们能看到ThreadedRenderer在初始化，做了三件事情：

关键是看1-3点中ThreadRenderer都做了什么。

文件：/ frameworks / base / core / jni / android_view_ThreadedRenderer.cpp

能看到这里是直接实例化一个RootRenderNode对象，并把指针的地址直接返回。

能看到RootRenderNode继承了RenderNode对象，并且保存一个JavaVM也就是我们所说的Java虚拟机对象，一个java进程全局只有一个。同时通过getForThread方法，获取ThreadLocal中的Looper对象。这里实际上拿的就是UI线程的Looper。

在这个构造函数有一个mDisplayList十分重要，记住之后会频繁出现。接着来看看RenderNode的头文件：
文件：/ frameworks / base / libs / hwui / RenderNode.h

实际上我把几个重要的对象留下来：

文件：/ frameworks / base / core / java / android / view / RenderNode.java

能看到很简单，就是包裹一个native层的RenderNode返回一个Java层对应的对象开放Java层的操作API。

能看到这个过程生成了两个对象：

这个对象实际上让RenderProxy持有一个创建动画上下文的工厂。RenderProxy可以通过ContextFactoryImpl为每一个RenderNode创建一个动画执行对象的上下文AnimationContextBridge。

文件：/ frameworks / base / libs / hwui / renderthread / RenderProxy.cpp

在这里有几个十分重要的对象被实例化，当然这几个对象在聊TextureView有聊过( SurfaceView和TextureView 源码浅析 )：

我们依次看看他们初始化都做了什么。

文件：/ frameworks / base / libs / hwui / renderthread / RenderThread.cpp

能看到其实就是简单的调用RenderThread的构造函数进行实例化，并且返回对象的指针。

RenderThread是一个线程对象。先来看看其头文件继承的对象：
文件：/ frameworks / base / libs / hwui / renderthread / RenderThread.h

其中RenderThread的中进行排队处理的任务队列实际上是来自ThreadBase的WorkQueue对象。

文件：/ frameworks / base / libs / hwui / thread / ThreadBase.h

ThreadBase则是继承于Thread对象。当调用start方法时候其实就是调用Thread的run方法启动线程。

另一个更加关键的对象，就是实例化一个Looper对象到WorkQueue中。而直接实例化Looper实际上就是新建一个Looper。但是这个Looper并没有获取当先线程的Looper，这个Looper做什么的呢？下文就会揭晓。

WorkQueue把一个Looper的方法指针设置到其中，其作用可能是完成了某一件任务后唤醒Looper继续工作。

而start方法会启动Thread的run方法。而run方法最终会走到threadLoop方法中，至于是怎么走进来的，之后有机会会解剖虚拟机的源码线程篇章进行讲解。

在threadloop中关键的步骤有如下四个：

在这个过程中创建了几个核心对象：

另一个核心的方法就是，这个方法为WorkQueue的Looper注册了监听：

能看到在这个Looper中注册了对DisplayEventReceiver的监听，也就是Vsync信号的监听，回调方法为displayEventReceiverCallback。

我们暂时先对RenderThread的方法探索到这里，我们稍后继续看看回调后的逻辑。

文件：/ frameworks / base / libs / hwui / thread / ThreadBase.h

能看到这里的逻辑很简单实际上就是调用Looper的pollOnce方法，阻塞Looper中的循环，直到Vsync的信号到来才会继续往下执行。详细的可以阅读我写的 Handler与相关系统调用的剖析 系列文章。

文件：/ frameworks / base / libs / hwui / thread / ThreadBase.h

实际上调用的是WorkQueue的process方法。

文件：/ frameworks / base / libs / hwui / thread / WorkQueue.h

能看到这个过程中很简单，几乎和Message的loop的逻辑一致。如果Looper的阻塞打开了，则首先找到预计执行时间比当前时刻都大的WorkItem。并且从mWorkQueue移除，最后添加到toProcess中，并且执行每一个WorkItem的work方法。而每一个WorkItem其实就是通过从某一个压入方法添加到mWorkQueue中。

到这里，我们就明白了RenderThread中是如何消费渲染任务的。那么这些渲染任务又是哪里诞生呢？

上文聊到了在RenderThread中的Looper会监听Vsync信号，当信号回调后将会执行下面的回调。

能看到这个方法的核心实际上就是调用drainDisplayEventQueue方法，对ui渲染任务队列进行处理。

能到在这里mVsyncRequested设置为false，且mFrameCallbackTaskPending将会设置为true，并且调用queue的postAt的方法执行ui渲染方法。

还记得queue实际是是指WorkQueue，而WorkQueue的postAt方法实际实现如下：
/ frameworks / base / libs / hwui / thread / WorkQueue.h

情景带入，当一个Vsync信号达到Looper的监听者，此时就会通过WorkQueue的drainDisplayEventQueue 压入一个任务到队列中。

每一个默认的任务都是执行dispatchFrameCallback方法。这里的判断mWorkQueue中是否存在比当前时间更迟的时刻，并返回这个WorkItem。如果这个对象在头部needsWakeup为true，说明可以进行唤醒了。而mWakeFunc这个方法指针就是上面传下来：

把阻塞的Looper唤醒。当唤醒后就继续执行WorkQueue的process方法。也就是执行dispatchFrameCallbacks方法。

在这里执行了两个事情：

先添加到集合中，在上面提到过的threadLoop中，会执行如下逻辑：

如果大小不为0，则的把中的IFrameCallback全部迁移到mFrameCallbacks中。

而这个方法什么时候调用呢？稍后就会介绍。其实这部分的逻辑在TextureView的解析中提到过。

接下来将会初始化一个重要对象：

这个对象名字叫做画布的上下文，具体是什么上下文呢？我们现在就来看看其实例化方法。
文件：/ frameworks / base / libs / hwui / renderthread / CanvasContext.cpp

文件：/ device / generic / goldfish / init.ranchu.rc

在init.rc中默认是opengl，那么我们就来看看下面的逻辑：

首先实例化一个OpenGLPipeline管道，接着OpenGLPipeline作为参数实例化CanvasContext。

文件：/ frameworks / base / libs / hwui / renderthread / OpenGLPipeline.cpp

能看到在OpenGLPipeline中，实际上就是存储了RenderThread对象，以及RenderThread中的mEglManager。透过OpenGLPipeline来控制mEglManager进而进一步操作OpenGL。

做了如下操作：

文件：/ frameworks / base / libs / hwui / renderstate / RenderState.cpp

文件：/ frameworks / base / libs / hwui / renderthread / DrawFrameTask.cpp

实际上就是保存这三对象RenderThread；CanvasContext；RenderNode。

文件：/ frameworks / base / core / jni / android_view_ThreadedRenderer.cpp

能看到实际上就是调用RenderProxy的setName方法给当前硬件渲染对象设置名字。

文件：/ frameworks / base / libs / hwui / renderthread / RenderProxy.cpp

能看到在setName方法中，实际上就是调用RenderThread的WorkQueue，把一个任务队列设置进去，并且调用runSync执行。

能看到这个方法实际上也是调用post执行排队执行任务，不同的是，这里使用了线程的Future方式，阻塞了执行，等待CanvasContext的setName工作完毕。

D. 手机openGl是什么意思

编程作图

E. 怎么成为安卓工程师

成为安卓工程师需要具备的知识：
1.计算机及相关专业本科以上学历，英语良好，能阅读英文资料；

2.3年以上JAVA开发或移动应用项目开发经验，具备良好的编程习惯；
3.熟悉数据库开发；掌握多线程、TCP/IP Socket/HTTP 网络通信编程；
4.熟悉Android系统体系结构和软件开发技术，掌握Android应用实现机制，Android平台UI设计和常用布局；
5.熟悉Android平台UI开发；熟悉Eclipse或MyEclipse集成开发环境；
6.具有正式发布产品的项目经验；有良好的面向对象分析、设计能力、规范的编程风格和良好文档管理习惯；

作为开发人员，应当在学习并深入了解Android之后，在自己的软件中，将Android的优势发挥出来，同时通过一些手段去弥补Android 本身的缺陷或不足。Android拥有的特点：与硬件交互非常方便，包括摄像头、GPS 等，都可以简单的操作；拥有自己的运行时和虚拟机，优秀的内存管理能力；提供丰富的界面控件供开发者使用，允许可视化开发，并保证Android平台下的应用程序界面一致；提供轻量级的进程间通信机制；支持后台服务类应用程序；支持高效、快速的数据存取方式。

Android开发工程师三个阶段必须掌握的技能：
1、初级：拥有娴熟的Java基础，理解设计模式，比如OOP语言的工厂模式要懂得。掌握AndroidUI控件、AndroidJava层API相关使用。
2、中级：迈向中级，最好再次更新下Java技术，掌握Javaconcurrent库、nio库，精通xml、json解析，做过socketc/s端的程序。内容包括：熟练掌握NDKJNI方式的开发，对Androidframework十分了解。移植一些开源项目，比如FFmpeg、Mplayer到Android上运行。
3、高级：迈向高级，熟悉android开源代码的结构，中间件下层的库，比如webkit、opencore、opengl。熟练的Linux驱动开发，精通Linux内核结构。掌握Android移植，比如常见的TIOMAP、QualcommMSM的硬件移植。
迈向顶尖，发现Android体系中的0day漏洞，能够轻松的找出Root体系的10种方法，协助Google改进Android操作体系。

Android不但是手机操作体系，使用于智能手机领域，也是一个可以广泛用于平板电脑、花费电子、智能家电领域内的归纳开发渠道，其使用领域和市场份额处于急速扩大期。近来，笔者从国内抢先的嵌入式及移动开发专业组织-华清远见集团获悉：跟着国内3G职业的迅猛发展，其上千家合作企业对Android开发人才、特别是Android底层体系开发人才的需求量也出现爆破式急速增加的态势，而兼具Android使用开发和体系底层开发的全才型Android开发工程师更是变成职业稀缺。

而目前企业急缺的，真正需要的Android工程师不只是软件开发工程师，而是兼具Android应用开发和底层系统开发的全才型工程师。也就是说，Android开发不只是Java开发，Android系统实际上是嵌入式操作系统，是基于Linux内核的嵌入式系统。基于这个形势，能够帮助我们更加清楚安卓开发工程师应该具备的能力方向。

F. 安卓开发课程分为哪几个阶段

安卓越的安卓开发课程分为5个阶段，共768课时，第一阶段：android介绍与Java核心部分 (168课时)
第二阶段：Android基础编程 (152课时) 第三阶段：专项技能突破（160课时）第四阶段：高级篇（48课时）Android OpenGL 开发基础 OpenGL基本知识、OpenGL和OpenGl ES介绍 掌握OpenGL开发技巧
第五阶段：高级篇（112课时) Android项目实战 掏客（个人媒体客户端）

G. 在Android上开发一个3D游戏需要用到哪些技术

Android开源游戏引擎是Android游戏开发的基础，选择一个好的Android游戏开发的引擎能让我们更好的来开发游戏，下面就为大家简绍几个Android开源游戏引擎。
1、Angle
Angle是一款专为Android平台设计的，敏捷且适合快速开发的2D游戏引擎，基于OpenGL ES技术开发。该引擎全部用Java代码编写，并且可以根据自己的需要替换里面的实现，缺陷在于文档不足，而且下载的代码中仅仅包含有少量的示例教程。
2、Rokon
rokon是一款Android 2D游戏引擎，基于OpenGL ES技术开发，物理引擎为Box2D，因此能够实现一些较为复杂的物理效果，该项目最新版本为 2.0.3 (09/07/10)。总体来说，此引擎最大的优点在于其开发文档相当之完备，并且项目作者对反馈Bug的修正非常之神速，所以该框架的使用在目前也最为 广泛，有人干脆将它称为Cocos2d-iPhone引擎的Android版（业务逻辑和编码风格上也确实很像）。附带一提，国内某个需要注册会员才能下 载的Android游戏框架衍生于此框架，所以大家也不要刻板的认为收费便一定是好的，免费就一定不好，最低运行环境要求为Android 1.5。
3、LGame
LGame是一款国人开发的Java游戏引擎，有Android及PC(J2SE)两个开发版本，目前最高版本同为0.2.6(31/07/10)。其底 层绘图器LGrpaphics封装有J2SE以及J2ME提供的全部Graphics API（PC版采用Graphics2D封装，Android版采用Canvas模拟实现），所以能够将J2SE或J2ME开发经验直接套用其中，两版本 间主要代码能够相互移植。Android版内置有Admob接口，可以不必配置XML直接硬编码Admob广告信息。
该引擎除了基本的音效、图形、物理、精灵等常用组件以外，也内置有Ioc、xml、http等常用Java组件的封装，代价是jar体积较为庞大，PC版 已突破1.2MB，Android版有所简化也在500KB左右。此外，该引擎还内置有按照1:1实现的J2ME精灵类及相关组件，可以将绝大多数 J2ME游戏平移到Android或PC版中。唯一遗憾的是，该项目作者是个极其懒惰的家伙，开发文档从去年说到今年依旧没有提供，只有游戏示例可供下 载。
4、jPCT
jPCT是一款基于OpenGL技术开发的3D图形引擎(PC环境为标准OpenGL，Android为OpenGL ES)， 以Java语言为基础的，拥有功能强大的Java 3D解决方案。该引擎与LGame（此为2D游戏引擎）相类似，目前拥有PC(J2SE)以及Android两个开发版本。
jPCT的最大优势之一，就在于它惊人的向下兼容性。在PC环境中，jPCT甚至可以运行在JVM1.1环境之中，因为jPCT内部提供的图形渲染接口完 全符合所有的Java 1.1规范（就连已经消失的Microsoft VM乃至更古老的Netscape 4 VM也不例外）。
5、Catcake
Catcake是一款跨平台的Java 3D图形引擎，目前支持PC(J2SE)及Android环境运行（已有iPhone版规划）。该引擎在易用性和运行性能上皆有出色的表现，支持常见的游戏开发功能，诸如精灵动画，音频处理和视频播放等。
转网络知道

H. android 可以用go 语言吗

Go语言将支持Android
概述
我们建议将Go语言引入Android平台，重点是用Go语言编写游戏程序，API将在Android
NDK中定义。
背景
Android平台被设定为一个多应用操作系统，一个相对于传统UNIX系统来说更依赖于网络库和服务的操作系统，这意味着我们将为Go运行时开放更多的API。
将Golang带入Android平台是一件非常糟糕的事情，因为Android本身是Java构建的并且拥有巨量的API，任何试图将这些API用Go替代的结果将会导致一个非常糟糕的结果。无论是手工建立包装类还是自动建立都会导致程序运行非常缓慢。
然而如果使用基于C的API，通过AndroidNDK来编写一些游戏类程序可能会带来意想不到的收获。
提议
在Golang
1.4周期中，Android平台的编译将纳入Go的源，并且包含Android支持的cgo（由Elias
Naur贡献）。Dalvik-loadable
.so外部连接文件的支持也会由Android
NDK提供。
在发布上我们仍然提供交叉平台编译，并且支持在Linux主机上adb工具在Android设备上测试程序。
我们将会提供一个名叫go.mobile的子版本，包含：
1、通过Android
NDK对OpenGL,OpenSL和OpenMAX的支持。
2、一个Java->Go的工具，支持通过Java调用Go的Package，所以许多游戏的菜单UI可以通过标准SDK构建。（有可能会支持通过其他语言调用Go，比如Objective-C。）
3、集成AndroidStudio
新特性将会在Go1.4稳定版中提供。

I. android下的openGL开发

这个建议买本教材看看，现在这样的教材很多。

OpenGL ES 2.0

In this document
Create an Activity with GLSurfaceView
Draw a Shape on GLSurfaceViewDefine a Triangle
Draw the Triangle

Apply Projection and Camera Views
Add Motion
Respond to Touch Events

Related Samples
API Demos - graphics
OpenGL ES 2.0 Sample
TouchRotateActivity

See also
3D with OpenGL
OpenGL ES 1.0

This tutorial shows you how to create a simple Android application that uses the OpenGL ES 2.0 API to perform some basic graphics operations. You'll learn how to:
•Create an activity using GLSurfaceView and GLSurfaceView.Renderer
•Create and draw a graphic object
•Define a projection to correct for screen geometry
•Define a camera view
•Rotate a graphic object
•Make graphics touch interactive

The Android framework supports both the OpenGL ES 1.0/1.1 and OpenGL ES 2.0 APIs. You should carefully consider which version of the OpenGL ES API (1.0/1.1 or 2.0) is most appropriate for your needs. For more information, see Choosing an OpenGL API Version. If you would prefer to use OpenGL ES 1.0, see the OpenGL ES 1.0 tutorial.

Before you start, you should understand how to create a basic Android application. If you do not know how to create an app, follow the Hello World Tutorial to familiarize yourself with the process.

Caution: OpenGL ES 2.0 is currently not supported by the Android Emulator. You must have a physical test device running Android 2.2 (API Level 8) or higher in order to run and test the example code in this tutorial.

Create an Activity with GLSurfaceView

To get started using OpenGL, you must implement both a GLSurfaceView and a GLSurfaceView.Renderer. The GLSurfaceView is the main view type for applications that use OpenGL and the GLSurfaceView.Renderer controls what is drawn within that view. (For more information about these classes, see the 3D with OpenGL document.)

To create an activity using GLSurfaceView:
1.Start a new Android project that targets Android 2.2 (API Level 8) or higher.
2.Name the project HelloOpenGLES20 and make sure it includes an activity called HelloOpenGLES20.
3.Modify the HelloOpenGLES20 class as follows: package com.example.android.apis.graphics;import android.app.Activity;import android.content.Context;import android.opengl.GLSurfaceView;import android.os.Bundle;public class HelloOpenGLES20 extends Activity { private GLSurfaceView mGLView; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Create a GLSurfaceView instance and set it // as the ContentView for this Activity mGLView = new HelloOpenGLES20SurfaceView(this); setContentView(mGLView); } @Override protected void onPause() { super.onPause(); // The following call pauses the rendering thread. // If your OpenGL application is memory intensive, // you should consider de-allocating objects that // consume significant memory here. mGLView.onPause(); } @Override protected void onResume() { super.onResume(); // The following call resumes a paused rendering thread. // If you de-allocated graphic objects for onPause() // this is a good place to re-allocate them. mGLView.onResume(); }} class HelloOpenGLES20SurfaceView extends GLSurfaceView { public HelloOpenGLES20SurfaceView(Context context){ super(context); // Create an OpenGL ES 2.0 context. setEGLContextClientVersion(2); // Set the Renderer for drawing on the GLSurfaceView setRenderer(new HelloOpenGLES20Renderer()); }}
Note: You will get a compile error for the HelloOpenGLES20Renderer class reference. That's expected; you will fix this error in the next step.

As shown above, this activity uses a single GLSurfaceView for its view. Notice that this activity implements crucial lifecycle callbacks for pausing and resuming its work.

The HelloOpenGLES20SurfaceView class in this example code above is just a thin wrapper for an instance of GLSurfaceView and is not strictly necessary for this example. However, if you want your application to monitor and respond to touch screen events—and we are guessing you do—you must extend GLSurfaceView to add touch event listeners, which you will learn how to do in the Reponding to Touch Events section.

In order to draw graphics in the GLSurfaceView, you must define an implementation of GLSurfaceView.Renderer. In the next step, you create a renderer class to complete this OpenGL application.

4.Create a new file for the following class HelloOpenGLES20Renderer, which implements the GLSurfaceView.Renderer interface: package com.example.android.apis.graphics;import javax.microedition.khronos.egl.EGLConfig;import javax.microedition.khronos.opengles.GL10;import android.opengl.GLES20;import android.opengl.GLSurfaceView;public class HelloOpenGLES20Renderer implements GLSurfaceView.Renderer { public void onSurfaceCreated(GL10 unused, EGLConfig config) { // Set the background frame color GLES20.glClearColor(0.5f, 0.5f, 0.5f, 1.0f); } public void onDrawFrame(GL10 unused) { // Redraw background color GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT); } public void onSurfaceChanged(GL10 unused, int width, int height) { GLES20.glViewport(0, 0, width, height); } }
This minimal implementation of GLSurfaceView.Renderer provides the code structure needed to use OpenGL drawing methods:
◦onSurfaceCreated() is called once to set up the GLSurfaceView environment.
◦onDrawFrame() is called for each redraw of the GLSurfaceView.
◦onSurfaceChanged() is called if the geometry of the GLSurfaceView changes, for example when the device's screen orientation changes.

For more information about these methods, see the 3D with OpenGL document.

The code example above creates a simple Android application that displays a grey screen using OpenGL ES 2.0 calls. While this application does not do anything very interesting, by creating these classes, you have layed the foundation needed to start drawing graphic elements with OpenGL ES 2.0.

If you are familiar with the OpenGL ES APIs, these classes should give you enough information to use the OpenGL ES 2.0 API and create graphics. However, if you need a bit more help getting started with OpenGL, head on to the next sections for a few more hints.

Note: If your application requires OpenGL 2.0, make sure you declare this in your manifest:
<!-- Tell the system this app requires OpenGL ES 2.0. --> <uses-feature android:glEsVersion="0x00020000" android:required="true" />
For more information, see OpenGL manifest declarations in the 3D with OpenGL document.

J. 移动应用开发需要学什么

1. 首先，做主题和做应用是两码事，做主题是切图，做图，做应用的话就要写代码了。两条路，要慎重。

2. 学习ios和Android也是两码事，ios语言是OC和swift，Android的话就是Java。

3. ios门槛要高一些，你需要一台装在Mac OS的电脑（推荐MBR），一台iPhone（可选），每年交年费。

4. Android的话门槛低一些，但是入门快，最大的痛苦是官网被墙了，

如果不是计算机专业，那就自己辛苦一些，多听听计算机专业的课，毕竟基础还是蛮重要的，当然多写代码更重要。

具体学习:

在微博里面有课程，所有知识都涵盖