1、穿着不要太随意，但也不要太庄重，干净、整洁，头发要梳理好，西装一般没什么必要，上班需要穿西装的都是皮包公司。所以同学们没必要为了面试而特地去买一件西装。女生可以穿正装，感觉比较成熟。

2、如果一个公司，办公桌上只有电话没有电脑，100％是皮包公司。

3、如果面试的时候，面试官没有马上录用你，你回去后一天内没有消息，那就说明面试失败。一般面试官都会说，回去等，一周或者两周内给你消息，其实这都是假的。如果对方对你感兴趣，一般来说，都会当场拍板。

4、有些公司，美其名曰“某某贸易公司”，多半是直销公司，还有一些直销化妆品的公司，会起名叫“某某食品公司”，如果名字听上去很随意，网上有找不到信息，99％是皮包公司。

5、在网上投递简历的时候，如果一个岗位招聘人数很多（5个甚至10个，20个），99％是皮包公司（营业员除外）。如果一个岗位对学历没有要求，工作性质谈得很少，但是薪水却还过得去（2000以上），那么99％是皮包公司。

6、社会上的招聘会一般没必要去，除非是大学自己举办的。社会上的招聘会一般都是垃圾岗位，而且面向外地人比较多。比如中山西路的固定招聘会，上海体育馆的固定招聘会，基本上没有好的岗位。现在网络发达了，公司没必要到现场去招人。

7、面试时的薪水要求，其实自己没必要有什么心理价位，因为对方早就定好了。不以你的意志为转移。如果面试官问你，你就说由公司决定就行了。

8、保险公司会改头换面出现，比如某某金融公司，100％是让你推销保险，不用搭理，电话打来，只要说某某金融公司的，我都直接挂断。还有叫信托投资公司的，也直接挂断。

9、有一种公司叫投资咨询公司，现在上海基本上已经消灭了，但有时候还会借尸还魂，同学们要注意。这种公司以卖原始股为诱饵，告诉客户今后在美国上市会利润翻倍，其实是诈骗。根本无法交易，即使能交易，中国人也无法到美国市场进行交易。股份倒是真的，但不能分红。同学们遇到这种企业，直接PK它。

10、对于本科生的学弟学妹，我建议你们面试宁少勿滥，要到真正有希望，能学到东西的公司企业去。要勤于浏览招聘网站，但投递简历不要太多。

11、英语这个东西，当你遇到它了，你才知道它有用。但我还是希望同学们能在最后半年拼一个六级出来（如果你现在四级都没过，那基本上无视）。
12、货代是一个很容易找到工作的行业，薪水一般，对专业没有要求（只要懂一点三脚猫英语），一般都是高职、甚至中专生去的地方。而且低素质的女生比较多，万般无奈建议大家不要去。这个行业非常繁忙，我一个同学做过，连吃饭的时间都没有。工作很机械化，人会发疯。

13、储备干部，基本上是垃圾。超市的储备干部，基本上就是理货员。

14、凡是要先付钱的，当场就走人。

15、行业不要经常变换，这个容易伤筋动骨。所以一开始的选择很重要。

16、如果你有贵人相助，那当然最好。如果你没有，也不用灰心丧气，看看我，一个面试过34家公司的男人，不是也照样挺过来了嘛。人经历一些事情，可以学到一些东西。走一些弯路，可以看到别样风景。总之，同学们要相信自己。

2. 知道了形状，要设定数据源，也就是要画的点有哪些。通过gl.glVertexPointer(3, GL10.GL_FIXED, 0, vertexBuff );来设定。vertexBuff就是你想要画的哪些点。它表示为一个一维矩阵，但实际上根据你要画的形状来分成多个部分的。比如你想一个三角形。那么这个矩阵就可以表示为{-1，0，1，0，0，2}，{-1，0}表示第一个点，{1，0}表示第二个点，{0，2}表示第三个点。如果之后还有的话，也应该是6*N个数字，以确定更多的三角形坐标。

3. 要是gl.glDrawArrays()方法起作用，之前得调用gl.glEnableClientState(int p1); p1表示要激活的数组的种类，比如要gl.glVertexPointer()设置vertex,那么必须先调用gl.glEnableClientState(GL10.GL_VERTEX_ARRAY）;要用数组设置颜色，先调用gl.glEnableClientState( GL10.GL_COLOR_ARRAY );

4. 画三维图像时，要激活深度测试。gl.glEnable( GL10.GL_DEPTH_TEST );

5. 使用texture之前必须先调用gl.glEnable( GL10.GL_TEXTURE_2D );同时调用gl.glEnableClientState( GL10.GL_TEXTURE_COORD_ARRAY );来激活texture数组画图。
6. glLoadIdentity():另当前绘图坐标系从新回到世界坐标系的位置，另他们重合。
glTranslatef(x,y,z):使绘图坐标系相对世界坐标系沿x,y,z轴移动x,y,z个单位。
glVertex3f(x,y,z):在当前绘图坐标系绘制一个点
glColor3f(r,g,b):设置以后绘图函数的绘图颜色，如果没有再次碰到glColor3f(),以后任何绘图函数绘制出的图形颜色都是这个颜色。r,g,b的范围从0.0-1.0。r-蓝色，g-绿色，b-蓝色，色彩是这三种颜色分量的混合，比如glColor3f(1.0,1.0,0.0)是黄色，glColor3f(1.0,0.0,0.0)是红色。
glRotatef(angle,x,y,z):和glTranslatef()属于一类函数，glTranslatef()是平移，glRotatef是旋转，就是使当前绘图坐标系绕世界坐标系的x,y,z旋转angle个角度，x,y,z的值非0既1，比如glRotatef(30,1.0f,0.0f,0.0f)就是绕x轴旋转30度，glRotatef(30,1.0f,1.0f,0.0f)就是绕x,y的夹角线旋转30度。

7. 用glRotatef能是对象本身围绕一个向量旋转，我们也可以改变观测镜头本身，参考点和向上向量来改变所看到的对象，能产生glRotatef同样的旋转效果。
GLU.gluLookAt（gl,
0.0f, 0.0f, 3.0f,//观测点在屏幕正中向外3.0f单位距离的地方
viewX, 0.0f, 0.0f, //参考点在屏幕中间水平位置viewX
0.0f, 1.0f, 0.0f );//表示Y轴向上
综合这三个点，表示你这个人的眼睛从屏幕正中向外的3.0单位距离的地方,拿着摄像机瞄准viewX的地方再看，看的时候你的头是向上的（如果设置成1.0f, 0.0f, 0.0f，那么表示你的头得向右歪过来，成水平来看）。

http://seya.javaeye.com/blog/528560

android中,关于Intent相关内容是一整套强大的解耦合机制,跟spring的依赖注射有异曲同工之妙,这里来举几个简单应用的例子.

1\如何让用户不需要,而系统必须有的组件从ui中消失.

比如mid中的phone、mms和contact应用(如上图椭圆标注的),对于没有电话功能的mid来说,让它们出现在ui中是非常扎眼的,对于有完美主义倾向的人来说,永远用不到的东西出现在选单当中,会让用户觉得没有被尊重的感觉,所以,很有必要让它们在背后默默的服务,而不在用户面前碍眼.

解决的办法很简单,进入到对应应用的andoridmunifest.xml文件你会看到这样的代码:

———————————————————————————————————-

<activity android:name=”Settings” android:label=”@string/settings_label”

android:taskAffinity=”com.android.settings”

android:clearTaskOnLaunch=”true”

android:launchMode=”singleTop”>

<intent-filter>

<action android:name=”android.intent.action.MAIN” />

<action android:name=”android.settings.SETTINGS” />

<category android:name=”android.intent.category.DEFAULT” />

<category android:name=”android.intent.category.LAUNCHER” />

</intent-filter>

</activity>

———————————————————————————————————

把红色的这一行拿掉即可.

一个Activity如果拥有“android.intent.category.LAUNCHER”这个属性,则表示它属于这个应用为普通用户提供的入口,就像超市为顾客指定的入口一样,用户可以通过应用程序的门进入到应用内部体验.而对程序开发者而言,进入的方式就不限于launcher属性的Activity了,通过intent提供的action,category,class,type都可以匹配到对应的Activity,通过intent调用Activity分为显式调用和隐式调用,显示调用局限于应用内部,而隐式调用则完全是解耦的全局匹配模式.非常之方便.

2\如何像astro一样同一个应用在allappsview里面显示多个快捷方式呢?

同样的,在你需要它显示的Activity里面加上<category android:name=”android.intent.category.LAUNCHER” />即可.则像上图中的方形标注的快捷方式一样,来自同一个应用,但是有自己独立的快捷方式.要修改图片和文字内容也很简单,配置以下紫色的项即可.

———————————————————————————————————-

<activity android:name=”WirelessSettings”

android:label=”@string/wireless_networks_settings_title”

android:icon=”@drawable/ic_launcher_settings”

>

<intent-filter>

<action android:name=”android.intent.action.MAIN” />

<action android:name=”android.settings.WIRELESS_SETTINGS” />

<action android:name=”android.settings.AIRPLANE_MODE_SETTINGS” />

<category android:name=”android.intent.category.DEFAULT” />

<category android:name=”android.intent.category.LAUNCHER” />

<category android:name=”android.intent.category.VOICE_LAUNCH” />

</intent-filter>

</activity>

———————————————————————————————————-

http://unicorn25.javaeye.com/blog/834300

1开机图片:

android-logo-mask.png
android-logo-shine.png

这两个图片一个在上一个在下　　./out/target/common/obj/JAVA_LIBRARIES/android_stubs_current_intermediates/classes/assets/images/android-logo-shine.png

./frameworks/base/core/res/assets/images/android-logo-shine.png

注意:如果源码没有make可以直接更改frameworks里的的图片就可以了

然后直接make否则必须全更改并且不能make只能make firmwar

2默认开机墙纸的位置:

default_wallpaper.jpg　　./out/target/common/obj/JAVA_LIBRARIES/android_stubs_current_intermediates/classes/res/drawable/default_wallpaper.jpg
./frameworks/base/core/res/res/drawable/default_wallpaper.jpg

注意:这个设置和上面的一样这俩个都不能更改文件名

3更改PC机器删除硬件的文字kernel中
drivers/usb/gadget/f_mass_storage.c
fsg->vendor = “XXXXXXXXXXXXX”;

4更改卷标:
bootable/recovery/etc/init.rc
setprop UserVolumeLabel “XXXXXXXXXXXXX”

直接打包

5修改屏幕锁:
(1)
frameworks/base/packages/SettingsProvider/res/values/defaults.xml
<integer name=”def_screen_off_timeout”>60000</integer>
60000改成想要的时间如果是不锁为-1
(2)

frameworks/policies/base/phone/com/android/internal/policy/impl/KeyguardViewMediator.java

private boolean mExternallyEnabled = true;
将其修改成false

这样更改就不会再进入休眠状态了

6初始化语言:
out\target\product\sdkDemo\root\default.prop
rkdroid2.1\recovery\default.prop
ro.product.locale.language = es_ES
ro.product.locale.region = es_ES

不能make直接打包

7设定初始化主页:
package/app/Browser/res/values/String.xml

655行

后面的应该是书签里的

8设定亮度0~255:
frameworks/base/packages/SettingsProvider/res/values/defaults.xml
def_screen_brightness–>这个值初始化好像是100多

9音量:
frameworks/base/media/java/android/media/AudioManager.java
数组DEFAULT_STREAM_VOLUME第4个值(最大我设置到30但是还是差2格才到最大–默认是11
建议将数组里的所有的数值都设为最大就OK了)

mm frameworks/base

10设置Google帐户，左上角提示“正在设置RK2818SDK”，要求改成“正在设置W9”:
out\target\product\sdkDemo\root 中default.prop文件第13行
ro.product.model=rk2818sdk  改为 ro.product.model=W9

11录音没有小时显示。要求增加:
packages\apps\SoundRecorder\src\com\android\soundrecorder
（1）SoundRecorder.java中： private void updateTimerView()
把 String timeStr = String.format(mTimerFormat, time/60, time%60);
改为：long hour=time/3600;
String timeStr = String.format(mTimerFormat, hour, (time-hour*3600)/60, time%60);
(2)  \res\values中strings.xml改为：
<string name=”timer_format”><xliff:g id=”format”>%02d:%02d:%02d</xliff:g></string>

12去掉Bluetooth:

(主界面->添加文件夹->Bluetooth received)

ic_launcher_folder_bluetooth.png（72*72）:

在\packages\apps\Bluetooth\res\drawable-hdpi
解决方法：删除\out\target\product\sdkDemo\system\app下的Bluetooth.apk

13充电锁屏时图片：

frameworks\base\core\res\res\drawable-hdpi:ic_lock_idle_charging.png

14去掉锁屏时显示充电百分比在：

frameworks\base\core\res\res\values-zh-rCN中strings.xml 的lockscreen_plugged_in 括号中的内容及括号 !!

15去掉动态桌面背景选项：

packages\wallpapers\Basic 中AndroidManifest.xml的<service>这些，如星系注释掉如下这些：
<service
android:label=”@string/wallpaper_galaxy”
android:name=”com.android.wallpaper.galaxy.GalaxyWallpaper”
android:permission=”android.permission.BIND_WALLPAPER”>
<intent-filter>
<action android:name=”android.service.wallpaper.WallpaperService” />
</intent-filter>
<meta-data android:name=”android.service.wallpaper” android:resource=”@xml/galaxy” />
</srvice>

16更改版本号:
build/core/Makefile
79行
RK_VER := xxx

17更改界面布局

位置:package/app/Launcher2/res/xml/default_workspace.xml

注意:adb shell 里当你点击任意的一个apk的时候,在后台会输出

I/ActivityManager(  728): Starting activity: Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0×10200000 　　 　cmp=com.estrongs.android.pop/.view.FileExplorerActivity bnds=[294,373][393,478] }
I/WindowManager(  728): Setting rotation to 1, animFlags=0

看蓝色的部分就可以找到/前是包名/后面是类名–>这个是在default_workspace.xml里面需要用到的

launcher:packageName=”com.android.browser”
launcher:className=”com.android.browser.BrowserActivity”

18如何将pdf类的文件放到桌面上

客户要求将他们自己制作的pdf帮助文档放置到桌面上使客人可以直接点击就浏览

String urlString = “/system/app/Nvsbl P4Dv2 English Manual.pdf”;
Intent intent = new Intent();
intent.setAction(android.content.Intent.ACTION_VIEW);
intent.setDataAndType(Uri.fromFile(new File(urlString)),”application/pdf”);
startActivity(intent);
finish();

解释下:

首先将pdf文档放到out/target/product/sdkDemo/system/app下

将固定地址给出urlString,使用Intent

intent.setAction(android.content.Intent.ACTION_VIEW);启动View

intent.setDataAndType(Uri.fromFile(new File(urlString)),”application/pdf”);

application/pdf可以指定别的格式包括音频,视频,图片等等但是没有试过有需要可以试试

19.如何修改版本号？

用记事本打开build.prop，修改以下几行就行（如果装有linux的话，在linux下修改更好，windows下排版显示错误，包含中文的话需要UTF-8格式保存）

另外，给一点常用的配置参数，加在最后就可以了：
ro.product.locale.language=zh
ro.product.locale.region=CN
ro.setupwizard.mode=DISABLED
persist.sys.timezone=Asia/Shanghai

20.如何汉化运营商名称？

用记事本打开system\etc下的spn-conf.xml。将里面的China Mobile全部替换成中国移动，China Unicom全部换成中国联通即可（如果替换后出现乱码，用UTF-8格式保存）。

注意:这个方法很不到如果只放置一些图片还可以但是如果放置文件比较大那么打包出来的

system.img文件会很大也就是占用本身的系统内存—–>所以不推荐使用!!!!!!!!!!!

http://www.cnblogs.com/hesiming/archive/2010/12/09/1901367.html

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。例如，使用它能获得 Java 类中各成员的名称并显示出来。

Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。

JavaBean 是 reflection 的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 Java 组件(类) 的属性。

1. 一个简单的例子

考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++)
System.out.println(m[i].toString());
} catch (Throwable e) {
System.err.println(e);
}
}
}

按如下语句执行：

java DumpMethods java.util.Stack

它的结果输出为：

public java.lang.Object java.util.Stack.push(java.lang.Object)

public synchronized java.lang.Object java.util.Stack.pop()

public synchronized java.lang.Object java.util.Stack.peek()

public boolean java.util.Stack.empty()

public synchronized int java.util.Stack.search(java.lang.Object)

这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。

这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

2.开始使用 Reflection

用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

下面就是获得一个 Class 对象的方法之一：

Class c = Class.forName(“java.lang.String”);

这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：

Class c = int.class;

或者

Class c = Integer.TYPE;

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：

Class c = Class.forName(“java.lang.String”);

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的第一个方法的原型。

在下面的例子中，这三个步骤将为使用 reflection 处理特殊应用程序提供例证。

模拟 instanceof 操作符

得到类信息之后，通常下一个步骤就是解决关于 Class 对象的一些基本的问题。例如，Class.isInstance 方法可以用于模拟 instanceof 操作符：

class A {
}

public class instance1 {
public static void main(String args[]) {
try {
Class cls = Class.forName(“A”);
boolean b1 = cls.isInstance(new Integer(37));
System.out.println(b1);
boolean b2 = cls.isInstance(new A());
System.out.println(b2);
} catch (Throwable e) {
System.err.println(e);
}
}
}

在这个例子中创建了一个 A 类的 Class 对象，然后检查一些对象是否是 A 的实例。Integer(37) 不是，但 new A() 是。

3.找出类的方法

找出一个类中定义了些什么方法，这是一个非常有价值也非常基础的 reflection 用法。下面的代码就实现了这一用法：

import java.lang.reflect.*;

public class method1 {
private int f1(Object p, int x) throws NullPointerException {
if (p == null)
throw new NullPointerException();
return x;
}

public static void main(String args[]) {
try {
Class cls = Class.forName(“method1″);
Method methlist[] = cls.getDeclaredMethods();
for (int i = 0; i < methlist.length; i++) {
Method m = methlist[i];
System.out.println(“name = ” + m.getName());
System.out.println(“decl class = ” + m.getDeclaringClass());
Class pvec[] = m.getParameterTypes();
for (int j = 0; j < pvec.length; j++)
System.out.println(“param #” + j + ” ” + pvec[j]);
Class evec[] = m.getExceptionTypes();
for (int j = 0; j < evec.length; j++)
System.out.println(“exc #” + j + ” ” + evec[j]);
System.out.println(“return type = ” + m.getReturnType());
System.out.println(“—–”);
}
} catch (Throwable e) {
System.err.println(e);
}
}
}

这个程序首先取得 method1 类的描述，然后调用 getDeclaredMethods 来获取一系列的 Method 对象，它们分别描述了定义在类中的每一个方法，包括 public 方法、protected 方法、package 方法和 private 方法等。如果你在程序中使用 getMethods 来代替 getDeclaredMethods，你还能获得继承来的各个方法的信息。

取得了 Method 对象列表之后，要显示这些方法的参数类型、异常类型和返回值类型等就不难了。这些类型是基本类型还是类类型，都可以由描述类的对象按顺序给出。

输出的结果如下：

name = f1

decl class = class method1

param #0 class java.lang.Object

param #1 int

exc #0 class java.lang.NullPointerException

return type = int

—–

name = main

decl class = class method1

param #0 class [Ljava.lang.String;

return type = void

-----
4.获取构造器信息

获取类构造器的用法与上述获取方法的用法类似，如：

import java.lang.reflect.*;

public class constructor1 {
public constructor1() {
}

protected constructor1(int i, double d) {
}

public static void main(String args[]) {
try {
Class cls = Class.forName(“constructor1″);
Constructor ctorlist[] = cls.getDeclaredConstructors();
for (int i = 0; i < ctorlist.length; i++) {
Constructor ct = ctorlist[i];
System.out.println(“name = ” + ct.getName());
System.out.println(“decl class = ” + ct.getDeclaringClass());
Class pvec[] = ct.getParameterTypes();
for (int j = 0; j < pvec.length; j++)
System.out.println(“param #” + j + ” ” + pvec[j]);
Class evec[] = ct.getExceptionTypes();
for (int j = 0; j < evec.length; j++)
System.out.println(“exc #” + j + ” ” + evec[j]);
System.out.println(“—–”);
}
} catch (Throwable e) {
System.err.println(e);
}
}
}

这个例子中没能获得返回类型的相关信息，那是因为构造器没有返回类型。

这个程序运行的结果是：

name = constructor1

decl class = class constructor1

—–

name = constructor1

decl class = class constructor1

param #0 int

param #1 double

—–

5.获取类的字段(域)

找出一个类中定义了哪些数据字段也是可能的，下面的代码就在干这个事情：
import java.lang.reflect.*;

public class field1 {
private double d;
public static final int i = 37;
String s = “testing”;

public static void main(String args[]) {
try {
Class cls = Class.forName(“field1″);
Field fieldlist[] = cls.getDeclaredFields();
for (int i = 0; i < fieldlist.length; i++) {
Field fld = fieldlist[i];
System.out.println(“name = ” + fld.getName());
System.out.println(“decl class = ” + fld.getDeclaringClass());
System.out.println(“type = ” + fld.getType());
int mod = fld.getModifiers();
System.out.println(“modifiers = ” + Modifier.toString(mod));
System.out.println(“—–”);
}
} catch (Throwable e) {
System.err.println(e);
}
}
}

这个例子和前面那个例子非常相似。例中使用了一个新东西 Modifier，它也是一个 reflection 类，用来描述字段成员的修饰语，如“private int”。这些修饰语自身由整数描述，而且使用 Modifier.toString 来返回以“官方”顺序排列的字符串描述 (如“static”在“final”之前)。这个程序的输出是：

name = d

decl class = class field1

type = double

modifiers = private

—–

name = i

decl class = class field1

type = int

modifiers = public static final

—–

name = s

decl class = class field1

type = class java.lang.String

modifiers =

—–

和获取方法的情况一下，获取字段的时候也可以只取得在当前类中申明了的字段信息 (getDeclaredFields)，或者也可以取得父类中定义的字段 (getFields) 。
6.根据方法的名称来执行方法

文本到这里，所举的例子无一例外都与如何获取类的信息有关。我们也可以用 reflection 来做一些其它的事情，比如执行一个指定了名称的方法。下面的示例演示了这一操作：

import java.lang.reflect.*;
public class method2 {
public int add(int a, int b) {
return a + b;
}
public static void main(String args[]) {
try {
Class cls = Class.forName(“method2″);
Class partypes[] = new Class[2];
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
Method meth = cls.getMethod(“add”, partypes);
method2 methobj = new method2();
Object arglist[] = new Object[2];
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
Object retobj = meth.invoke(methobj, arglist);
Integer retval = (Integer) retobj;
System.out.println(retval.intValue());
} catch (Throwable e) {
System.err.println(e);
}
}
}

假如一个程序在执行的某处的时候才知道需要执行某个方法，这个方法的名称是在程序的运行过程中指定的 (例如，JavaBean 开发环境中就会做这样的事)，那么上面的程序演示了如何做到。

上例中，getMethod 用于查找一个具有两个整型参数且名为 add 的方法。找到该方法并创建了相应的 Method 对象之后，在正确的对象实例中执行它。执行该方法的时候，需要提供一个参数列表，这在上例中是分别包装了整数 37 和 47 的两个 Integer 对象。执行方法的返回的同样是一个 Integer 对象，它封装了返回值 84。

7.创建新的对象

对于构造器，则不能像执行方法那样进行，因为执行一个构造器就意味着创建了一个新的对象 (准确的说，创建一个对象的过程包括分配内存和构造对象)。所以，与上例最相似的例子如下：

import java.lang.reflect.*;

public class constructor2 {
public constructor2() {
}

public constructor2(int a, int b) {
System.out.println(“a = ” + a + ” b = ” + b);
}

public static void main(String args[]) {
try {
Class cls = Class.forName(“constructor2″);
Class partypes[] = new Class[2];
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
Constructor ct = cls.getConstructor(partypes);
Object arglist[] = new Object[2];
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
Object retobj = ct.newInstance(arglist);
} catch (Throwable e) {
System.err.println(e);
}
}
}

根据指定的参数类型找到相应的构造函数并执行它，以创建一个新的对象实例。使用这种方法可以在程序运行时动态地创建对象，而不是在编译的时候创建对象，这一点非常有价值。

8.改变字段(域)的值

reflection 的还有一个用处就是改变对象数据字段的值。reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它，下面的例子可以说明这一点：

import java.lang.reflect.*;

public class field2 {
public double d;

public static void main(String args[]) {
try {
Class cls = Class.forName(“field2″);
Field fld = cls.getField(“d”);
field2 f2obj = new field2();
System.out.println(“d = ” + f2obj.d);
fld.setDouble(f2obj, 12.34);
System.out.println(“d = ” + f2obj.d);
} catch (Throwable e) {
System.err.println(e);
}
}
}

这个例子中，字段 d 的值被变为了 12.34。

9.使用数组

本文介绍的 reflection 的最后一种用法是创建的操作数组。数组在 Java 语言中是一种特殊的类类型，一个数组的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的：

import java.lang.reflect.*;

public class array1 {
public static void main(String args[]) {
try {
Class cls = Class.forName(“java.lang.String”);
Object arr = Array.newInstance(cls, 10);
Array.set(arr, 5, “this is a test”);
String s = (String) Array.get(arr, 5);
System.out.println(s);
} catch (Throwable e) {
System.err.println(e);
}
}
}

例中创建了 10 个单位长度的 String 数组，为第 5 个位置的字符串赋了值，最后将这个字符串从数组中取得并打印了出来。

下面这段代码提供了一个更复杂的例子：

import java.lang.reflect.*;

public class array2 {
public static void main(String args[]) {
int dims[] = new int[]{5, 10, 15};
Object arr = Array.newInstance(Integer.TYPE, dims);
Object arrobj = Array.get(arr, 3);
Class cls = arrobj.getClass().getComponentType();
System.out.println(cls);
arrobj = Array.get(arrobj, 5);
Array.setInt(arrobj, 10, 37);
int arrcast[][][] = (int[][][]) arr;
System.out.println(arrcast[3][5][10]);
}
}
例中创建了一个 5 x 10 x 15 的整型数组，并为处于 [3][5][10] 的元素赋了值为 37。注意，多维数组实际上就是数组的数组，例如，第一个 Array.get 之后，arrobj 是一个 10 x 15 的数组。进而取得其中的一个元素，即长度为 15 的数组，并使用 Array.setInt 为它的第 10 个元素赋值。

注意创建数组时的类型是动态的，在编译时并不知道其类型。

MID（移动互连设备）是 PC 产品系列的一项最新创新，它具有 PC 的所有功能，但功耗却有明显的降低。鉴于 MID 的功能及用途，在设计用户界面（UI）时需要考虑到多方面的因素，以便为用户提供卓越的使用体验。本白皮书从总体上介绍了 MID 的 UI 设计规则。Hildon 用户界面以任务为导向，所以它需要一些特别的处理。本白皮书还介绍了 Hildon UI 设计的已知最佳方案（BKM）。

MID（移动互连设备）是 PC 产品系列的一项最新创新，它具有 PC 的所有功能，但功耗却有明显的降低。MID 是一种小外形（SFF）设备，它便于携带，可提供 24×7 全天候的数据访问功能。
英特尔一直致力于开发并推广各种技术，以满足 MID 用户的需求。在 MID 的创新过程中，英特尔最重要的一项贡献就是，通过其集成显卡驱动程序英特尔®图形媒体加速器，为用户提供了集成的显卡软件。
MID 一般采用尺寸较小（4.5” – 6”）的高分辨率触摸显示屏，并具有小型的键盘。为了给用户提供类似于 PC 的使用体验，MID 显示屏上的内容必须易于阅读，必须能够使用手指在显示屏上轻松进行操作，这也就是说，操作系统和应用的 UI 必须是高度定制的。

Linux 是一种开源操作系统，它允许在系统级别上进行高度的定制，例如快速启动、快速从待机模式恢复；在应用级别上，它还允许进行 UI 风格及主题方面的定制。 
Midinux 是首款基于 Linux 的操作系统，它完全支持英特尔 2007 MID 平台。它具有基于 GTK 的移动应用框架，专为 MID 的屏幕尺寸和分辨率而优化。图 1 显示了 MID 应用框架堆栈。 

图 1. MID 应用框架堆栈

2.1 Hildon 概览

Hildon 用户界面以及 Maemo 均基于开源组件。Hildon 以 Gnome 桌面使用的工具套件 GTK＋ 为基础，并在原有基础上进行了一些改进，使其更适合于移动设备。首款采用 Hildon UI 风格的产品为 Nokia 770 Internet Tablet。Hildon 用户界面主要以触摸屏操作为基础，这就意味着用户将主要通过手写笔和手指来使用设备。虽然设备上有几个强制性的硬件按钮，用户在大多数时间均通过触摸屏操作设备。Hildon 支持多任务处理，可以同时运行多个应用，并且用户可以在不同应用之间切换。 
Hildon UI 包含 4 个基本组件：任务导航条、标题区域、状态指示区域以及应用区域。任务导航条是位于屏幕上方的全局屏幕元素。任务导航条主要用于启动应用并在不同应用之间进行切换。标题区域包含应用的标题，该标题可打开应用特定的菜单。标题区域的右侧包含有最小化和关闭按钮。状态指示区域包含各种指示系统状态和行为的图标。状态条程序便位于该区域。应用区域由处于正常模式的应用使用。在全屏模式中，所有其它组件均会消失，应用区域会扩展至整个屏幕。

图 2 显示了 MID 应用 UI 的一般布局。

图 2. MID 应用 UI 布局

尽管 PC 架构以及全功能 PC 操作系统会降低开发人员将应用从桌面 PC 移植到 MID 的难度，MID 自身的外形仍为应用 UI 的设计提出了许多新的挑战。Hildon 应用框架是一种类似于设备的应用框架，这也给应用 UI 的设计带来了一些难题。

3.1．屏幕尺寸

由于 MID 的屏幕尺寸要远远小于传统屏幕尺寸，因此各种图形元素的尺寸就需要特殊处理。开发人员既要避免将按比例缩小的图形元素设计得过小，又要避免尺寸相同的图形元素占用太多的屏幕空间。具体来说，某些文本和图标可能比较难以辨认，屏幕上的按钮和单元可能不便于点击操作，一些游戏窗口可能无法放大到整个屏幕。

3.1.1．文本和图标尺寸

问题：在移植到 MID 的应用界面上，文本或图标可能会缩小到某个尺寸，这可能使文本或图标变得难以辨认。一个在 15 英寸屏幕上能够正常显示的文本，如果放到 MID 使用的 5 – 7 英寸的屏幕上，用户将很难看清文本的内容。除了文本的实际字体大小外，聊天和其它文本窗口也将变得过小。如果通过降低字体大小来适应较小的窗口尺寸，那么文本将变得非常难以阅读。

(a)

(b)

图 3. 适合于阅读的正常文本尺寸 (a) 与未经过合理的字体大小调整的文本 (b)。

最佳方案：理想情况下，针对 MID 设计的应用程序应尽量避免使用文本，此外，在选择字体时一定要考虑 MID 的屏幕尺寸。同样，图标设计上不应过分依赖于细节信息，这样，即便是在较小的 MID 屏幕上，也可以很容易地区分这些图标。在一些情况下，如果增大文本尺寸会对应用的其它元素造成影响，最佳的解决方案就是允许用户自行调整文本大小，根据他们自身的喜好来选择尺寸。

3.1.2．按钮与其它元素的可点击性

问题：与文本过小的问题类似，按钮和其它可点击的元素增加了将软件移植到 MID 的复杂性。由于在 PC上使用的是定位功能更加精确的鼠标，而在 MID 中使用的则是手写笔或手指，因此，尽管 MID 的整体界面必须小于标准的 PC 界面，但 MID 界面上的按钮却应比后者更大。即使用户在小心翼翼的情况下或许能够正确选择某个按钮，但这无疑会极大的影响用户体验。

图 4. 按钮的可点击性。在一个 20 英寸的 PC 显示器上（左），用户可以轻松使用鼠标指针选择一张骨牌。然而，在 5 英寸的 MID 显示屏上（右），选择某个骨牌就变得非常困难，甚至根本无法辨认骨牌上的点数。

最佳方案：与文本和图标尺寸的问题相同，开发人员应通过使用较大且易于辨认的按钮或其它元素来避免这一问题。各元素之间也必须留有足够的空隙，以避免用户无意中选择了错误的按钮。如果某个文本标签与按钮或其它元素相邻，该标签应该是元素的可点击区域的一部分，使按钮更加易于点击，并且不会占用额外的空间。

3.1.3．窗口大小

问题：如果应用窗口使用固定尺寸，而不是自动调整大小以适应整个屏幕，那么屏幕上的某些图像或元素将无法显示。MID 的宽屏一般使用 800×480 或 1024×600 的分辨率，这会使问题更加复杂，因为图像的宽高比必须与标准 PC 所采用的 4:3 的宽高比相匹配。

图 5. 窗口的可见度。在标准 PC 上（左），用户可以看到整个游戏区域，包括操作界面的信息区域。如果将窗口进行剪切，以适应 MID 更小的屏幕尺寸或其它宽高比（中），则如透明区域显示的那样，部分图像将无法显示出来。如果将图像按比例缩放到 MID 的屏幕尺寸（右），则基本上能看清所有图像，虽然有一定的图像扭曲，但仍在可以接受的范围内。

最佳方案：对于开发人员来说，解决这个问题的关键就是在开发 MID 用户界面时就应考虑 800×480 和 1024×600 的分辨率，可以缩小整个游戏窗口来适应屏幕，也可对界面进行重新安排，以充分利用宽屏的优势。例如，在某些情况下可提供滚动栏，允许用户手动或自动调整窗口来观看整个屏幕，从而提供可以接受的用户体验。

3.2．触摸屏

MID 使用的是触摸屏而非鼠标，这进一步增加了移植应用的复杂性。对于大多数软件操作而言，触摸屏的作用与鼠标类似，不同之处在于，用户拖动光标时产生的是线性的移动轨迹，而触摸屏产生的则是类似于点击按钮的操作效果。不点击就无法移动光标，以及左击与右击之间的关系也会导致一些问题。

3.2.1．准确解读触摸屏输入信息

问题：MID 应用必须能够将用户提供的光标输入理解为一系列的点（等同于一系列的触摸屏点击操作），而不需要线性的移动模式（如同用鼠标移动光标所产生的操作）。在某些应用中（例如第一人称射击游戏），如果需要将图像切换到用户的视角，以使光标始终处于屏幕中央，这种问题就会变得尤为明显。在这种情况下，当用户触摸屏幕时，光标可能会四处随意跳动，而不是移动到用户点触的位置。

最佳方案：如果游戏能够跟踪光标从 A 点到 B 点的移动，那么它应该将其理解为在 A 点和 B 点的两次点击，而不是在 A 点与 B 点之间移动。在 MID 上使用鼠标通常能够解决这个问题，但从用户体验的角度来看，这种解决方法显然不够理想。

3.2.2．精确的触摸屏映射

问题（窗口分辨率小于实际屏幕尺寸）：当应用在全屏模式下以小于实际屏幕尺寸的分辨率运行时，游戏会在屏幕中央显示，屏幕两侧将出现一定的空间（比如将 640×480 的窗口在 800×480 的屏幕上居中显示，或将 800×600 的窗口在 1024×600 的屏幕上居中显示时，屏幕两侧会留有黑色条形区域），当将整个触摸屏界面映射到相对较小的显示区域时，即会出现错误映射的问题。这种错误映射会导致界面对用户操作产生错误的响应，比如一个按钮的可点击区域与屏幕上显示的按钮位置不符。

图 6. 将游戏窗口居中显示时，屏幕两侧会留有空白区域，读取屏幕点触操作的游戏逻辑不能将整个屏幕区域映射到游戏窗口上。这种错误映射的结果就是，当点触屏幕上的一个位置时（黄色箭头指向的位置），而游戏逻辑却认为点触操作发生在另一个位置（红色星号的位置）。

最佳方案：在将应用居中显示，屏幕两侧留有空白区域时，只要映射逻辑能够将两侧的空白区域识别为屏幕本身的一部分，就不会出现错误映射的问题。通过这种调整，屏幕触摸会准确地映射到触摸位置。

问题（窗口分辨率大于实际屏幕尺寸）：如果窗口的纵向尺寸大于屏幕的实际尺寸，则可能发生纵向的错误映射问题。在这种情况下，触摸屏通常会映射到整个游戏窗口，而不是可显示的部分。这样，就会发生错误响应点触操作的现象。

图 7. 当游戏窗口在纵向上被部分剪切时（半透明区域），也同样会导致错误映射的问题，即点触一个位置（黄色箭头指向的位置），而游戏逻辑却认为点触发生在另一个位置（红色星号的位置）。

最佳方案：开发人员应确保操作系统将触摸屏准确地映射到屏幕的可视部分（包括游戏未使用的部分），但不应包括游戏窗口中不可视的部分。另一个解决方案则是，开发人员可将 800×480 和 1024×600 分辨率作为用户可配置的选项。在某些情况下，可以自动调整窗口大小，使其填充整个屏幕，前提是这种调整所产生的屏幕扭曲在可以接受的范围内。

3.2.3．悬停显示效果的替代方案

问题：许多游戏都具备悬停显示功能，用户在游戏中将光标放在某个对象或某个位置之上时（无需点击），即可触发信息提示或工具选项。该功能通常用来为新手玩家提供指导，但是它与触摸屏并不兼容，因为触摸屏无法在不点击的情况下移动光标。

图 8. 悬停显示效果。

最佳方案：由于悬停显示功能与目前的 MID 硬件不兼容，开发人员必须选择其它事件来触发动画或工具提示。例如，当玩家到达与动画对象或工具提示对象相关的游戏环节时，便能触发动画或工具提示。另一种方法则是设计一个界面，借助某种手段临时将点击事件解释为鼠标悬停事件，例如按住某个按钮，便可点击触摸屏移动光标，而不会产生点击操作。

3.2.4．兼容右击功能

问题：在典型的 MID 触摸屏上，用户通过在屏幕上进行稍长时间的点击来启用右键功能，但这可能会导致用户意外进行左击操作。此外，无法同时实现左击和右击操作。

最佳方案：开发人员应提供其它的用户交互来代替右击功能，如在屏幕上使用双击或添加可点击的控制按钮。游戏开发人员也可要求用户使用外接鼠标或其它指点设备，虽然这会影响用户体验。

3.3．外形

许多问题都直接来自于 MID 与标准 PC 的硬件差异。例如，与 PC 不同，MID 可能具有触摸屏、操纵杆、用户可定义的按钮和“菜单”按钮等专用按钮，但通常不具备键盘或 CD-ROM 光驱。虽然可以添加键盘、光驱或其它外设，但这会降低 MID 的便携性。此外，不同型号的 MID 会在其设计中包含不同的元素，因此每种设备在外形方面的局限性会有所不同。这种变化通常要求开发人员在按照核心要求设计应用时，重点考虑硬件特性的最低水平。

3.3.1．尽量减少命令输入

问题：相对于标准 PC 提供的键盘和鼠标而言，MID 的外形对输入方式造成了许多限制。即使某些游戏是使用游戏手柄在电脑上操纵的，但是它还需要使用手柄上的许多其它功能按钮，而这在 MID 上是无法实现的。另外，如果某个游戏将键盘的快捷键作为游戏的主要操作途径，则 MID 也会存在一些问题。然而，主要由鼠标进行操作的游戏则不受 MID 外形的影响。

最佳方案：开发人员应减少进行游戏所需的命令数量，以此解决 MID 输入方式有限的问题。但是，更灵活的解决方案则是创建屏幕按钮。特别是提供那些与环境相关的按钮，仅在游戏需要时才会出现，这就提供了一种开放的解决方案，有效解决输入方面的问题。

3.3.2．解决键盘问题

问题：除发出命令外，许多游戏还要求使用键盘来输入信息，如为人物命名、创建人物资料、保存游戏或在线聊天等。通常，大多数游戏在登录时都需要使用键盘输入人物名称，但在其它时刻都不需要使用键盘。某些游戏还要求玩家使用键盘来命名保存的游戏。在许多情况下，屏幕键盘不会出现在游戏界面上，因此无法解决这些问题。

最佳方案：开发人员在设计游戏时应避免其与屏幕键盘产生冲突（例如，不将游戏默认设置为全屏模式），或者将游戏设计为仅在需要时，才会在界面上提供屏幕键盘。有一种简单的方法可用来减少键盘输入，即提供诸如人物名称、保存游戏名称等文本字符串的默认值，并允许使用屏幕选项来选择这些值。这些文本字符串的其它值也可通过添加界面按钮来提供，使用该界面按钮可随机在开发人员创建的人物名单中选择新值。也可根据玩家游戏结束时的屏幕截图，以及日期与时戳来识别保存的游戏。由于聊天功能通常不是游戏的核心内容，所以在 MID 中一般都会禁用该功能，并且不会对用户体验造成影响。

图 9. 全屏模式下显示的屏幕键盘。

4. Hildon UI 设计的 BKM

Hildon 用户界面是以任务为导向的，这就意味着它可以实现与专用和优化的应用和功能集类似的普通任务。例如，仅仅通过 2 次点击就可以打开书签中保存的网站，或发送新的电子邮件。

PC 所采用的基于鼠标和键盘的交互模式与 Hildon 交互模式有许多区别，在设计用户界面时必须充分考虑这些因素。当用户在行走时，要准确地点触某个屏幕按钮可能会比较困难。用户的手还可能会挡住屏幕的部分区域（UI 控制按钮或内容等）。因此要优化 UI 设计，仅使用少数几个操作即可完成一项任务，避免给用户带来不必要的麻烦。UI 上的任务流应遵循标准的操作流程，比如从左到右、从上到下，而非强迫用户在各个界面进行操作。

4.1 Hildonized 与 Un-Hildonized UI

由于 MID 的应用框架以 GTK 为基础，这就意味着以 GTK 为基础编写的应用所需的移植工作会相对较少，但是 Hildon UI 的各种工具条按钮会更大一些，方便用户使用手指进行操作。以下 2 个截屏显示了经过与未经过 Hildon UI 改进的两种界面。

图 10. 未经过 Hildon 改进的 UI

图 11. 经过 Hildon 改进的 UI

4.2 菜单

菜单命令应根据它们的重要性和功能关系进行安排。如果有许多命令，可将功能比较相近的命令分组到一个子菜单，在第一级菜单上仅使用子菜单标题，比如：’文件’->’新建’ 以及 ‘文件’->’保存’。

在 Hildon UI 中，菜单项是纵向排列的，这与 PC 环境中横向排列方式不同。最常用的命令或子菜单应位于菜单的前几级，不太重要的可以设计在下方，以便于用户操作。使用分隔符在菜单内对相关的菜单项进行分组。在纵向上，应避免超过 7 行命令或子菜单，在横向上应避免超过 3 列菜单。

当前无法使用的命令应呈灰色显示。Hildon 的一项特有功能就是它会对选择灰色菜单项的操作进行响应，通常会弹出一条信息，解释为什么该功能无法使用，比如“没有可以撤销的内容”。这样，用户便可以按正确的方法使用应用。

对于第一个应用菜单标题，应使用一个可以反映应用功能的词语，比如“文档”、“图像”、“卡片”，而不是“文件”。

图 12. Midinux 中的菜单。

4.3 工具条

工具条应能使用户轻松地访问应用的常用或重要功能。以下是设计和使用工具条的一些规则。

工具条中项目的数量取决于每个项的宽度以及是否会显示任务导航条（从普通屏幕切换到全屏幕）。

• 如果应用使用多个视图，则可以考虑改变并优化每个视图中工具条上显示的功能。
• 应该为应用的基本功能提供一些最常见的图标。
• 工具条图标必须直观易懂，能够直接反映出它们代表的操作。图标形象应从日常生活中取材，以便用户将其与设备上的任务联系起来。
• 应用菜单上应包含所有显示的命令。
• 由于屏幕空间有限，应该提供在菜单中隐藏某个工具条的功能。
• 必要时，应使用分隔符标记分组图标。
• 应避免在工具条上使用需要本地化的文本，因为不同的文本长度会打乱工具条的布局。可能的话，应尽量使用图标来代替文本，以节省工具条空间。

图 13. Midinux 中的工具条。（浏览器、播放器、E-mail、GPS、Office 工具、电话簿…）

4.4 对话框

可使用各种对话框来指引用户完成某个任务。应尽量使任务变得简单，避免设置一长串的对话框。对于那些比较复杂的任务，可以设置一个新的窗口。如果该任务需要来自其它应用的信息，并且没有将信息作为预设的列表提供，则建议将其作为一个新窗口实施，而非对话框。对话框显示在应用区域的中央

图 14. office工具中的对话框。

4.5 通知

通知用于向用户反馈信息。有 2 种类型的通知：消息框或信息条。 
消息框一般显示在屏幕的中央并包含简短的信息，同时提供按钮供用户作出响应。在用户对注释中的信息进行确认之前，应用处于暂停状态。
信息条不需要用户执行任何操作。它们显示在应用区域的右上角。 
图 15 显示了消息框和信息条的差别。

图 15. 消息框（左）和信息条（右）

总结

本文针对 MID 的 UI 设计提出了一些主要问题，并针对屏幕尺寸、触摸屏以及外形方面的因素提供了 UI 设计的方案。由于 Hildon 用户界面是以任务为导向的，所以它需要一些特别的考虑。本白皮书还提供了 Hildon UI 设计的已知最佳方案（BKM）。

参考文档

[1] Best Practices in Game Design for the Ultra-Mobile PC. Matt Gillespie, Michael Finkel and Victoria Bailey

[2] Hildon User Interface Style Guide Summary Version 1.1. 

[3] MID Application UI Design Guide.

http://software.intel.com/zh-cn/articles/best-known-methods-of-ui-design-for-mid/

]]>

1. 命令-也就是envsetup.sh中的函数

function help() 　　　　　　　　　　　　　　　　　　# 显示帮助信息
function get_abs_build_var()　　　　　　　　　　　# 获取绝对变量
function get_build_var()　　　　　　　　　　　　　 # 获取绝对变量
function check_product()　　　　　　　　　　　　　# 检查product
function check_variant()　　　　　　　　　　　　　 # 检查变量
function setpaths()　　　　　　　　　　　　　　　　# 设置文件路径
function printconfig()　　　　　　　　　　　　　　　# 打印配置
function set_stuff_for_environment()　　　　　　  # 设置环境变量
function set_sequence_number()　　　　　　　　  # 设置序号
function settitle()　　　　　　　　　　　　　　　　  # 设置标题
function choosetype()　　　　　　　　　　　　　　 # 设置type
function chooseproduct()　　　　　　　　　　　　  # 设置product
function choosevariant()　　　　　　　　　　　　   # 设置variant
function tapas()　　　　　　　　　　　　　　　　    # 功能同choosecombo
function choosecombo()　　　　　　　　　　　　　# 设置编译参数
function add_lunch_combo()　　　　　　　　　　　# 添加lunch项目
function print_lunch_menu()　　　　　　　　　　　# 打印lunch列表
function lunch()　　　　　　　　　　　　　　　　　 # 配置lunch
function m()　　　　　　　　　　　　　　　　　　　# make from top
function findmakefile()　　　　　　　　　　　　　　# 查找makefile
function mm()　　　　　　　　　　　　　　　　　　# make from current directory
function mmm()　　　　　　　　　　　　　　　　　# make the supplied directories
function croot()　　　　　　　　　　　　　　　　　# 回到根目录
function cproj()
function pid()
function systemstack()
function gdbclient()
function jgrep()　　　　　　　　　　　　　　　　　# 查找java文件
function cgrep()　　　　　　　　　　　　　　　　  # 查找c/cpp文件
function resgrep()
function tracedmdump()
function runhat()
function getbugreports()
function startviewserver()
function stopviewserver()
function isviewserverstarted()
function smoketest()
function runtest()
function godir () 　　　　　　　　　　　　　　　　 # 跳到指定目录

# add the default one here
add_lunch_combo generic-eng

# Execute the contents of any vendorsetup.sh files we can find.
for f in `/bin/ls vendor/*/vendorsetup.sh vendor/*/build/vendorsetup.sh 2> /dev/null`
do
echo “including $f”
. $f
done

2. lunch命令

已经有人分析过了，直接搬过来：

http://www.lupaworld.com/home.php?mod=space&uid=131820&do=blog&id=149462

这里说一下check_product的流程：

待续

3. choosecombo

待续

http://www.cnblogs.com/cnhome/archive/2010/07/24/1784382.html

按键事件

对于按键事件，调用mDevices->layoutMap->map进行映射。映射实际是由 KeyLayoutMap::map完成的，KeyLayoutMap类里读取配置文件qwerty.kl，由配置 文件 qwerty.kl 决定键值的映射关系。你可以通过修 改./development/emulator/keymaps/qwerty.kl来改变键值的映射关系。

JNI 函数
在frameworks/base/services/jni/com_android_server_KeyInputQueue.cpp文 件中，向 JAVA提供了函数android_server_KeyInputQueue_readEvent，用于读 取输入设备事件。 
C代码：

static jboolean android_server_KeyInputQueue_readEvent(JNIEnv* env, jobject clazz,
jobject event)
{
gLock.lock();
sp hub = gHub;
if (hub == NULL) {
hub = new EventHub;
gHub = hub;
}
gLock.unlock();
int32_t deviceId;
int32_t type;
int32_t scancode, keycode;
uint32_t flags;
int32_t value;
nsecs_t when;
bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode,
&flags, &value, &when);
env->SetIntField(event, gInputOffsets.mDeviceId, (jint)deviceId);
env->SetIntField(event, gInputOffsets.mType, (jint)type);
env->SetIntField(event, gInputOffsets.mScancode, (jint)scancode);
env->SetIntField(event, gInputOffsets.mKeycode, (jint)keycode);
env->SetIntField(event, gInputOffsets.mFlags, (jint)flags);
env->SetIntField(event, gInputOffsets.mValue, value);
env->SetLongField(event, gInputOffsets.mWhen,
(jlong)(nanoseconds_to_milliseconds(when)));
return res;
}

readEvent调用hub->getEvent读了取事件，然后转换成JAVA的结构。

事件中转线程
在frameworks/base/services/java/com/android/server/KeyInputQueue.java 里创建了一个线程，它循环的读取事件，然后把事件放入事件队列里。
Java代码:

Thread mThread = new Thread(“InputDeviceReader”) {
public void run() {
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY);

try {
RawInputEvent ev = new RawInputEvent();
while (true) {
InputDevice di;

// block, doesn’t release the monitor
readEvent(ev);

boolean send = false;
boolean configChanged = false;

if (false) {
Log.i(TAG, “Input event: dev=0x”
+ Integer.toHexString(ev.deviceId)
+ ” type=0x” + Integer.toHexString(ev.type)
+ ” scancode=” + ev.scancode
+ ” keycode=” + ev.keycode
+ ” value=” + ev.value);
}

if (ev.type == RawInputEvent.EV_DEVICE_ADDED) {
synchronized (mFirst) {
di = newInputDevice(ev.deviceId);
mDevices.put(ev.deviceId, di);
configChanged = true;
}
}

……

}

}

}

};

按键、触摸屏流、轨迹球程分析

输入事件分发线程
在frameworks/base/services/java/com/android/server/WindowManagerService.java里创建了一个输入事件分发线程，它负责把事件分发到相应的窗口上去。

按键触摸屏流程分析:

WindowManagerService类的构造函数

WindowManagerService()

mQueue = new KeyQ();

因为 WindowManagerService.java (frameworks\base\services\java\com\android\server)中有：

private class KeyQ extends KeyInputQueue implements KeyInputQueue.FilterCallback

KeyQ 是抽象类 KeyInputQueue 的实现，所以 new KeyQ类的时候实际上在 KeyInputQueue 类中创建了一个线程 InputDeviceReader 专门用来从设备读取按键事件，

代码：

readEvent() 实际上调用的是 com_android_server_KeyInputQueue.cpp (frameworks\base\services\jni)中的

static jboolean android_server_KeyInputQueue_readEvent(JNIEnv* env, jobject clazz,jobject event) 来读取事件，

bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode,&flags, &value, &when)调用的是EventHub.cpp (frameworks\base\libs\ui)中的：

bool EventHub::getEvent (int32_t* outDeviceId, int32_t* outType,

int32_t* outScancode, int32_t* outKeycode, uint32_t *outFlags,

int32_t* outValue, nsecs_t* outWhen)

在函数中调用了读设备操作：res = read(mFDs.fd, &iev, sizeof(iev));

在构造函数 WindowManagerService()调用 new KeyQ() 以后接着调用了：

mInputThread = new InputDispatcherThread();
…

mInputThread.start();

来启动一个线程 InputDispatcherThread

run()
process();
QueuedEvent ev = mQueue.getEvent(…)

因为WindowManagerService类中： final KeyQ mQueue;

所以实际上 InputDispatcherThread 线程实际上从 KeyQ 的事件队列中读取按键事件，在process() 方法中进行处理事件。

switch (ev.classType)
case RawInputEvent.CLASS_KEYBOARD:
…
dispatchKey((KeyEvent)ev.event, 0, 0);
mQueue.recycleEvent(ev);
break;
case RawInputEvent.CLASS_TOUCHSCREEN:
//Log.i(TAG, “Read next event ” + ev);
dispatchPointer(ev, (MotionEvent)ev.event, 0, 0);
break;

case RawInputEvent.CLASS_TRACKBALL:
dispatchTrackball(ev, (MotionEvent)ev.event, 0, 0);
break;

===============================================================

补充一些内容：

在写程序时，需要捕获KEYCODE_HOME、KEYCODE_ENDCALL、KEYCODE_POWER这几个按键，但是这几个按键系统做了特殊处理，

在进行dispatch之前做了一些操作，HOME除了Keygaurd之外，不分发给任何其他APP，ENDCALL和POWER也类似，所以需要我们系统

处理之前进行处理。

我的做法是自己定义一个FLAG，在自己的程序中添加此FLAG，然后在WindowManagerServices.java中获取当前窗口的FLAG属性，如果是我

们自己设置的那个FLAG，则不进行特殊处理，直接分发按键消息到我们的APP当中，由APP自己处理。

这部分代码最好添加在

@Override
boolean preprocessEvent(InputDevice device, RawInputEvent event)

方法中，这个方法是KeyInputQueue中的一个虚函数，在处理按键事件之前的一个“预处理”。

PS:对HOME键的处理好像必需要修改PhoneWindowManager.java中的interceptKeyTi方法，具体可以参考对KeyGuard程序的处理。

===============================================================

系统底层事件处理过程

在系统启动后，android 会通过

static const char *device_path = “/dev/input”;

bool EventHub::penPlatformInput(void)

res = scan_dir(device_path);

通过下面的函数打开设备。

int EventHub::pen_device(const char *deviceName)
{
…
fd = open(deviceName, O_RDWR);
…
mFDs[mFDCount].fd = fd;
mFDs[mFDCount].events = POLLIN;
…
ioctl(mFDs[mFDCount].fd, EVIOCGNAME(sizeof(devname)-1), devname);
…
const char* root = getenv(“ANDROID_ROOT“);
snprintf(keylayoutFilename, sizeof(keylayoutFilename),
“%s/usr/keylayout/%s.kl“, root, tmpfn);
…
device->layoutMap->load(keylayoutFilename);
…
}

打开设备的时候，如果 device->classes&CLASS_KEYBOARD 不等于 0 表明是键盘。

常用输入设备的定义有：

enum {
CLASS_KEYBOARD      = 0×00000001, //键盘

CLASS_ALPHAKEY      = 0×00000002, //

CLASS_TOUCHSCREEN   = 0×00000004, //触摸屏

CLASS_TRACKBALL     = 0×00000008 //轨迹球
};

打开键盘设备的时候通过上面的 ioctl 获得设备名称，命令字 EVIOCGNAME 的定义在文件：

kernel/include/linux/input.h 中。

#define EVIOCGNAME(len)   _IOC(_IOC_READ, ‘E’, 0×06, len) /* get device name */

在内核键盘驱动文件 drivers/input/keyboard/pxa27x_keypad.c 中定义了设备名称：pxa27x-keypad

static struct platform_driver pxa27x_keypad_driver = {

.probe        = pxa27x_keypad_probe,

.remove        = __devexit_p(pxa27x_keypad_remove),

.suspend    = pxa27x_keypad_suspend,

.resume        = pxa27x_keypad_resume,

.driver        = {

.name    = “pxa27x-keypad”,

.owner    = THIS_MODULE,

},

};

ANDROID_ROOT 为环境变量，在android的命令模式下通过 printenv 可以知道它为： system

所以 keylayoutFilename 为：/system/usr/keylayout/pxa27x-keypad.kl

pxa27x-keypad.kl 定义了按键映射，具体内容如下：

# NUMERIC KEYS 3×4
key 2 1
key 3 2
key 4 3
key 5 4
key 6 5
key 7 6
key 8 7
key 9 8
key 10 9
key 11 0
key 83 POUND
key 55 STAR

# FUNCTIONAL KEYS
key 231 MENU        WAKE_DROPPED
key 192 BACK           WAKE_DROPPED
key 193 HOME       WAKE
key 107 DEL        WAKE
key 102 CALL        WAKE_DROPPED
key 158 ENDCALL     WAKE_DROPPED
key 28 DPAD_CENTER     WAKE
key 115 VOLUME_UP
key 114 VOLUME_DOWN

如果没有定义键盘映射文件，那么默认使用系统的 /system/usr/keylayout/qwerty.kl 可以修改 /system/usr/keylayout/qwerty.kl 文件改变Android公司的按键映射。

device->layoutMap->load(keylayoutFilename) 调用的是文件 KeyLayoutMap.cpp (frameworks\base\libs\ui)中的函数：

status_t KeyLayoutMap::load(const char* filename)通过解析 pxa27x-keypad.kl
把按键的映射关系保存在 ：KeyedVector<int32_t,Key> m_keys; 中。

当获得按键事件以后调用：
status_t KeyLayoutMap::map(int32_t scancode, int32_t *keycode, uint32_t *flags)

由映射关系 KeyedVector<int32_t,Key> m_keys 把扫描码转换成andorid上层可以识别的按键。