android应用程序的混淆打包
1 . 在工程文件project.properties中加入下proguard.config=proguard.cfg ， 如下所示：
target=android-8

proguard.config=proguard.cfg

Eclipse会通过此配置在工程目录生成proguard.cfg文件

 2 . 生成keystore (如已有可直接利用)

按照下面的命令行 在D:\Program Files\Java\jdk1.6.0_07\bin>目录下，输入keytool -genkey -alias android.keystore -keyalg RSA -validity 100000 -keystore android.keystore

参数意义：-validity主要是证书的有效期，写100000天；空格，退格键 都算密码。

命令执行后会在D:\Program Files\Java\jdk1.6.0_07\bin>目录下生成 android.keystore文件。

 3. 在Eclipce的操作

File -> Export -> Export Android Application -> Select project -> Using the existing keystore , and input password -> select the destination APK file 

 经过混淆后的源代码，原先的类名和方法名会被类似a,b,c。。。的字符所替换，混淆的原理其实也就是类名和方法名的映射。



proguard 自己考一个就行
----------------------------------------------------------------------------------------

proguard 原理
Java代码编译成二进制class 文件，这个class 文件也可以反编译成源代码 ，除了注释外，原来的code 基本都可以看到。为了防止重要code 被泄露，我们往往需要混淆（Obfuscation code ， 也就是把方法，字段，包和类这些java 元素的名称改成无意义的名称，这样代码结构没有变化，还可以运行，但是想弄懂代码的架构却很难。 proguard 就是这样的混淆工具，它可以分析一组class 的结构，根据用户的配置，然后把这些class 文件的可以混淆java 元素名混淆掉。在分析class 的同时，他还有其他两个功能，删除无效代码（Shrinking 收缩），和代码进行优化 （Optimization Options）。
缺省情况下，proguard 会混淆所有代码，但是下面几种情况是不能改变java 元素的名称，否则就会这样就会导致程序出错。
一， 我们用到反射的地方。
二， 我们代码依赖于系统的接口，比如被系统代码调用的回调方法，这种情况最复杂。
三， 是我们的java 元素名称是在配置文件中配置好的。
所以使用proguard时，我们需要有个配置文件告诉proguard 那些java 元素是不能混淆的。

proguard 配置
最常用的配置选项
-dontwarn 缺省proguard 会检查每一个引用是否正确，但是第三方库里面往往有些不会用到的类，没有正确引用。如果不配置的话，系统就会报错。
-keep 指定的类和类成员被保留作为 入口 。
-keepclassmembers 指定的类成员被保留。
-keepclasseswithmembers 指定的类和类成员被保留，假如指定的类成员存在的话。

proguard 问题和风险
代码混淆后虽然有混淆优化的好处，但是它往往也会带来如下的几点问题
1，混淆错误，用到第三方库的时候，必须告诉 proguard 不要检查，否则proguard 会报错。
2，运行错误，当code 不能混淆的时候，我们必须要正确配置，否则程序会运行出错，这种情况问题最多。
3，调试苦难，出错了，错误堆栈是混淆后的代码 ，自己也看不懂。


为了防止混淆出问题，你需要熟悉你所有的code ，系统的架构 ，以及系统和你code的集成的接口，并细心分析。 同时你必须需要一轮全面的测试。 所以混淆也还是有一定风险的。 为了避免风险，你可以只是混淆部分关键的代码，但是这样你的混淆的效果也会有所降低。

常见的不能混淆的androidCode
Android 程序 ，下面这样代码混淆的时候要注意保留。
Android系统组件，系统组件有固定的方法被系统调用。
被Android Resource 文件引用到的。名字已经固定，也不能混淆，比如自定义的View 。
Android Parcelable ，需要使用android 序列化的。
其他Anroid 官方建议 不混淆的，如
android.app.backup.BackupAgentHelper
android.preference.Preference
com.android.vending.licensing.ILicensingService
Java序列化方法，系统序列化需要固定的方法。
枚举 ，系统需要处理枚举的固定方法。
本地方法，不能修改本地方法名
annotations 注释
数据库驱动
有些resource 文件
用到反射的地方


如何实施
现在的系统已经配置为混淆时候会保留
Android系统组件
自定义View
Android Parcelable
Android R 文件
Android Parcelable
枚举
各个开发人员必须检查自己的code 是否用到反射 ，和其他不能混淆的地方。告诉我来修改配置文件（已经保留的就不需要了）


目前系统部检查的第三方库为
-dontwarn android.support.**
-dontwarn com.tencent.**
-dontwarn org.dom4j.**
-dontwarn org.slf4j.**
-dontwarn org.http.mutipart.**
-dontwarn org.apache.**
-dontwarn org.apache.log4j.**
-dontwarn org.apache.commons.logging.**
-dontwarn org.apache.commons.codec.binary.**
-dontwarn weibo4android.**
proguard 参数
-include {filename}    从给定的文件中读取配置参数 

-basedirectory {directoryname}    指定基础目录为以后相对的档案名称 

-injars {class_path}    指定要处理的应用程序jar,war,ear和目录 

-outjars {class_path}    指定处理完后要输出的jar,war,ear和目录的名称 

-libraryjars {classpath}    指定要处理的应用程序jar,war,ear和目录所需要的程序库文件 

-dontskipnonpubliclibraryclasses    指定不去忽略非公共的库类。 

-dontskipnonpubliclibraryclassmembers    指定不去忽略包可见的库类的成员。 


保留选项 
-keep {Modifier} {class_specification}    保护指定的类文件和类的成员 

-keepclassmembers {modifier} {class_specification}    保护指定类的成员，如果此类受到保护他们会保护的更好

-keepclasseswithmembers {class_specification}    保护指定的类和类的成员，但条件是所有指定的类和类成员是要存在。 

-keepnames {class_specification}    保护指定的类和类的成员的名称（如果他们不会压缩步骤中删除） 

-keepclassmembernames {class_specification}    保护指定的类的成员的名称（如果他们不会压缩步骤中删除） 

-keepclasseswithmembernames {class_specification}    保护指定的类和类的成员的名称，如果所有指定的类成员出席（在压缩步骤之后） 

-printseeds {filename}    列出类和类的成员-keep选项的清单，标准输出到给定的文件 

压缩 
-dontshrink    不压缩输入的类文件 

-printusage {filename} 

-whyareyoukeeping {class_specification}     

优化 
-dontoptimize    不优化输入的类文件 

-assumenosideeffects {class_specification}    优化时假设指定的方法，没有任何副作用 

-allowaccessmodification    优化时允许访问并修改有修饰符的类和类的成员 

混淆 
-dontobfuscate    不混淆输入的类文件 

-printmapping {filename} 

-applymapping {filename}    重用映射增加混淆 

-obfuscationdictionary {filename}    使用给定文件中的关键字作为要混淆方法的名称 

-overloadaggressively    混淆时应用侵入式重载 

-useuniqueclassmembernames    确定统一的混淆类的成员名称来增加混淆 

-flattenpackagehierarchy {package_name}    重新包装所有重命名的包并放在给定的单一包中 

-repackageclass {package_name}    重新包装所有重命名的类文件中放在给定的单一包中 

-dontusemixedcaseclassnames    混淆时不会产生形形色色的类名 

-keepattributes {attribute_name,...}    保护给定的可选属性，例如LineNumberTable, LocalVariableTable, SourceFile, Deprecated, Synthetic, Signature, and InnerClasses. 

-renamesourcefileattribute {string}    设置源文件中给定的字符串常量

解决export打包的报错
这个时候export提示“conversion to Dalvik format failed with error 1”错误，网上说法有好多种，最后我还是把proguard从4.4升级到4.8就解决了。官方地址是http://proguard.sourceforge.net。上面的配置文件参数可以在这里查阅。
升级办法很简单，就是把android sdk目录下的tool/proguard目录覆盖一下即可。

打包出来的程序如何调试
一旦打包出来，就不能用eclipse的logcat去看了，这里可以用android sdk中ddms.bat的tool来看，一用就发现和logcat其实还是一个东西，就是多了个设备的选择。

使用 gson 需要的配置
当Gson用到了泛型就会有报错，这个真给郁闷了半天，提示“Missing type parameter”。最后找到一个资料给了一个解决办法，参考：http://stackoverflow.com/questio ... sing-type-parameter。
另外我又用到了JsonObject，提交的Object里面的members居然被改成了a。所以上面给的东西还不够，还要加上
# 用到自己拼接的JsonObject
-keep class com.google.gson.JsonObject { *; }


个人建议减少这些依赖包混淆带来的麻烦，干脆都全部保留不混淆。例如
-keep class com.badlogic.** { *; }
-keep class * implements com.badlogic.gdx.utils.Json*
-keep class com.google.** { *; }

使用libgdx需要的配置
参考http://code.google.com/p/libgdx-users/wiki/Ant


验证打包效果
利用了apktool的反编译工具，把打包文件又解压了看了一下，如果包路径、类名、变量名、方法名这些变化和你期望一致，那就OK了。命令：


apktool.bat d xxx.apk destdir

配置实例
-injars  androidtest.jar【jar包所在地址】 
-outjars  out【输出地址】
-libraryjars    'D:\android-sdk-windows\platforms\android-9\android.jar' 【引用的库的jar，用于解析injars所指定的jar类】

-optimizationpasses 5
-dontusemixedcaseclassnames 【混淆时不会产生形形色色的类名 】
-dontskipnonpubliclibraryclasses 【指定不去忽略非公共的库类。 】
-dontpreverify 【不预校验】
-verbose
-optimizations !code/simplification/arithmetic,!field/*,!class/merging/* 【优化】
-keep public class * extends android.app.Activity　　【不进行混淆保持原样】
-keep public class * extends android.app.Application
-keep public class * extends android.app.Service
-keep public class * extends android.content.BroadcastReceiver
-keep public class * extends android.content.ContentProvider
-keep public class * extends android.app.backup.BackupAgentHelper
-keep public class * extends android.preference.Preference
-keep public class com.android.vending.licensing.ILicensingService
-keep public abstract interface com.asqw.android.Listener{
public protected ;  【所有方法不进行混淆】
}
-keep public class com.asqw.android{
public void Start(java.lang.String); 【对该方法不进行混淆】
}
-keepclasseswithmembernames class * { 【保护指定的类和类的成员的名称，如果所有指定的类成员出席（在压缩步骤之后）】
native ;
}
-keepclasseswithmembers class * { 【保护指定的类和类的成员，但条件是所有指定的类和类成员是要存在。】
public (android.content.Context, android.util.AttributeSet);
}
-keepclasseswithmembers class * {
public (android.content.Context, android.util.AttributeSet, int);
}
-keepclassmembers class * extends android.app.Activity {【保护指定类的成员，如果此类受到保护他们会保护的更好 】
public void *(android.view.View);
}
-keepclassmembers enum * {
public static **[] values();
public static ** valueOf(java.lang.String);
}
-keep class * implements android.os.Parcelable {【保护指定的类文件和类的成员】
public static final android.os.Parcelable$Creator *;

有时会从其他的文件浏览器获取路径，这时根据路径去数据库取文件时会发现不成功，原因是由于android的文件浏览器太多，各自返回的路径不统一，而android本身的数据库中的路径是绝对路径，即"/mnt"开头的路径。

private String getRealPath(Uri fileUrl){
String fileName = null;
Uri filePathUri = fileUrl;
if(fileUrl!= null){
if (fileUrl.getScheme().toString().compareTo("content")==0) //content://开头的uri
{ 
Cursor cursor = mContext.getContentResolver().query(videoUrl, null, null, null, null);
if (cursor != null && cursor.moveToFirst())
{
int column_index = cursor.getColumnIndexOrThrow(***.***.***.DATA);
fileName = cursor.getString(column_index); //取出文件路径
if(!fileName.startsWith("/mnt")){
//检查是否有”/mnt“前缀

fileName = "/mnt" + fileName; 
}
cursor.close();
}
}else if (videoUrl.getScheme().compareTo("file")==0) //file:///开头的uri
{
fileName = filePathUri.toString();
fileName = filePathUri.toString().replace("file://", "");
//替换file://
if(!fileName.startsWith("/mnt")){
//加上"/mnt"头
fileName += "/mnt"; 
}
}
}
return fileName;
}
-----------------------------


Uri uri = data.getData();
String[] proj = { MediaStore.Images.Media.DATA };
Cursor actualimagecursor = managedQuery(uri,proj,null,null,null);
int actual_image_column_index = actualimagecursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
actualimagecursor.moveToFirst();
String img_path = actualimagecursor.getString(actual_image_column_index);
File file = new File(img_path);

可以通过获取

mProfile.videoCodec 获取视频编码格式：0：default； 1：H.263； 2：H.264； 3：MPEG_4_SP

具体参考SDK文档说明：CamcorderProfile，里面包含了视频录制的参数列表


每个手机都有自己支持的一套编码参数，你要设置前要先获取当前摄像头支不支持你设置的参数，不然都会出现设置无效录像失败！
通过CamcorderProfile 中的public static CamcorderProfile get (int quality)或者public static CamcorderProfile get (int cameraId, int quality)可以获取
当前支持的编码参数：int quality在4.0中的值有
QUALITY_LOW
QUALITY_HIGH
QUALITY_QCIF
QUALITY_CIF
QUALITY_480P
QUALITY_720P
QUALITY_1080P
QUALITY_TIME_LAPSE_LOW
QUALITY_TIME_LAPSE_HIGH
QUALITY_TIME_LAPSE_QCIF
QUALITY_TIME_LAPSE_CIF
QUALITY_TIME_LAPSE_480P
QUALITY_TIME_LAPSE_720P
QUALITY_TIME_LAPSE_1080P
只要获取到是摄像头支持的编码参数都可以进行设置

你还可以通过 Camera.Parameters 这个类里面的函数获取系统摄像头支持的设置：
List<String>         getSupportedAntibanding()  //Gets the supported antibanding values.
List<String>         getSupportedColorEffects() //Gets the supported color effects.
List<String>         getSupportedFlashModes() //Gets the supported flash modes.
List<String>         getSupportedFocusModes() //Gets the supported focus modes.
List<Camera.Size>         getSupportedJpegThumbnailSizes() //Gets the supported jpeg thumbnail sizes.
List<Integer>         getSupportedPictureFormats() //Gets the supported picture formats.
List<Camera.Size>         getSupportedPictureSizes() //Gets the supported picture sizes.
List<Integer>         getSupportedPreviewFormats() //Gets the supported preview formats.
List<int[]>         getSupportedPreviewFpsRange() //Gets the supported preview fps (frame-per-second) ranges.
List<Integer>         getSupportedPreviewFrameRates() //This method is deprecated. replaced by getSupportedPreviewFpsRange()
List<Camera.Size>         getSupportedPreviewSizes() //Gets the supported preview sizes.
List<String>         getSupportedSceneModes() //Gets the supported scene modes.
List<Camera.Size>         getSupportedVideoSizes() //Gets the supported video frame sizes that can be used by MediaRecorder.
List<String>         getSupportedWhiteBalance()

如果这里获取不到你要的参数
可以调用String         get(String key) ，通过设置不同的key可以返回你需要的参数，具体key的值参考Camera.Parameters 文档说明；

在设置参数前，最好都获取下系统支持的设置；

mProfile的值可以直接修改。

有没有人试过motorola的视频拍摄？即使设置了
mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
录出来的视频format profile 还是 3GPP media release 4,iphone 播放不了

类似米聊、微信上的涂鸦和手写文字功能
实现原理是自定义View，通过手势识别获取轨迹，然后通过画笔画图
这里添加了手势记录功能，并不难理解
代码贴下
public class TuyaView extends View {
private Bitmap mBitmap;
private Canvas mCanvas;
private Path mPath;
private Paint mBitmapPaint;// 画布的画笔
private Paint mPaint;// 真实的画笔
private float mX, mY;// 临时点坐标
private static final float TOUCH_TOLERANCE = 4;
// 保存Path路径的集合,用List集合来模拟栈
private static List<DrawPath> savePath;
// 记录Path路径的对象
private DrawPath dp;
private int screenWidth, screenHeight;// 屏幕長寬
private class DrawPath {
public Path path;// 路径
public Paint paint;// 画笔
}
public TuyaView(Context context, int w, int h) {
super(context);
screenWidth = w;
screenHeight = h;
mBitmap = Bitmap.createBitmap(screenWidth, screenHeight, Bitmap.Config.ARGB_8888);
// 保存一次一次绘制出来的图形
mCanvas = new Canvas(mBitmap);
mBitmapPaint = new Paint(Paint.DITHER_FLAG);
mPaint = new Paint();
mPaint.setAntiAlias(true);
mPaint.setStyle(Paint.Style.STROKE);
mPaint.setStrokeJoin(Paint.Join.ROUND);// 设置外边缘
mPaint.setStrokeCap(Paint.Cap.SQUARE);// 形状
mPaint.setStrokeWidth(5);// 画笔宽度
savePath = new ArrayList<DrawPath>();
}
@Override
public void onDraw(Canvas canvas) {
canvas.drawColor(0xFFAAAAAA);
// 将前面已经画过得显示出来
canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);
if (mPath != null) {
// 实时的显示
canvas.drawPath(mPath, mPaint);
}
}
private void touch_start(float x, float y) {
mPath.moveTo(x, y);
mX = x;
mY = y;
}
private void touch_move(float x, float y) {
float dx = Math.abs(x - mX);
float dy = Math.abs(mY - y);
if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) {
// 从x1,y1到x2,y2画一条贝塞尔曲线，更平滑(直接用mPath.lineTo也是可以的)
mPath.quadTo(mX, mY, (x + mX) / 2, (y + mY) / 2);
mX = x;
mY = y;
}
}
private void touch_up() {
mPath.lineTo(mX, mY);
mCanvas.drawPath(mPath, mPaint);
//将一条完整的路径保存下来(相当于入栈操作)
savePath.add(dp);
mPath = null;// 重新置空
}
/**
* 撤销的核心思想就是将画布清空，
* 将保存下来的Path路径最后一个移除掉，
* 重新将路径画在画布上面。
*/
public void undo() {
mBitmap = Bitmap.createBitmap(screenWidth, screenHeight,
Bitmap.Config.ARGB_8888);
mCanvas.setBitmap(mBitmap);// 重新设置画布，相当于清空画布
// 清空画布，但是如果图片有背景的话，则使用上面的重新初始化的方法，用该方法会将背景清空掉...
if (savePath != null && savePath.size() > 0) {
// 移除最后一个path,相当于出栈操作
savePath.remove(savePath.size() - 1);
Iterator<DrawPath> iter = savePath.iterator();
while (iter.hasNext()) {
DrawPath drawPath = iter.next();
mCanvas.drawPath(drawPath.path, drawPath.paint);
}
invalidate();// 刷新
/*在这里保存图片纯粹是为了方便,保存图片进行验证*/
String fileUrl = Environment.getExternalStorageDirectory()
.toString() + "/android/data/test.png";
try {
FileOutputStream fos = new FileOutputStream(new File(fileUrl));
mBitmap.compress(CompressFormat.PNG, 100, fos);
fos.flush();
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 重做的核心思想就是将撤销的路径保存到另外一个集合里面(栈)，
* 然后从redo的集合里面取出最顶端对象，
* 画在画布上面即可。
*/
public void redo(){
//如果撤销你懂了的话，那就试试重做吧。
}
@Override
public boolean onTouchEvent(MotionEvent event) {
float x = event.getX();
float y = event.getY();
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
// 每次down下去重新new一个Path
mPath = new Path();
//每一次记录的路径对象是不一样的
dp = new DrawPath();
dp.path = mPath;
dp.paint = mPaint;
touch_start(x, y);
invalidate();
break;
case MotionEvent.ACTION_MOVE:
touch_move(x, y);
invalidate();
break;
case MotionEvent.ACTION_UP:
touch_up();
invalidate();
break;
}
return true;
}
}

调用的地方
public class TuyaActivity extends Activity {
private TuyaView tuyaView = null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
tuyaView = new TuyaView(this, dm.widthPixels, dm.heightPixels);
setContentView(tuyaView);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK) {// 返回键
tuyaView.undo();
return true;
}
return super.onKeyDown(keyCode, event);
}
}

 首先添加权限：

<uses-permission android:name="android.permission.WAKE_LOCK"></uses-permission>

     实现代码：

   1: public class test extends Activity
   2: {
   3:     PowerManager powerManager = null;
   4:     WakeLock wakeLock = null;
   5:     @Override
   6:     protected void onCreate(Bundle savedInstanceState) {
   7:         super.onCreate(savedInstanceState);
   8:         this.setContentView(R.layout.main);
   9:         
  10:         this.powerManager = (PowerManager)this.getSystemService(Context.POWER_SERVICE);
  11:         this.wakeLock = this.powerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, "My Lock");
  12:     }
  13:     @Override
  14:     protected void onResume() {
  15:         super.onResume();
  16:         this.wakeLock.acquire();
  17:     }
  18:     @Override
  19:     protected void onPause() {
  20:         super.onPause();
  21:         this.wakeLock.release();
  22:     }
  23: }
    
     说明：在不同的生命周期调用不用的WakeLock函数可以使系统正常运行(如果不调用WakeLock.release，则屏幕会一直常亮)。

方法一：重写onBackPressed方法 
Java代码  
@Override  
    public void onBackPressed() {  
        // do something what you want  
        super.onBackPressed();  
    }  


方法二：重写dispatchKeyEvent 
Java代码  
@Override  
public boolean dispatchKeyEvent(KeyEvent event) {  
    // TODO Auto-generated method stub  
    if (event.getAction() == KeyEvent.ACTION_DOWN  
            && event.getKeyCode() == KeyEvent.KEYCODE_BACK) {  
        //do something what you want  
        return true;//返回true，把事件消费掉，不会继续调用onBackPressed  
    }  
    return super.dispatchKeyEvent(event);  
}  

方法三：使用测试框架Instrumentation，模拟任意键按下动作，注意的是该方法不能在主线程中使用，只能开启新线程，带来的问题就是反应速度较慢，项目中不建议使用。 
调用actionKey(KeyEvent.KEYCODE_BACK);产生back键单击效果 
Java代码  
/** 
 * 模拟键盘事件方法 
 * @param keyCode 
*/  
public void actionKey(final int keyCode) {  
     new Thread () {    
                public void run () {    
                    try {    
                         Instrumentation inst=new Instrumentation();    
                         inst.sendKeyDownUpSync(keyCode);  
                    } catch(Exception e) {    
                        e.printStackTrace();                    }    
                }    
            }.start();    
        }  

在项目中，一进入一个页面, EditText默认就会自动获取焦点。

那么如何取消这个默认行为呢？

 
解决之道：在EditText的父级控件中找一个，设置成

   android:focusable="true"  
   android:focusableInTouchMode="true"

这样，就把EditText默认的行为截断了！

 

 

<LinearLayout 
        style="@style/FillWrapWidgetStyle"
        android:orientation="vertical"
        android:background="@color/black"
        android:gravity="center_horizontal"
        
        android:focusable="true"  
        android:focusableInTouchMode="true"
        >
        <ImageView
            android:id="@+id/logo"
            style="@style/WrapContentWidgetStyle"
            android:background="@drawable/dream_dictionary_logo"
          />
        <RelativeLayout 
            style="@style/FillWrapWidgetStyle"
            android:background="@drawable/searchbar_bg"
            android:gravity="center_vertical"
            >
            <EditText
                android:id="@+id/searchEditText"
               style="@style/WrapContentWidgetStyle"
               android:background="@null"
               android:hint="Search"
               android:layout_marginLeft="40dp"
               android:singleLine="true"
             />
            
        </RelativeLayout>
        
    </LinearLayout>

在Android 2.0之后有了overridePendingTransition（） ，其中里面两个参数，一个是前一个activity的退出两一个activity的进入。 
Java代码  
@Override   
      public void onCreate(Bundle savedInstanceState) {   
              super.onCreate(savedInstanceState);    
  
              setContentView(R.layout.SplashScreen);   
   
              new Handler().postDelayed(new Runnable() {   
                      @Override   
                      public void run() {   
                              Intent mainIntent = new Intent(SplashScreen.this,     AndroidNews.class);   
                              SplashScreen.this.startActivity(mainIntent);   
                              SplashScreen.this.finish();   
   
                              overridePendingTransition(R.anim.mainfadein,   
                                      R.anim.splashfadeout);   
                      }   
              }, 3000);   
      }   

上面的代码只是闪屏的一部分。 
Java代码  
getWindow ().setWindowAnimations ( int );    

这可没有上个好但是也可以 。 

实现淡入淡出的效果 
Java代码  
overridePendingTransition(Android.R.anim.fade_in,android.R.anim.fade_out);    

由左向右滑入的效果 
Java代码  
overridePendingTransition(Android.R.anim.slide_in_left,android.R.anim.slide_out_right);    

实现zoomin和zoomout,即类似iphone的进入和退出时的效果 
Java代码  
overridePendingTransition(R.anim.zoomin, R.anim.zoomout);    

新建anim\zoomin.xml文件 
Xml代码  
<?xml version="1.0" encoding="utf-8"?>  
<set xmlns:Android="http://schemas.android.com/apk/res/android"  
        Android:interpolator="@android:anim/decelerate_interpolator">  
    <scale Android:fromXScale="2.0" android:toXScale="1.0"  
           Android:fromYScale="2.0" android:toYScale="1.0"  
           Android:pivotX="50%p" android:pivotY="50%p"  
           Android:duration="@android:integer/config_mediumAnimTime" />  
</set>  

新建anim\zoomout.xml文件 
Xml代码  
<?xml version="1.0" encoding="utf-8"?>  
<set xmlns:Android="http://schemas.android.com/apk/res/android"  
        Android:interpolator="@android:anim/decelerate_interpolator"  
        Android:zAdjustment="top">  
    <scale Android:fromXScale="1.0" android:toXScale=".5"  
           Android:fromYScale="1.0" android:toYScale=".5"  
           Android:pivotX="50%p" android:pivotY="50%p"  
           Android:duration="@android:integer/config_mediumAnimTime" />  
    <alpha Android:fromAlpha="1.0" android:toAlpha="0"  
            Android:duration="@android:integer/config_mediumAnimTime"/>  
</set>   

getLocalVisibleRect ， 返回一个填充的Rect对象， 感觉是这个View的Rect大小，left，top取到的都是0

···

getGlobalVisibleRect ， 获取全局坐标系的一个视图区域， 返回一个填充的Rect对象；该Rect是基于总整个屏幕的

···

getLocationOnScreen ，计算该视图在全局坐标系中的x，y值，（注意这个值是要从屏幕顶端算起，也就是索包括了通知栏的高度）//获取在当前屏幕内的绝对坐标 

···

getLocationInWindow ，计算该视图在它所在的widnow的坐标x，y值，//获取在整个窗口内的绝对坐标 (不是很理解= =、)

···

getLeft , getTop, getBottom, getRight,  这一组是获取相对在它父亲里的坐标

···

**注**：如果在Activity的OnCreate()事件输出那些参数，是全为0，要等UI控件都加载完了才能获取到这些（个人感觉好像是得有焦点，不是很清楚，待查查）

example:

    int[] location = new int[2];
    v.getLocationOnScreen(location);
    int x = location[0];
    int y = location[1];

XML：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:padding="5px"
    >
    <ViewFlipper
        android:id="@+id/fliper"   
        android:layout_width="fill_parent"   
        android:layout_height="100dp"   
        android:background="#FFFFFF"
        android:flipInterval="2000" >  
        <TextView   
            android:id="@+id/tv_1"  
            android:text="Hello1"
            android:layout_width="wrap_content"   
            android:layout_height="wrap_content"   
            android:layout_gravity="center_horizontal">  
         </TextView>
        <TextView   
            android:id="@+id/tv_2"  
            android:text="Hello"
            android:layout_width="wrap_content"   
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal">  
        </TextView>  
     </ViewFlipper>
     <Button android:id="@+id/button2"
             android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="B"
            android:layout_gravity="center_horizontal"
            />
</LinearLayout>

JavaCode：

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ViewFlipper;

public class ViewLocationActivity extends Activity {
    private ViewFlipper flipper;
    private Rect mRectSrc = new Rect();
    int[] location = new int[2];
    int x, y;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        flipper = (ViewFlipper) findViewById(R.id.fliper);
        Log.d("demo", "left:" + flipper.getLeft());
        Log.d("demo", "right:" + flipper.getRight());
        Log.d("demo", "Top:" + flipper.getTop());
        Log.d("demo", "Bottom:" + flipper.getBottom());

        Button btn = (Button) findViewById(R.id.button2);
        btn.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {

                Log.d("demo", "Button.Width--->" + v.getWidth());
                Log.d("demo", "Button.Height--->" + v.getHeight());

                v.getLocalVisibleRect(mRectSrc);
                Log.d("demo", "LocalVisibleRect--->" + mRectSrc);

                v.getGlobalVisibleRect(mRectSrc);
                Log.d("demo", "GlobalVisibleRect--->" + mRectSrc);

                v.getLocationOnScreen(location);
                x = location[0];
                y = location[1];
                Log.d("demo", "Screenx--->" + x + "  " + "Screeny--->" + y);

                v.getLocationInWindow(location);
                x = location[0];
                y = location[1];
                Log.d("demo", "Window--->" + x + "  " + "Window--->" + y);

                Log.d("demo", "left:" + v.getLeft());
                Log.d("demo", "right:" + v.getRight());
                Log.d("demo", "Top:" + v.getTop());
                Log.d("demo", "Bottom:" + v.getBottom());
            }
        });
    }
}

**显示**

Button.Width--->470
Button.Height--->72
LocalVisibleRect--->Rect(0, 0 - 470, 72)
GlobalVisibleRect--->Rect(5, 231 - 475, 303)
Screenx--->5  Screeny--->231
Windowx--->5  Windowy--->231
left:5
right:475
Top:155
Bottom:227

一些手机app（如微信、QQ等）有新消息来到达，手机屏幕即使在锁屏状态下也会亮起，并提示用户有新消息。但是，一般情况下手机锁屏后，Android系统为了省电以及减少CPU消耗，在一段时间后会使系统进入休眠状态，这时，Android系统中CPU会保持在一个相对较低的功耗状态，而收到新消息必定有网络请求，而网络请求是消耗CPU的操作，那么如何在锁屏状态乃至系统进入休眠后，仍然保持系统的网络状态以及通过程序唤醒手机呢？答案就是Android中的WakeLock机制。

    官方对于WakeLock的解释：

    PowerManager:This class gives you control of the power state of the device.
    PowerManager.WakeLock: lets you say that you need to have the device on.

    PowerManager负责对Android设备电源相关进行管理，而系统通过各种锁对电源进行控制，WakeLock是一种锁机制，只要有人拿着这把锁，系统就无法进入休眠阶段。既然要保持应用程序一直在后台运行，那自然要获得这把锁才可以保证程序始终在后台运行。

    WakeLock 使用代码：

WakeLock wakeLock = null;
 //获取电源锁，保持该服务在屏幕熄灭时仍然获取CPU时，保持运行
 private void acquireWakeLock()
 {
  if (null == wakeLock)
  {
   PowerManager pm = (PowerManager)this.getSystemService(Context.POWER_SERVICE);
   wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK|PowerManager.ON_AFTER_RELEASE, "PostLocationService");
   if (null != wakeLock)
   {
    wakeLock.acquire();
   }
  }
 }
 
 //释放设备电源锁
 private void releaseWakeLock()
 {
  if (null != wakeLock)
  {
   wakeLock.release();
   wakeLock = null;
  }
 }

    上面第一个方法是获取锁，第二个方法是释放锁，一旦获取锁后，及时屏幕在熄灭或锁屏长时间后，系统后台一直可以保持获取到锁的应用程序运行。获取到PowerManager的实例pm后，再通过newWakeLock方法获取wakelock的实例，其中第一个参数是指定要获取哪种类型的锁，不同的锁对系统CPU、屏幕和键盘有不同的影响，第二个参数是自定义名称。

    各种锁的类型对CPU 、屏幕、键盘的影响：

    PARTIAL_WAKE_LOCK:保持CPU 运转，屏幕和键盘灯有可能是关闭的。

    SCREEN_DIM_WAKE_LOCK：保持CPU 运转，允许保持屏幕显示但有可能是灰的，允许关闭键盘灯

    SCREEN_BRIGHT_WAKE_LOCK：保持CPU 运转，允许保持屏幕高亮显示，允许关闭键盘灯

    FULL_WAKE_LOCK：保持CPU 运转，保持屏幕高亮显示，键盘灯也保持亮度

    ACQUIRE_CAUSES_WAKEUP：强制使屏幕亮起，这种锁主要针对一些必须通知用户的操作.

    ON_AFTER_RELEASE：当锁被释放时，保持屏幕亮起一段时间

    最后声明权限：

    <uses-permission android:name="android.permission.WAKE_LOCK"/>
    <uses-permission android:name="android.permission.DEVICE_POWER"/>

android提供了一种新的类型：Parcel。本类被用作封装数据的容器，封装后的数据可以通过Intent或IPC传递。 除了基本类型以
外，只有实现了Parcelable接口的类才能被放入Parcel中。
 
Parcelable实现要点：需要实现三个东西
1）writeToParcel 方法。该方法将类的数据写入外部提供的Parcel中.声明如下：
writeToParcel (Parcel dest, int flags) 具体参数含义见javadoc
2）describeContents方法。没搞懂有什么用，反正直接返回0也可以
3）静态的Parcelable.Creator接口，本接口有两个方法：
createFromParcel(Parcel in) 实现从in中创建出类的实例的功能
newArray(int size) 创建一个类型为T，长度为size的数组，仅一句话（return new T[size])即可。估计本方法是供外部类反序列化本类数组使用。
测试用的接收信息Activity
import android.app.Activity;   
 
import android.content.Intent;   
 
import android.os.Bundle;   
import android.os.Parcelable;   
  
public class Test extends Activity {   
      
    @Override  
    public void onCreate(Bundle savedInstanceState) {   
        super.onCreate(savedInstanceState);   
        setContentView(R.layout.main);   
        Intent i = getIntent();   
        Person p = i.getParcelableExtra("yes");   
        System.out.println("---->"+p.name);   
        System.out.println("---->"+p.map.size());   
    }   
}  
发送的Activity
import java.util.HashMap;   
  
import android.app.Activity;   
import android.content.Intent;   
import android.os.Bundle;   
  
public class TestNew extends Activity {   
      
    @Override  
    public void onCreate(Bundle savedInstanceState) {   
        super.onCreate(savedInstanceState);   
        setContentView(R.layout.main);   
        Intent intent = new Intent();   
        Person p = new Person();   
        p.map = new HashMap<String,String>();   
        p.map.put("yes", "ido");   
        p.name="ok";   
        intent.putExtra("yes", p);   
        intent.setClass(this, Test.class);   
        startActivity(intent);   
    }   
}  
Parcelable的实现类
import java.util.HashMap;   
  
import android.os.Parcel;   
import android.os.Parcelable;   
  
public class Person implements Parcelable {   
  
    public HashMap<String,String> map = new HashMap<String,String> ();   
       
    public String name ;   
    @Override  
    public int describeContents() {   
        return 0;   
    }   
  
    @Override  
    public void writeToParcel(Parcel dest, int flags) {   
  
        dest.writeMap(map);   
        dest.writeString(name);   
    }   
    public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {   
//重写Creator
  
        @Override  
        public Person createFromParcel(Parcel source) {   
            Person p = new Person();   
            p.map=source.readHashMap(HashMap.class.getClassLoader());   
            p.name=source.readString();   
            return p;   
        }   
  
        @Override  
        public Person[] newArray(int size) {   
            // TODO Auto-generated method stub   
            return null;   
        }   
    };   
  
}  

  RadioGroup不是CompoundButton的子类,所以不能直接使用CompoundButton的回调函数，而只能

用RadioGroup.OnCheckedChangeListener()
                 
                而    CheckBox是CompoundButton的子类，可以直接使用CompoundButton的回调函数，可以直接

使用CompoundButton的
 
CompoundButton.OnCheckedChangeListener()
 
                部分代码如下：
 
                genderGroup.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
            
            @Override
            public void onCheckedChanged(RadioGroup group, int checkedId) {

                // TODO Auto-generated method stub

                if(femaleButton.getId()==checkedId){

                    System.out.println("female");

                    Toast.makeText(RadioTestActivity.this, "female", Toast.LENGTH_SHORT).show();

                }else if(maleButton.getId()==checkedId){

                    System.out.println("male");

                    Toast.makeText(RadioTestActivity.this, "male", Toast.LENGTH_SHORT).show();
                    
                }
            }
        });

        //多选按钮添加监听器
        swimBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {

                // TODO Auto-generated method stub

                if(isChecked){

                    System.out.println("swim is checked");

                }else{
                    System.out.println("swim is unchecked");
                }
            }
        });

公司技术人员在实现内部办公系统与外部网站一体化的时候，最重要的步骤就是从OA系统读取数据，并且根据网站模板生成最终的静态页面。这里就需要一个定时任务，循环的执行。

技术人员在写定时任务的时候，想当然的以为Timer.schedule(TimerTask task, long delay)就是重复的执行task。程序运行后发现只运行了一次，总觉得是task里的代码有问题，花了很长时间调试代码都没有结果。

仔细研读java api，发现：

schedule(TimerTask task, long delay)的注释：Schedules the specified task for execution after the specified delay。大意是在延时delay毫秒后执行task。并没有提到重复执行

schedule(TimerTask task, long delay, long period)的注释：Schedules the specified task for repeated fixed-delay execution, beginning after the specified delay。大意是在延时delay毫秒后重复的执行task，周期是period毫秒。

这样问题就很明确schedule(TimerTask task, long delay)只执行一次，schedule(TimerTask task, long delay, long period)才是重复的执行。关键的问题在于程序员误以为schedule就是重复的执行，而没有仔细的研究API，一方面也是英文能力不够，浏览API的过程中不能很快的理解到含义。

getLocationOnScreen 计算该视图在全局坐标系中的x，y值，（注意这个值是要从屏幕顶端算起，也就是包括了通知栏的高度）//获取在当前屏幕内的绝对坐标 
getLocationInWindow 计算该视图在它所在的widnow的坐标x，y值，//获取在整个窗口内的绝对坐标

getLeft , getTop, getBottom, getRight, 这一组是获取相对在它父亲里的坐标
int[] location = new  int[2] ;
view.getLocationInWindow(location); //获取在当前窗口内的绝对坐标
view.getLocationOnScreen(location);//获取在整个屏幕内的绝对坐标
location [0]--->x坐标,location [1]--->y坐标
转：http://blog.csdn.net/sjf0115/article/details/7306284

如果在Activity的OnCreate()事件输出那些参数，是全为0，要等UI控件都加载完了才能获取到这些。

package xiaosi.location;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;

public class LocationActivity extends Activity {
    /** Called when the activity is first created. */
	private ImageView t = null;
	private Button button = null;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        t = (ImageView)findViewById(R.id.l);
        button = (Button)findViewById(R.id.button);
        button.setOnClickListener(new buttonListener());
    }   
    public class buttonListener implements OnClickListener{

		public void onClick(View v)
		{
			int[] location = new int[2];
	        t.getLocationOnScreen(location);
	        int x = location[0];
	        int y = location[1];
	        System.out.println("x:"+x+"y:"+y);
            System.out.println("图片各个角Left："+t.getLeft()+"Right："+t.getRight()+"Top："+t.getTop()+"Bottom："+t.getBottom());
		}
    }
}
 
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <Button
        android:id="@+id/button"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="button"/>
    <ImageView
        android:id="@+id/l"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:src="@drawable/a" />
</LinearLayout>
 

转：http://suchang1123.blog.163.com/blog/static/200194051201252925258254/ 

 
int[] location =newint[2];


/**获取在当前窗口内的绝对坐标，getLeft , getTop, getBottom, getRight, 这一组是获取相对在它父窗口里的坐标。*/
view.getLocationInWindow(location); 

//获取在整个屏幕内的绝对坐标，注意这个值是要从屏幕顶端算起，也就是包括了通知栏的高度。
view.getLocationOnScreen(location);


其中 location [0]代表x坐标,location [1] 代表 坐标。
 
所以在需要确定组件在父窗体中的坐标时，使用getLocationInWindow，需要获得组件在整个屏幕的坐标时，使用getLocationOnScreen。
这里要注意虽然getLocationOnScreen是获取组件在屏幕中的坐标，但如果我们想拿到这个坐标，并且在这个坐标附近再添加一个组件时，直接使用拿到的坐标来建立新的组件是达不到效果的。

View itemView = userManagerView.getListView().getChildAt(j);// 获取列表子项
int[] location =newint[2];
itemView.getLocationOnScreen(location);
ImageView image =newImageView(getContext());

image.setBackgroundResource(R.drawable.operator);
if(GlobalData.loginState()){
params=newAbsoluteLayout.LayoutParams(LayoutParams.WRAP_CONTENT,
LayoutParams.WRAP_CONTENT, location[0]-15, location[1]-95);
}else{
params=newAbsoluteLayout.LayoutParams(LayoutParams.WRAP_CONTENT,
LayoutParams.WRAP_CONTENT, location[0]-15, location[1]-25);
}
image.setLayoutParams(params);

 

在代码中，我想根据itemVIew的坐标来绘制一个新的ImageView控件，但如果整个界面没有父容器时，拿到的坐标是可以直接使用的，而当前界面上有父容器，或者有与其平行的界面时，坐标是有偏移的，所以我加上了有些判断处理，根据不同的布局，适当的调整下坐标的偏移量

if(GlobalData.loginState()){
params=newAbsoluteLayout.LayoutParams(LayoutParams.WRAP_CONTENT,
LayoutParams.WRAP_CONTENT, location[0]-15, location[1]-95);
}else{
params=newAbsoluteLayout.LayoutParams(LayoutParams.WRAP_CONTENT,
LayoutParams.WRAP_CONTENT, location[0]-15, location[1]-25);
}

网上很多人对设置控件的位置都使用view.setPadding(left, top, right, bottom) ，其实这玩意很差劲，它是设置自己本身位置的偏移，我们很少需要这种效果，我需要的设置控件相对屏幕左上角的X 、Y位置。众里寻他千百度，蓦然回首，那人却在灯火阑珊处
import android.view.View; 
import android.view.ViewGroup.MarginLayoutParams; 
import android.widget.RelativeLayout; 
/* 
* 获取、设置控件信息 
*/ 
public class WidgetController { 
/* 
* 获取控件宽 
*/ 
public static int getWidth(View view) 
{ 
int w = View.MeasureSpec.makeMeasureSpec(0,View.MeasureSpec.UNSPECIFIED); 
int h = View.MeasureSpec.makeMeasureSpec(0,View.MeasureSpec.UNSPECIFIED); 
view.measure(w, h); 
return (view.getMeasuredWidth()); 
} 
/* 
* 获取控件高 
*/ 
public static int getHeight(View view) 
{ 
int w = View.MeasureSpec.makeMeasureSpec(0,View.MeasureSpec.UNSPECIFIED); 
int h = View.MeasureSpec.makeMeasureSpec(0,View.MeasureSpec.UNSPECIFIED); 
view.measure(w, h); 
return (view.getMeasuredHeight()); 
} 

/* 
* 设置控件所在的位置X，并且不改变宽高， 
* X为绝对位置，此时Y可能归0 
*/ 
public static void setLayoutX(View view,int x) 
{ 
MarginLayoutParams margin=new MarginLayoutParams(view.getLayoutParams()); 
margin.setMargins(x,margin.topMargin, x+margin.width, margin.bottomMargin); 
RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(margin); 
view.setLayoutParams(layoutParams); 
} 
/* 
* 设置控件所在的位置Y，并且不改变宽高， 
* Y为绝对位置，此时X可能归0 
*/ 
public static void setLayoutY(View view,int y) 
{ 
MarginLayoutParams margin=new MarginLayoutParams(view.getLayoutParams()); 
margin.setMargins(margin.leftMargin,y, margin.rightMargin, y+margin.height); 
RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(margin); 
view.setLayoutParams(layoutParams); 
} 
/* 
* 设置控件所在的位置YY，并且不改变宽高， 
* XY为绝对位置 
*/ 
public static void setLayout(View view,int x,int y) 
{ 
MarginLayoutParams margin=new MarginLayoutParams(view.getLayoutParams()); 
margin.setMargins(x,y, x+margin.width, y+margin.height); 
RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(margin); 
view.setLayoutParams(layoutParams); 
} 
} 

时候，我们必须把用户密码存放到数据库，为了安全起见，我们需要对这些密码进行单向的加密处理，
比如，有明文密码如下：
String originalPwd = "mypassword";
应用报文摘要方法，得到单向的加密字符串

//MD5是16位,SHA是20位（这是两种报文摘要的算法）
//MessageDigest md= MessageDigest.getInstance("MD5");
MessageDigest messageDigest=MessageDigest.getInstance("SHA-1");
messageDigest.update(originalPwd.getBytes());
//String digestedPwdString = new String(messageDigest.digest());
String digestedPwdString = new String(Base64.encode(messageDigest.digest()));
System.out.println("pwd:" + digestedPwdString);
这样，就得到密码的报文摘要，把此摘要保存到数据库，
以后用户登陆时，用相同的算法算出摘要，和数据库中的比较，如果一致，则密码正确。

注意：
byte[] digest = messageDigest.digest();
得到的是个二进制byte数组，有可能某些byte是不可打印的字符。
所以用Base64.encode把它转化成可打印字符。

也可以把digest的每个byte转化成hex（16进制）保存。
MessageDigest messageDigest=MessageDigest.getInstance("SHA-1");
messageDigest.update(originalPwd.getBytes());
byte[] bin = messageDigest.digest()；
再调用下面的方法生产hex（16进制）保存。


二行制转hex字符串的方法如下：
private static String byte2hex(byte[] b){
    String hs="";
    String stmp="";
    for (int n=0; n<b.length; n++){
        stmp=(java.lang.Integer.toHexString(b[n] & 0xFF));
        if (stmp.length()==1) hs=hs+"0"+stmp;
            else hs=hs+stmp;
    }
    return hs;
}

或者：
private static String byto2hex2(byte[] bin){
    StringBuffer buf = new StringBuffer();
    for (int i = 0; i < bin.length; ++i) {
        int x = bin[i] & 0xFF, h = x >>> 4, l = x & 0x0F;
        buf.append((char) (h + ((h < 10) ? '0' : 'a' - 10)));
        buf.append((char) (l + ((l < 10) ? '0' : 'a' - 10)));
    }
    return buf.toString();
}

或者:
干脆直接用下面的方法生成，用到第三方包：
public static String encryptPwd(String pwd, String algorithm){
    //String a = org.apache.catalina.realm.RealmBase.Digest(pwd,"SHA-1");
    return org.apache.catalina.realm.RealmBase.Digest(pwd, algorithm);
}

字符串显示时的宽度通过字符串的个数/长度是没有办法取得
因为涉及到字体，大小，全角/半角，
甚至英文字i和T的宽度也是截然不同的。
 
使用下面的方法， 可以取得字符串显示的宽度。
 
TextPaint paint = view.getPaint();
int width = Layout.getDesiredWidth(source, start, index, paint);
 
TextView view是显示字符串的TextView
CharSequence source 是字符串配列
int start是开始位置。
int index是字符个数 
 
使用例：
mainActivity
-------------------------------------------------------------------------------------------------
        mItem = new ArrayList<String>();
        mItem.add("あいうえおーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー");
        if (progDataAryList != null) {
            for (int i = 0; i < progDataAryList.size(); i++) {
             mItem.add(((String[]) progDataAryList.get(i))[1]);
            }
        }
        MyAdapter myAdapter = new MyAdapter(activity, R.layout.simple_list_item, R.id.simple_list_text1, mItem);
        // アダプターを設定します
        listView.setAdapter(myAdapter);
-------------------------------------------------------------------------------------------------
 
private class MyAdapter extends ArrayAdapter<String> {
        private int mResource;
        private int mFieldId;
        private LayoutInflater mInflater;
        private List<String> mStringobjects = new ArrayList<String>();
        public MyAdapter(Context context, int resource, int textViewResourceId, List<String> objects) {
            super(context, resource, textViewResourceId, objects);
            mResource = resource;
            mFieldId = textViewResourceId;
            mInflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
            mStringobjects = objects;
        }
        public View getView(int position, View convertView, ViewGroup parent) {
            View view;
            TextView text;
            if (convertView == null) {
                view = mInflater.inflate(mResource, parent, false);
            } else {
                view = convertView;
            }
            try {
                text = (TextView)view.findViewById(mFieldId);
            } catch (ClassCastException e) {
             String stack = Log.getStackTraceString(e);
                SaveLog.put(activity, stack);
                throw new IllegalStateException("resource ID error", e);
            }
            text.setFilters(new InputFilter[] {new LineFeedFilter(text)});
            text.setText(mStringobjects.get(position));
            ListView listView = (ListView) activity.findViewById(R.id.prog_listview1);
            if (position == listView.getCheckedItemPosition()) {
                if (convertView != null) {
                    convertView.setBackgroundResource(R.drawable.textviewtype2);
                }
            } else {
                if (convertView != null) {
                    convertView.setBackgroundColor(Color.TRANSPARENT);
                }
            }
            return view;
        }
    }
-------------------------------------------------------------------------------------------------
private class LineFeedFilter implements InputFilter {
        private final TextView view;
        public LineFeedFilter(TextView view) {
            this.view = view;
        }
        public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
            TextPaint paint = view.getPaint();
            int width = view.getWidth() - view.getCompoundPaddingLeft() - view.getCompoundPaddingRight();
            if (width <= 0){
             ListView listView = (ListView) activity.findViewById(R.id.prog_listview1);
             width = listView.getWidth() - listView.getPaddingLeft() -listView.getPaddingRight()
               - view.getCompoundPaddingLeft() - view.getCompoundPaddingRight();
            }
            SpannableStringBuilder result = new SpannableStringBuilder();
            for (int index = start; index < end; index++) {
                if (Layout.getDesiredWidth(source, start, index + 1, paint) > width) {
                 // 幅を越えたら改行を挿入
                    result.append(source.subSequence(start, index));
                    result.append("\n");
                    start = index;
                } else if (source.charAt(index) == '\n') {
                 // 改行文字があれば、ここまで出力
                    result.append(source.subSequence(start, index));
                    start = index;
                }
            }
            if (start < end) {
            // 残りの文字を追加
                result.append(source.subSequence(start, end));
            }
            return result;
        }
    }

1.基本的get
 
Java代码  
public void getUrl(String url, String encoding)  
            throws ClientProtocolException, IOException {  
        // 默认的client类。  
        HttpClient client = new DefaultHttpClient();  
        // 设置为get取连接的方式.  
        HttpGet get = new HttpGet(url);  
        // 得到返回的response.  
        HttpResponse response = client.execute(get);  
        // 得到返回的client里面的实体对象信息.  
        HttpEntity entity = response.getEntity();  
        if (entity != null) {  
            System.out.println("内容编码是：" + entity.getContentEncoding());  
            System.out.println("内容类型是：" + entity.getContentType());  
            // 得到返回的主体内容.  
            InputStream instream = entity.getContent();  
            try {  
                BufferedReader reader = new BufferedReader(  
                        new InputStreamReader(instream, encoding));  
                System.out.println(reader.readLine());  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                instream.close();  
            }  
        }  
  
        // 关闭连接.  
        client.getConnectionManager().shutdown();  
    }  
 
2.基本的Post
   下面的params参数，是在表单里面提交的参数。
 
Java代码  
public void postUrlWithParams(String url, Map params, String encoding)  
            throws Exception {  
        DefaultHttpClient httpclient = new DefaultHttpClient();  
        try {  
  
            HttpPost httpost = new HttpPost(url);  
            // 添加参数  
            List<NameValuePair> nvps = new ArrayList<NameValuePair>();  
            if (params != null && params.keySet().size() > 0) {  
                Iterator iterator = params.entrySet().iterator();  
                while (iterator.hasNext()) {  
                    Map.Entry entry = (Entry) iterator.next();  
                    nvps.add(new BasicNameValuePair((String) entry.getKey(),  
                            (String) entry.getValue()));  
                }  
            }  
  
            httpost.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8));  
  
            HttpResponse response = httpclient.execute(httpost);  
            HttpEntity entity = response.getEntity();  
  
            System.out.println("Login form get: " + response.getStatusLine()  
                    + entity.getContent());  
            dump(entity, encoding);  
            System.out.println("Post logon cookies:");  
            List<Cookie> cookies = httpclient.getCookieStore().getCookies();  
            if (cookies.isEmpty()) {  
                System.out.println("None");  
            } else {  
                for (int i = 0; i < cookies.size(); i++) {  
                    System.out.println("- " + cookies.get(i).toString());  
                }  
            }  
  
        } finally {  
            // 关闭请求  
            httpclient.getConnectionManager().shutdown();  
        }  
    }  
 
3。打印页面输出的小代码片段
 
Java代码  
private static void dump(HttpEntity entity, String encoding)  
            throws IOException {  
        BufferedReader br = new BufferedReader(new InputStreamReader(  
                entity.getContent(), encoding));  
        System.out.println(br.readLine());  
    }  
 
4.常见的登录session问题，需求:使用账户，密码登录系统之后，然后再访问页面不出错。
 
	特别注意，下面的httpclient对象要使用一个，而不要在第二次访问的时候，重新new一个。至于如何保存这个第一步经过了验证的httpclient，有很多种方法实现。单例，系统全局变量（android 下面的Application），ThreadLocal变量等等。
 
       以及下面创建的httpClient要使用ThreadSafeClientConnManager对象！
 
   public String getSessionId(String url, Map params, String encoding,
Java代码  
        String url2) throws Exception {  
    DefaultHttpClient httpclient = new DefaultHttpClient(  
            new ThreadSafeClientConnManager());  
    try {  
  
        HttpPost httpost = new HttpPost(url);  
        // 添加参数  
        List<NameValuePair> nvps = new ArrayList<NameValuePair>();  
        if (params != null && params.keySet().size() > 0) {  
            Iterator iterator = params.entrySet().iterator();  
            while (iterator.hasNext()) {  
                Map.Entry entry = (Entry) iterator.next();  
                nvps.add(new BasicNameValuePair((String) entry.getKey(),  
                        (String) entry.getValue()));  
            }  
        }  
        // 设置请求的编码格式  
        httpost.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8));  
        // 登录一遍  
        httpclient.execute(httpost);  
        // 然后再第二次请求普通的url即可。  
        httpost = new HttpPost(url2);  
        BasicResponseHandler responseHandler = new BasicResponseHandler();  
        System.out.println(httpclient.execute(httpost, responseHandler));  
    } finally {  
        // 关闭请求  
        httpclient.getConnectionManager().shutdown();  
    }  
    return "";  
}  
 
5.下载文件，例如mp3等等。
 
Java代码  
//第一个参数，网络连接；第二个参数，保存到本地文件的地址  
public void getFile(String url, String fileName) {  
        HttpClient httpClient = new DefaultHttpClient();  
        HttpGet get = new HttpGet(url);  
        try {  
            ResponseHandler<byte[]> handler = new ResponseHandler<byte[]>() {  
                public byte[] handleResponse(HttpResponse response)  
                        throws ClientProtocolException, IOException {  
                    HttpEntity entity = response.getEntity();  
                    if (entity != null) {  
                        return EntityUtils.toByteArray(entity);  
                    } else {  
                        return null;  
                    }  
                }  
            };  
  
            byte[] charts = httpClient.execute(get, handler);  
            FileOutputStream out = new FileOutputStream(fileName);  
            out.write(charts);  
            out.close();  
  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            httpClient.getConnectionManager().shutdown();  
        }  
    }  
 
6.创建一个多线程环境下面可用的httpClient
（原文：http://blog.csdn.net/jiaoshi0531/article/details/6459468）
 
Java代码  
              HttpParams params = new BasicHttpParams();  
//设置允许链接的做多链接数目  
ConnManagerParams.setMaxTotalConnections(params, 200);  
//设置超时时间.  
ConnManagerParams.setTimeout(params, 10000);  
//设置每个路由的最多链接数量是20  
ConnPerRouteBean connPerRoute = new ConnPerRouteBean(20);  
//设置到指定主机的路由的最多数量是50  
HttpHost localhost = new HttpHost("127.0.0.1",80);  
connPerRoute.setMaxForRoute(new HttpRoute(localhost), 50);  
ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute);  
//设置链接使用的版本  
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);  
//设置链接使用的内容的编码  
HttpProtocolParams.setContentCharset(params,  
        HTTP.DEFAULT_CONTENT_CHARSET);  
//是否希望可以继续使用.  
HttpProtocolParams.setUseExpectContinue(params, true);  
  
SchemeRegistry schemeRegistry = new SchemeRegistry();  
schemeRegistry.register(new Scheme("http",PlainSocketFactory.getSocketFactory(),80));  
schemeRegistry.register(new Scheme("https",SSLSocketFactory.getSocketFactory(),443));  
ClientConnectionManager cm = new ThreadSafeClientConnManager(params,schemeRegistry);  
httpClient = new DefaultHttpClient(cm, params);   
 
7.实用的一个对象，http上下文，可以从这个对象里面取到一次请求相关的信息，例如request，response，代理主机等。
 
Java代码  
public static void getUrl(String url, String encoding)  
            throws ClientProtocolException, IOException {  
        // 设置为get取连接的方式.  
        HttpGet get = new HttpGet(url);  
        HttpContext localContext = new BasicHttpContext();  
        // 得到返回的response.第二个参数，是上下文，很好的一个参数！  
        httpclient.execute(get, localContext);  
  
        // 从上下文中得到HttpConnection对象  
        HttpConnection con = (HttpConnection) localContext  
                .getAttribute(ExecutionContext.HTTP_CONNECTION);  
        System.out.println("socket超时时间：" + con.getSocketTimeout());  
  
        // 从上下文中得到HttpHost对象  
        HttpHost target = (HttpHost) localContext  
                .getAttribute(ExecutionContext.HTTP_TARGET_HOST);  
        System.out.println("最终请求的目标:" + target.getHostName() + ":"  
                + target.getPort());  
  
        // 从上下文中得到代理相关信息.  
        HttpHost proxy = (HttpHost) localContext  
                .getAttribute(ExecutionContext.HTTP_PROXY_HOST);  
        if (proxy != null)  
            System.out.println("代理主机的目标:" + proxy.getHostName() + ":"  
                    + proxy.getPort());  
  
        System.out.println("是否发送完毕:"  
                + localContext.getAttribute(ExecutionContext.HTTP_REQ_SENT));  
  
        // 从上下文中得到HttpRequest对象  
        HttpRequest request = (HttpRequest) localContext  
                .getAttribute(ExecutionContext.HTTP_REQUEST);  
        System.out.println("请求的版本:" + request.getProtocolVersion());  
        Header[] headers = request.getAllHeaders();  
        System.out.println("请求的头信息: ");  
        for (Header h : headers) {  
            System.out.println(h.getName() + "--" + h.getValue());  
        }  
        System.out.println("请求的链接:" + request.getRequestLine().getUri());  
  
        // 从上下文中得到HttpResponse对象  
        HttpResponse response = (HttpResponse) localContext  
                .getAttribute(ExecutionContext.HTTP_RESPONSE);  
        HttpEntity entity = response.getEntity();  
        if (entity != null) {  
            System.out.println("返回结果内容编码是：" + entity.getContentEncoding());  
            System.out.println("返回结果内容类型是：" + entity.getContentType());  
            dump(entity, encoding);  
        }  
    }  
 输出结果大致如下：
 
Txt代码  
socket超时时间：0  
最终请求的目标:money.finance.sina.com.cn:-1  
是否发送完毕:true  
请求的版本:HTTP/1.1  
请求的头信息:   
Host--money.finance.sina.com.cn  
Connection--Keep-Alive  
User-Agent--Apache-HttpClient/4.2.2 (java 1.5)  
请求的链接:/corp/go.php/vFD_BalanceSheet/stockid/600031/ctrl/part/displaytype/4.phtml  
返回结果内容编码是：null  
返回结果内容类型是：Content-Type: text/html  
 
8.设置代理
 
Java代码  
             //String  hostIp代理主机ip,int port  代理端口  
tpHost proxy = new HttpHost(hostIp, port);  
// 设置代理主机.  
tpclient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY,  
proxy);  
 
9.设置保持链接时间
Java代码  
//在服务端设置一个保持持久连接的特性.  
        //HTTP服务器配置了会取消在一定时间内没有活动的链接，以节省系统的持久性链接资源.  
        httpClient.setKeepAliveStrategy(new ConnectionKeepAliveStrategy() {  
            public long getKeepAliveDuration(HttpResponse response,  
                    HttpContext context) {  
                HeaderElementIterator it = new BasicHeaderElementIterator(  
                        response.headerIterator(HTTP.CONN_KEEP_ALIVE));  
                while (it.hasNext()) {  
                    HeaderElement he = it.nextElement();  
                    String param = he.getName();  
                    String value = he.getValue();  
                    if (value != null && param.equalsIgnoreCase("timeout")) {  
                        try {  
                            return Long.parseLong(value) * 1000;  
                        } catch (Exception e) {  
  
                        }  
                    }  
                }  
                HttpHost target = (HttpHost)context.getAttribute(ExecutionContext.HTTP_TARGET_HOST);  
                if("www.baidu.com".equalsIgnoreCase(target.getHostName())){  
                    return 5*1000;  
                }  
                else  
                    return 30*1000;   
            }   
        });  

<antcall> 只能调用同一个脚本之内的构建目标（target)，
<ant>可以通过antfile属性指定其他脚本内的目标(target).
一般如果目标在脚本内部，用<antcall>组织一下，
分布在不同脚本里，用<ant>组织。
http://blog.csdn.net/catoop/article/details/7614275
http://www.th7.cn/Program/Android/201305/138025.shtml
http://blog.csdn.net/hudashi/article/details/9016789
http://hi.baidu.com/_sherry_liu/item/f7d23ccdebca2623a0b50a80

ProGuard简介

       ProGuard是一个SourceForge上非常知名的开源项目。官网网址是：http://proguard.sourceforge.net/。

       Java的字节码一般是非常容易反编译的。为了很好的保护Java源代码，我们往往会对编译好的class文件进行混淆处理。ProGuard的主要作用就是混淆。当然它还能对字节码进行缩减体积、优化等，但那些对于我们来说都算是次要的功能。

       引用ProGuard官方的一段话来介绍就是：

       ProGuard is a free Java class file shrinker, optimizer, obfuscator, and preverifier. It detects and removes unused classes, fields, methods, and attributes. It optimizes bytecode and removes unused instructions. It renames the remaining classes, fields, and methods using short meaningless names. Finally, it preverifies the processed code for Java 6 or for Java Micro Edition.


Android Eclipse开发环境与ProGuard

       在Android 2.3以前，混淆Android代码只能手动添加proguard来实现代码混淆，非常不方便。而2.3以后，Google已经将这个工具加入到了SDK的工具集里。具体路径：SDK\tools\proguard。当创建一个新的Android工程时，在工程目录的根路径下，会出现一个proguard的配置文件proguard.cfg。也就是说，我们可以通过简单的配置，在我们的elipse工程中直接使用ProGuard混淆Android工程。

       具体混淆的步骤非常简单。首先，我们需要在工程描述文件default.properties中，添加一句话，启用ProGuard。如下所示：


 1 # This file is automatically generated by Android Tools.
 2 # Do not modify this file -- YOUR CHANGES WILL BE ERASED!
 3 # 
 4 # This file must be checked in Version Control Systems.
 5 # 
 6 # To customize properties used by the Ant build system use,
 7 # "build.properties", and override values to adapt the script to your
 8 # project structure.
 9 # Indicates whether an apk should be generated for each density.
10 split.density=false
11 # Project target.
12 target=android-10
13 proguard.config=proguard.cfg
14 

       这样，Proguard就可以使用了。当我们正常通过Android Tools导出Application Package时，Proguard就会自动启用，优化混淆你的代码。

 


 


      
    导出成功后，你可以反编译看看混淆的效果。一些类名、方法名和变量名等，都变成了一些无意义的字母或者数字。证明混淆成功！


proguard.cfg配置

       稍微深入想一下混淆后的结果，你就会发现，如果一些提供给外部的类、方法、变量等名字被改变了，那么程序本身的功能就无法正常实现。那么Proguard如何知道哪些东西是可以改名，而哪些是不能改变的呢？

       这个是靠proguard.cfg文件来进行配置的。Android工程中默认自动生成的proguard.cfg已经针对Android的一般情况进行了配置，我们打开这个配置文件。内容大概如下：


 1 -optimizationpasses 5
 2 -dontusemixedcaseclassnames
 3 -dontskipnonpubliclibraryclasses
 4 -dontpreverify
 5 -verbose
 6 -optimizations !code/simplification/arithmetic,!field/*,!class/merging/*
 7 -keep public class * extends android.app.Activity
 8 -keep public class * extends android.app.Application
 9 -keep public class * extends android.app.Service
10 -keep public class * extends android.content.BroadcastReceiver
11 -keep public class * extends android.content.ContentProvider
12 -keep public class * extends android.app.backup.BackupAgentHelper
13 -keep public class * extends android.preference.Preference
14 -keep public class com.android.vending.licensing.ILicensingService
15 
16 -keepclasseswithmembernames class * {
17     native <methods>;
18 }
19 
20 -keepclasseswithmembernames class * {
21     public <init>(android.content.Context, android.util.AttributeSet);
22 }
23 
24 -keepclasseswithmembernames class * {
25     public <init>(android.content.Context, android.util.AttributeSet, int);
26 }
27 
28 -keepclassmembers enum * {
29     public static **[] values();
30     public static ** valueOf(java.lang.String);
31 }
32 
33 -keep class * implements android.os.Parcelable {
34   public static final android.os.Parcelable$Creator *;
35 }
36 

    它主要保留了继承自Activity、Application、Service、BroadcastReceiver、ContentProvider、BackupAgentHelper、Preference和ILicensingService的子类。因为这些子类，都是可能被外部调用的。

另外，它还保留了含有native方法的类、构造函数从xml构造的类（一般为View的子类）、枚举类型中的values和valueOf静态方法、继承Parcelable的跨进程数据类。

       在实际的一个工程项目中，可能Google自动生成的配置不能胜任我们的混淆工作。所以，我们往往需要自己编写一些ProGuard配置。这方面的资料在官网的Manual -> Usage里有详细说明。大家可以研究一下。

  最近在做的项目要通过域名调用内网的服务器，因为android模拟器host文件无法修改，导致无法通过域名使用http方法调用内网服务，因此从网上大量转载的一种方法，这种方法:

    1. 通过emulator -avd avdName -partition-size 128 启动模拟器

    2.通过adb root 和 adb remount 命令获得root权限。

    3.通过 adb pull /system/etc/hosts 命令将hosts文件转移到PC上，手动修改hosts，并且通过adb push将hosts文件再推送回去。

     这个问题是因为linux中的换行符和window中的回车换行不一致引起的，网上大部分方法是让利用ultraedit等编辑器直接修改，但是我复制到编辑器上依然无法修改。上贴中的malbers回复说，利用echo命令，可以直接通过命令将需要修改的内容添加到hosts文件中，试了一下，果然可行。

     首先键入 adb shell 命令（新版本的sdk adb命令被转移到了platform-tools目录中），然后echo 192.168.0.246 www.aaa.com>>/system/etc/hosts，敲入上面这条命令后，再使用 cat /system/etc/hosts查看hosts文件修改情况，发现hosts果然已经被修改，但是问题是依然没有换行，貌似只有换行了以后才能被识别，

因此再次利用echo命令加入了换行符，问题解决。具体操作如下：

     前面几个步骤不变，但是不需要将hosts文件pull到电脑上，如果你已经修改了但是无效，可以先pull出来，还原到原始状态，不要有任何换行，并替换掉

模拟器上已经修改的hosts，使它回复到原始状态。即只有127.0.0.1 localhost。

    然后进入adb shell ， 使用 echo -e \\n >> /system/etc/hosts 为hosts文件加入换行符。

    再次使用 echo 192.168.0.246 www.aaa.com >> /system/etc/hosts 。

    这样就完整解决了换行问题。再次在浏览器中敲入www.aaa.com,熟悉的页面也出现了。

java源码：
private final static int a = 1;
	private final static int b = 2;
	private final static int c = 3;
public void Test(int d, int e) {
		if (a == d) {
			System.out.println("a==d");
			if (a == e) {
				System.out.println("a==e");
			}
		} else if (b == d) {
			System.out.println("b==d");
			if (b == e) {
				System.out.println("b==e");
			}
		} else {
			System.out.println("null == d");
			if (c == e) {
				System.out.println("c==e");
			}
		}
	}
反编译后对应代码：
public void Test(int paramInt1, int paramInt2)
  {
    if (1 == paramInt1)
    {
      System.out.println("a==d");
      if (1 == paramInt2)
        System.out.println("a==e");
    }
    while (true)
    {
      do
      {
        while (true)
        {
          do
          {
            return;
            if (2 != paramInt1)
              break label56;
            System.out.println("b==d");
          }
          while (2 != paramInt2);
          System.out.println("b==e");
        }
        label56: System.out.println("null == d");
      }
      while (3 != paramInt2);
      System.out.println("c==e");
    }
  }
--------------
java源码：
public void Test1(int f, int g) {
		switch (f) {
		case a:
			System.out.println("case a");
			break;
		case b:
			System.out.println("case b");
			break;
		case c:
			System.out.println("case v");
			if (f == g) {
				System.out.println("case v f == g");
			}
			break;
		default:
			System.out.println("case default");
			break;
		}
	}
反编译后编码：
public void Test1(int paramInt1, int paramInt2)
  {
    switch (paramInt1)
    {
    default:
      System.out.println("case default");
    case 1:
    case 2:
    case 3:
    }
    while (true)
    {
      do
      {
        while (true)
        {
          while (true)
          {
            return;
            System.out.println("case a");
          }
          System.out.println("case b");
        }
        System.out.println("case v");
      }
      while (paramInt1 != paramInt2);
      System.out.println("case v f == g");
    }
  }

JAVANCSS
PMD
checkstyle

开发apk的时候当然要考虑保护好自己的代码，Android环境就提供了ProGuard来进行代码混淆，确实是一个非常有用的工具，但用起来也确实够折腾的。


1. 基本配置
eclipse下建立android工程，就会生成proguard.cfg和project.properties，在后面的文件追加proguard.config=proguard.cfg即可让前面的配置文件在export时生效。默认的那个文件有一些内容，这里给一个更通用点的。

##—————Begin: proguard configuration common for all Android apps ———-
-optimizationpasses 5
-dontusemixedcaseclassnames
-dontskipnonpubliclibraryclasses
-dontskipnonpubliclibraryclassmembers
-dontpreverify
-verbose
-optimizations !code/simplification/arithmetic,!field/*,!class/merging/*
-keepattributes *Annotation*
-renamesourcefileattribute SourceFile
-keepattributes SourceFile,LineNumberTable

# 以下两个命令配合让类的路径给删除了
-allowaccessmodification
-repackageclasses ”

# 记录生成的日志数据，在proguard目录下
-dump class_files.txt
-printseeds seeds.txt
-printusage unused.txt
-printmapping mapping.txt

# 异常都可以忽略就打开
#-dontwarn

-keep public class * extends android.app.Activity
-keep public class * extends android.app.Application
-keep public class * extends android.app.Service
-keep public class * extends android.content.BroadcastReceiver
-keep public class * extends android.content.ContentProvider
-keep public class * extends android.app.backup.BackupAgentHelper
-keep public class * extends android.preference.Preference
-keep public class com.android.vending.licensing.ILicensingService
-dontnote com.android.vending.licensing.ILicensingService

-keepnames class * implements java.io.Serializable

# Explicitly preserve all serialization members. The Serializable interface
# is only a marker interface, so it wouldn’t save them.
-keepclassmembers class * implements java.io.Serializable {
static final long serialVersionUID;
private static final java.io.ObjectStreamField[] serialPersistentFields;
private void writeObject(java.io.ObjectOutputStream);
private void readObject(java.io.ObjectInputStream);
java.lang.Object writeReplace();
java.lang.Object readResolve();
}

# Preserve all native method names and the names of their classes.
-keepclasseswithmembernames class * {
native ;
}

-keepclasseswithmembernames class * {
public (android.content.Context, android.util.AttributeSet);
}

-keepclasseswithmembernames class * {
public (android.content.Context, android.util.AttributeSet, int);
}

# Preserve static fields of inner classes of R classes that might be accessed
# through introspection.
-keepclassmembers class **.R$* {
public static ;
}

# Preserve the special static methods that are required in all enumeration classes.
-keepclassmembers enum * {
public static **[] values();
public static ** valueOf(java.lang.String);
}

-keep class * implements android.os.Parcelable {
public static final android.os.Parcelable$Creator *;
}

# 如果你的工程是对外提供方法调用就打开
#-keep public class * {
# public protected *;
#}

##—————End: proguard configuration common for all Android apps ———-

2. 解决export打包的报错
这个时候export提示“conversion to Dalvik format failed with error 1”错误，网上说法有好多种，最后我还是把proguard从4.4升级到4.8就解决了。官方地址是http://proguard.sourceforge.net。上面的配置文件参数可以在这里查阅。

升级办法很简单，就是把android sdk目录下的tool/proguard目录覆盖一下即可。

3. 打包出来的程序如何调试
一旦打包出来，就不能用eclipse的logcat去看了，这里可以用android sdk中ddms.bat的tool来看，一用就发现和logcat其实还是一个东西，就是多了个设备的选择。

4. 使用 gson 需要的配置
当Gson用到了泛型就会有报错，这个真给郁闷了半天，提示“Missing type parameter”。最后找到一个资料给了一个解决办法，参考：http://stackoverflow.com/questions/8129040/proguard-missing-type-parameter。

另外我又用到了JsonObject，提交的Object里面的members居然被改成了a。所以上面给的东西还不够，还要加上

# 用到自己拼接的JsonObject
-keep class com.google.gson.JsonObject { *; }

我个人建议减少这些依赖包混淆带来的麻烦，干脆都全部保留不混淆。例如

-keep class com.badlogic.** { *; }
-keep class * implements com.badlogic.gdx.utils.Json*
-keep class com.google.** { *; }

5. 使用libgdx需要的配置
参考http://code.google.com/p/libgdx-users/wiki/Ant

6. 验证打包效果
我是利用了apktool的反编译工具，把打包文件又解压了看了一下，如果包路径、类名、变量名、方法名这些变化和你期望一致，那就OK了。命令：

apktool.bat d xxx.apk destdir

总结
这个东西用起来也不是很简单，特别是你程序用到的高级特性多，就更容易出问题。另外proguard的参数看起来确实也有点不好理解，打包过程慢，测试也比较浪费时间。东西虽好，但真不是那么容易上手。

【转：】http://blog.csdn.net/qeqeqe236/article/details/7346069
2.3SDK的两个新特点：
1.刚安装上2.3时，查看sdk目录，发现在<SDK_PATH>\tools下新增了一文件夹“proguard”,如下图,我就在想是不是Google终于官方对proguard考虑进去了。理论上，对java的混淆都是可以的，但关键在于如何编写proguard的混淆脚本。
 
2.使用SDK2.3后，新建的工程下和之前相比，都会多了一个文件“proguard.cfg”。一打开，相当惊喜，这就是混淆所需的proguard脚本啊。
如下图：
 
其代码如下：
view plaincopy to clipboardprint?
-optimizationpasses 5 
-dontusemixedcaseclassnames  
-dontskipnonpubliclibraryclasses  
-dontpreverify  
-verbose  
-optimizations !code/simplification/arithmetic,!field/*,!class/merging/*  
-keep public class * extends android.app.Activity  
-keep public class * extends android.app.Application  
-keep public class * extends android.app.Service  
-keep public class * extends android.content.BroadcastReceiver  
-keep public class * extends android.content.ContentProvider  
-keep public class com.android.vending.licensing.ILicensingService  
-keepclasseswithmembernames class * {  
    native <methods>;  
}  
-keepclasseswithmembernames class * {  
    public <init>(android.content.Context, android.util.AttributeSet);  
}  
-keepclasseswithmembernames class * {  
    public <init>(android.content.Context, android.util.AttributeSet, int);  
}  
-keepclassmembers enum * {  
    public static **[] values();  
    public static ** valueOf(java.lang.String);  
}  
-keep class * implements android.os.Parcelable {  
  public static final android.os.Parcelable$Creator *;  
} 
-optimizationpasses 5
-dontusemixedcaseclassnames
-dontskipnonpubliclibraryclasses
-dontpreverify
-verbose
-optimizations !code/simplification/arithmetic,!field/*,!class/merging/*
-keep public class * extends android.app.Activity
-keep public class * extends android.app.Application
-keep public class * extends android.app.Service
-keep public class * extends android.content.BroadcastReceiver
-keep public class * extends android.content.ContentProvider
-keep public class com.android.vending.licensing.ILicensingService
-keepclasseswithmembernames class * {
    native <methods>;
}
-keepclasseswithmembernames class * {
    public <init>(android.content.Context, android.util.AttributeSet);
}
-keepclasseswithmembernames class * {
    public <init>(android.content.Context, android.util.AttributeSet, int);
}
-keepclassmembers enum * {
    public static **[] values();
    public static ** valueOf(java.lang.String);
}
-keep class * implements android.os.Parcelable {
  public static final android.os.Parcelable$Creator *;
}
从脚本中可以看到，混淆中保留了继承自Activity、Service、Application、BroadcastReceiver、ContentProvider等基本组件。
并保留了所有的Native变量名及类名，所有类中部分以设定了固定参数格式的构造函数，枚举等等。(详细信息请参考<proguard_path>\examples中的例子及注释。)
好了，进行得差不多了，下面就来看看如何真正的生成混淆APK吧。这儿又得提醒一下，SDK新的特性在文档里都是有的，所以文档很重要。
查看SDK2.3的文档，在路径“<androidSDK_path>/docs/guide/developing/tools/proguard.html”的“Enabling ProGuard ”中是这样描述的：
To enable ProGuard so that it runs as part of an Ant or Eclipse build, set the proguard.config property in the <project_root>/default.properties file. The path can be an absolute path or a path relative to the project's root.
好的，那就这样做吧。
在工程的"default.properties"中添加这样一句话“proguard.config=proguard.cfg”，如下图：
 
这样就已经设置好ADT的混淆操作了。接下来就是正常的打包和签名了。。
下图是我混淆SDK Demo中自带的Notepad效果图：
 
注意要点: 
1.混淆以后的包会比混淆前的包小一点，一定要注意这点.
如果混淆不成功,请在第2步,将proguard.config=proguard.cfg修改为proguard.config=E:\Mobile_Develop\Google_Android\publicGoldenBeach_new\proguard.cfg这种类似的用绝对路径,请注意绝对路径中的文件夹名不能含有空格,如果有空格请替换为"_". 
 
2.android在用proguard混淆时，一般情况下使用系统自带的配置文件就可以保持大部分外部需要引用的类，比如Activity，view扩展等等，但是有些情况下一些引入的外部lib，如果被混淆也会出现各种各样的问题，如果不想混淆这些包，就要加上
-keep class packagename.** {*;}
这样就能完整保持原有class了

这是在工程中的proguard-project.txt中发现的

# To enable ProGuard in your project, edit project.properties
# to define the proguard.config property as described in that file.
#
# Add project specific ProGuard rules here.
# By default, the flags in this file are appended to flags specified
# in ${sdk.dir}/tools/proguard/proguard-android.txt
# You can edit the include path and order by changing the ProGuard
# include property in project.properties.
#
# For more details, see
# http://developer.android.com/guide/developing/tools/proguard.html

# Add any project specific keep options here:

# If your project uses WebView with JS, uncomment the following
# and specify the fully qualified class name to the JavaScript interface
# class:
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
# public *;
#}

 
从脚本中可以看到，混淆中保留了继承自Activity、Service、Application、BroadcastReceiver、ContentProvider等基本组件以及com.android.vending.licensing.ILicensingService，
并保留了所有的Native变量名及类名，所有类中部分以设定了固定参数格式的构造函数，枚举等等。(详细信息请参考<proguard_path>/examples中的例子及注释。)
让proguard.cfg起作用的做法很简单，就是在eclipse自动生成的default.properties文件中加上一句“proguard.config=proguard.cfg”就可以了
完整的default.properties文件应该如下：
# This file is automatically generated by Android Tools.
# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
#
# This file must be checked in Version Control Systems.
#
# To customize properties used by the Ant build system use,
# "build.properties", and override values to adapt the script to your
# project structure.

# Project target.
target=android-15
proguard.config=proguard.cfg

Android代码混淆，如何过滤掉反射的R文件及第三方包？
解决方案：在Proguard.cfg方件中添加以下设定：


过滤R文件的混淆：
-keep class **.R$* {   *;  }


过滤第三方包的混淆：
-keep class packagename.** {*;}（其中packagename为第三方包的包名）

Android导入第三方jar包，proguard混淆脚本(屏蔽警告，不混淆第三方包)
最近1个项目中 需要导入移动MM的第三方计费包，混淆时用到了如下脚本，可屏蔽警告，不混淆第三方包指定内容。
非常有效

proguard.cfg 文件

-optimizationpasses 5
-dontusemixedcaseclassnames
-dontskipnonpubliclibraryclasses
-dontpreverify
-ignorewarnings //这1句是屏蔽警告，脚本中把这行注释去掉
-verbose
-optimizations !code/simplification/arithmetic,!field/*,!class/merging/*
//这1句是导入第三方的类库，防止混淆时候读取包内容出错，脚本中把这行注释去掉
-libraryjars libs/mmbilling.jar 

-dontwarn  //dontwarn去掉警告
-dontskipnonpubliclibraryclassmembers

-keep public class * extends android.app.Activity
-keep public class * extends android.app.Application
-keep public class * extends android.app.Service
-keep public class * extends android.content.BroadcastReceiver
-keep public class * extends android.content.ContentProvider
-keep public class * extends android.app.backup.BackupAgentHelper
-keep public class * extends android.preference.Preference
-keep public class com.android.vending.licensing.ILicensingService
-keepclasseswithmembernames class * {
    native <methods>;
}
-keepclasseswithmembernames class * {
    public <init>(android.content.Context, android.util.AttributeSet);
}
-keepclasseswithmembernames class * {
    public <init>(android.content.Context, android.util.AttributeSet, int);
}
-keepclassmembers enum * {
    public static **[] values();
    public static ** valueOf(java.lang.String);
}
-keep class * implements android.os.Parcelable {
  public static final android.os.Parcelable$Creator *;
}

//这4句是不混淆第三方包中的指定内容，脚本中把这行注释去掉 -keep class com.ccit.** {*; }   
-keep class ccit.** { *; }
-keep class com.aspire.**
-keep class mm.vending.**

第一篇： 
很多网友可能知道Android横竖屏切换时会触发onSaveInstanceState，而还原时会产生onRestoreInstanceState，但是Android的Activity类还有一个方法名为onRetainNonConfigurationInstance和getLastNonConfigurationInstance这两个方法。

   我们可以通过  onRetainNonConfigurationInstance 代替 onSaveInstanceState，比如

  @Override
  public Object onRetainNonConfigurationInstance() 
 {    
       //这里需要保存的内容，在切换时不是bundle了，我们可以直接通过Object来代替
      return obj;
 }

 在恢复窗口时，我们可以不使用 onRestoreInstanceState，而代替的是 getLastNonConfigurationInstance 方法。我们可以直接在onCreate中使用，比如

  Object obj = getLastNonConfigurationInstance();     最终obj的内容就是上次切换时的内容。

  这里Android123提醒大家，每次Activity横竖屏切换时onCreate方法都会被触发。

转：http://www.android123.com.cn/androidkaifa/610.html


第二篇：

Android横竖屏切换时会触发onSaveInstanceState，而还原时会产生onRestoreInstanceState，但是Android的Activity类还有一个方法名为onRetainNonConfigurationInstance和getLastNonConfigurationInstance这两个方法。

    当Device configuration发生改变时，将伴随Destroying被系统调用。通过这个方法可以像onSaveInstanceState()的方法一样保留变化前的Activity State，最大的不同在于这个方法可以返回一个包含有状态信息的Object，其中甚至可以包含Activity Instance本身。新创建的Activity可以继承大量来至于Parent Activity State信息。

    用这个方法保存Activity State后，通过getLastNonConfigurationInstance()在新的Activity Instance中恢复原有状态。比如:
[java] view plaincopy
@Override  
public Object onRetainNonConfigurationInstance() {  
    final MyDataObject data = MyLoadedData();  
    return data;  
}  

在恢复窗口时，我们可以不使用onRestoreInstanceState，而代替的是 getLastNonConfigurationInstance 方法。我们可以直接在onCreate中使用，比如
[java] view plaincopy
@Override  
public void onCreate(Bundle savedInstanceState) {  
    super.onCreate(savedInstanceState);  
    setContentView(R.layout.main);  
  
    final MyDataObject data = (MyDataObject) getLastNonConfigurationInstance();  
    if (data == null) {  
        data = loadMyData();  
    }  
    ...  
}  


这个方法最大的好处是：
    * 当Activity曾经通过某个资源得到一些图片或者信息，那么当再次恢复后，无需重新通过原始资源地址获取，可以快速的加载整个Activity状态信息。
    * 当Activity包含有许多线程时，在变化后依然可以持有原有线程，无需通过重新创建进程恢复原有状态。
    * 当Activity包含某些Connection Instance时，同样可以在整个变化过程中保持连接状态。

下边是需要特别注意的几点：
    * onRetainNonConfigurationInstance()在onSaveInstanceState()之后被调用。
    * 调用顺序同样介于onStop() 和 onDestroy()之间。


转：http://www.cofftech.com/thread-7566-1-1.html

做的一个是要登录自己的图书馆账号，用于查看自己所借阅的书籍，

看了一下图书馆的代码，发现是POST用户名和密码，

而在代码实现主要有两个难点：一、保存账号密码 二、保存Cookie

那么 ，第一个可以使用之前提到过的Sharedpreference ，每次就直接从sharedpreference里获取账号名和密码就可以了，不需要每次都输入

第二个怎么获得服务器的cookie呢，知道这次的session id

通过Httpclient 中的getcookiestore

 
List<Cookie> cookies = httpclient.getCookieStore().getCookies();    
if (cookies.isEmpty()) {    
Log.i(TAG, "-------Cookie NONE---------");    
} else {                   
for (int i = 0; i < cookies.size(); i ) {    
//保存cookie     
cookie = cookies.get(i);    
Log.d(TAG, cookies.get(i).getName() "=" cookies.get(i).getValue() );    
}  
获得了session id后，怎么再添加到我们的POST或者GET请求里面呢，

 
HttpPost httpPost = new HttpPost(访问地址);  
httpPost.setHeader("Cookie", "JSESSIONID=" + 我们在静态变量里存放的SessionId);  
HttpResponse httpResponse = httpclient.execute(httpPost);  
 

 
HttpGet request = new HttpGet(url+"?"+Params);  
        request.setHeader("Cookie",Sessionid);  

在java网络编程Socket通信中，通常会遇到以下异常情况：
　　第1个异常是 java.net.BindException:Address already in use: JVM_Bind。
　　该异常发生在服务器端进行new ServerSocket(port)（port是一个0，65536的整型值）操作时。异常的原因是以为与port一样的一个端口已经被启动，并进行监听。此时用netstat -an命令，可以看到一个Listending状态的端口。只需要找一个没有被占用的端口就能解决该问题了。
　　第2个异常是java.net.ConnectException: Connection refused: connect。
　　该异常发生在客户端进行 new Socket(ip, port)操作时，该异常发生的原因是或者具有ip地址的机器不能找到（也就是说从当前机器不存在到指定ip路由），或者是该ip存在，但找不到指定的端口进行监听。出现该问题，首先检查客户端的ip和port是否写错，如果正确则从客户端ping一下服务器看是否能ping通，如果能ping通（服务器端把ping禁掉则需要另外的办法），则看在服务器端的监听指定端口的程序是否启动，这个肯定能解决这个问题。
　　第3个异常是java.net.SocketException: Socket is closed。
　　该异常在客户端和服务器均可能发生。异常的原因是本端主动关闭了连接后（调用了Socket的close方法）再对网络连接进行读写操作。
　　第4个异常是java.net.SocketException: （Connection reset或者Connect reset by peer:Socket write error）。
　　该异常在客户端和服务器端均有可能发生，引起该异常的原因有两个，第一个就是如果一端的Socket被关闭（或主动关闭或者因为异常退出而引起的关闭），另一端仍发送数据，发送的第一个数据包引发该异常(Connect reset by peer)。另一个是一端退出，但退出时并未关闭该连接，另一端如果在从连接中读数据则抛出该异常（Connection reset）。简单的说就是由连接断开后的读和写操作引起的。
　　第5个异常是java.net.SocketException: Broken pipe。
　　该异常在客户端和服务器均有可能发生。在第4个异常的第一种情况中（也就是抛出 SocketExcepton:Connect reset by peer:Socket write error后），如果再继续写数据则抛出该异常。前两个异常的解决方法是首先确保程序退出前关闭所有的网络连接，其次是要检测对方的关闭连接操作，发现对方关闭连接后自己也要关闭该连接。
　　二．编写网络程序时需要注意的问题:
　　1、是要正确区分长、短连接。所谓的长连接是指一经建立就永久保持。短连接的情况是，准备数据—>建立连接—>发送数据—>关闭连接。很多的程序员写了多年的网络程序，居然不知道什么是长连接，什么是短连接。
　　2、是对长连接的维护。所谓维护包括两个方面，首先是检测对方的主动断连（即调用 Socket的close方法），其次是检测对方的宕机、异常退出及网络不通。这是一个健壮的通信程序必须具备的。检测对方的主动断连很简单，主要一方主动断连，另一方如果在进行读操作，则此时的返回值只-1，一旦检测到对方断连，则应该主动关闭本端的连接（调用Socket的close方法）。而检测对方的宕机、异常退出及网络不通，常用方法是用“心跳”，也就是双方周期性的发送数据给对方，同时也从对方接收“心跳”，如果连续几个周期都没有收到对方心跳，则可以判断对方宕机、异常退出或者网络不通，此时也需要主动关闭本端连接，如果是客户端可在延迟一定时间后重新发起连接。虽然Socket有一个keep alive选项来维护连接，如果用该选项，一般需要两个小时才能发现对方的宕机、异常退出及网络不通。
　　3、是处理效率问题。不管是客户端还是服务器，如果是长连接一个程序至少需要两个线程，一个用于接收数据，一个用于发送心跳，写数据不需要专门的线程，当然另外还需要一类线程（俗称Worker线程）用于进行消息的处理，也就是说接收线程仅仅负责接收数据，然后再分发给Worker进行数据的处理。如果是短连接，则不需要发送心跳的线程，如果是服务器还需要一个专门的线程负责进行连接请求的监听。这些是一个通信程序的整体要求，具体到你的程序中，就看你如何对程序进行优化了。

以下是在做项目时常用到的，我做了一下总结。
1、EditText输入的文字为密码形式的设置
(1)通过.xml里设置：
 把该EditText设为：android:password="true"  // 以”.”形式显示文本
(2)在代码里设置：
通过设置EditText的setTransformationMethod()方法来实现隐藏密码或这显示密码。
editText.setTransformationMethod(PasswordTransformationMethod.getInstance()); //设置密码为不可见。
2、(1)EditText输入的文字为电话号码
Android:phoneNumber=”true”  // 输入电话号码
3、EditText字数限制的设置
(1)在.xml中设置：android:maxLength=“50” 
(2)代码中设置：   
editText.setFilters(new InputFilter[]{new InputFilter.LengthFilter(100)});
4、EditText设置字体
android:typeface="monospace" //设置字型。字形有：normal, sans, serif, monospace
5、EditText是否可编辑
Android:editable // 是否可编辑
6、在EditText中软键盘的调起、关闭
(1)EditText有焦点（focusable为true）阻止输入法弹出
 editText=(EditText)findViewById(R.id.txtBody);
    editText.setOnTouchListener(new OnTouchListener() {  
          public boolean onTouch(View v, MotionEvent event) { 
             editText.setInputType(InputType.TYPE_NULL); // 关闭软键盘     
             return false;
          }
     });
(2)当EidtText无焦点（focusable=false）时阻止输入法弹出
 InputMethodManager imm =
(InputMethodManager)getSystemService(INPUT_METHOD_SERVICE); 
 imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
（3）调用数字键盘并设置输入类型和键盘为英文
etNumber.setInputType(InputType.TYPE_CLASS_NUMBER); //调用数字键盘
rlEditText.setInputType(InputType.TYPE_TEXT_FLAG_MULTI_LINE);//设置输入类型和键盘为英文
或者：android:inputType="textUri|textMultiLine"
（4）android:focusable="false"//键盘永远不会弹出

<activity android:name=".AddLinkman" android:windowSoftInputMode="adjustUnspecified|stateHidden"/>//不自动弹出键盘
 
//关闭键盘（比如输入结束后执行）
InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(etEditText.getWindowToken(), 0);
 
//自动弹出键盘
((InputMethodManager) getSystemService(INPUT_METHOD_SERVICE)).toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS);
etEditText.requestFocus();//让EditText获得焦点，但是获得焦点并不会自动弹出键盘
7、android:layout_gravity和android:gravity的区别
(1)android:layout_gravity是本元素对父元素的重力方向。
(2)android:gravity是本元素所有子元素的重力方向。
8、android:padding和android:layout_margin区别
这两个都可以设置边距，但有细微的区别：
(1)android:padding是相对父view的边距
(2)android:layout_margin是相对同一级View的边距
例：LinearLayout是水平布局，下面有两个按钮，
(a)如果右边的按钮想距左边的按钮15px,因为这两个按钮是同一级的，应该用android:layout_margin；
(b)如果右边的按钮想距左边的距离为350px,应该用android:padding
9、android:numeric //只接受数字
android:numeric来控制输入的数字类型，一共有三种分别为integer（正整数）、signed（带符号整数，有正负）和decimal(浮点数)。
10、Enter键图标的设置
软键盘的Enter键默认显示的是“完成”文本，我们知道按Enter建表示前置工作已经准备完毕了，要去什么什么啦。比如，在一个搜索中，我们输入要搜索的文本，然后按Enter表示要去搜索了，但是默认的Enter键显示的是“完成”文本，看着不太合适，不符合搜索的语义，如果能显示“搜索”两个字或者显示一个表示搜索的图标多好。事实证明我们的想法是合理的，Android也为我们提供的这样的功能。通过设置android:imeOptions来改变默认的“完成”文本。这里举几个常用的常量值：
（1）actionUnspecified未指定，对应常量EditorInfo.IME_ACTION_UNSPECIFIED效果：
（2）actionNone 没有动作,对应常量EditorInfo.IME_ACTION_NONE 效果：
（3）actionGo 去往，对应常量EditorInfo.IME_ACTION_GO 效果：
（4）actionSearch 搜索，对应常量EditorInfo.IME_ACTION_SEARCH 效果： 
（5）actionSend 发送，对应常量EditorInfo.IME_ACTION_SEND 效果：
（6）actionNext 下一个，对应常量EditorInfo.IME_ACTION_NEXT 效果：
（7）actionDone 完成，对应常量EditorInfo.IME_ACTION_DONE 效果：
 
11、使用android:imeOptinos可对Android自带的软键盘进行一些界面上的设置：
android:imeOptions="flagNoExtractUi"  //使软键盘不全屏显示，只占用一部分屏幕
同时,这个属性还能控件软键盘右下角按键的显示内容,默认情况下为回车键
android:imeOptions="actionNone"  //输入框右侧不带任何提示
android:imeOptions="actionGo"    //右下角按键内容为'开始'
android:imeOptions="actionSearch"  //右下角按键为放大镜图片，搜索
android:imeOptions="actionSend"    //右下角按键内容为'发送'
android:imeOptions="actionNext"   //右下角按键内容为'下一步'
android:imeOptions="actionDone"  //右下角按键内容为'完成'
12、限定edittext能输入数字和字母，并且默认输入为数字，如身份证号码
android:inputType="number"
android:digits="0123456789xyzXYZ"
13、软键盘的调起导致原来的界面被挤上去，或者导致界面下面的tab导航被挤上去，解决方法如下
解决方法：
使用Manifest中的Activity的android:windowSoftInputMode的"adjustPan"属性。
另外注意：有关软键盘的问题可参考android:windowSoftInputMode中属性。
14、edittext光标详解
edittext.requestFocusFromTouch();//让光标放入到点击位置。
edittext.requestFocus();//默认方式获得焦点

EditText editor = (EditText)getCurrentView();//光标处插入
int cursor = editor.getSelectionStart();
editor.getText().insert(cursor,delta);
 
让光标移到末端（这样文字就会向前显示）
EditText et = ...
String text = "text";
et.setText(text);
et.setSelection(text.length());
 
android:cursorVisible="false" 隐藏光标
android:background="#00000000"//不要文本框背景