1,android 关闭进程

若是只有一个单独的Activity的工程，例如Activity A,调用android.app.Activity.finish()的话，并不会关闭该工程，只是使之不处于前台，而被置于后台。参考网上的方法，可以调用   android.os.Process.killProcess(android.os.Process.myPid());这种方法确实的是可以关闭该工程进程的，您可以到应用程序管理里头看看，该工程已不存在于Running中。

但是若是多个的Activity的工程，例如Activity A---》Activity B,而在Activity B中调用android.os.Process.killProcess(android.os.Process.myPid());这种方法应该只是关闭当前的Activity,接着系统会重构之前的Activity A(记住，这里说的是重构，意思是，并不会调用Activity A 的onRestart(),而是调用OnCreate())

2, Android开发问题整理

1、The constructor Intent(new View.OnClickListener(){}, Class) is undefined

点击按钮，进入另一个activity，问题代码如下

[java] view plain copy

1.       Button btn = (Button)findViewById(R.id.btnMe);  

2.         btn.setOnClickListener(new OnClickListener(){  

3.             @Override  

4.             public void onClick(View arg0) {  

5.                 // TODO Auto-generated method stub  

6.                 Intent intent = new Intent(this, ButtonStudyActivity.class);  

7.                 startActivity(intent);  

8.             }});  

   Intent myIntent = new Intent(this, AuswahlActivity.class);
   this.startActivity(myIntent);

这部分代码可能在 OnClickListener 中，所以使用：

Intent myIntent = new Intent(YouCurrentActivity.this, AuswahlActivity.class);
YouCurrentActivity.this.startActivity(myIntent); 

原因是，在一个匿名类(你的类是OnClickListener)，this通常是指OnClickListener而不是activity。intent的第一个参数是Context（应该是activity），因此导致了出现的错误。

解决方案一：

[java] view plain copy

1. Intent intent = new Intent(Activityheihei.this, ButtonStudyActivity.class);  

解决方案二：

[java] view plain copy

1.       final Intent intent = new Intent(Activityheihei.this, ButtonStudyActivity.class);  

2.         Button btn = (Button)findViewById(R.id.btnMe);  

3.         btn.setOnClickListener(new OnClickListener(){  

4.             @Override  

5.             public void onClick(View arg0) {  

6.                 // TODO Auto-generated method stub  

7.                 startActivity(intent);  

8.             }});  

解决方案三：

[java] view plain copy

1.       final Intent intent = new Intent(this, ButtonStudyActivity.class);  

2.         Button btn = (Button)findViewById(R.id.btnMe);  

3.         btn.setOnClickListener(new OnClickListener(){  

4.             @Override  

5.             public void onClick(View arg0) {  

6.                 // TODO Auto-generated method stub  

7.                 startActivity(intent);  

8.             }});  

2、ActivityManager: Warning: Activity not started, its current task has been brought to the front

Eclipse中，Project->Clean…，然后选中项目，clean一下即可。

3、E/AndroidRuntime(338): java.lang.IllegalStateException: Could not find a methodonClickBtnManifest(View) in the activity class cn.edu.pku.Activityheihei for onClick handler on view class android.widget.Button with id 'btnmanifest'

想给Button中加入点击事件

[html] view plain copy

1. <Button  
2.     android:id="@+id/btnmanifest"  
3.     … …  
4.     android:onClick="onClickBtnManifest" />  

Activity中实现如下

[java] view plain copy

1. private void onClickBtnManifest() {  

2.     Toast.makeText(Activityheihei.this, "button manifest", Toast.LENGTH_SHORT).show();  

3. }  

该函数需要加入参数View v，之后还是这个错误。private改为public即可。

[java] view plain copy

1.   public void onClickBtnManifest(View v) {  

2.         Toast.makeText(Activityheihei.this, "button manifest", Toast.LENGTH_SHORT).show();  

3.     }  

4、Unable to resolve target 'android-5'

使用高版本的SDK后再导入以前用低版本的project时，会遇到一些兼容性的问题。

需要将project.properties中的target=android-5改为target=android-7就好了。
但要注意，也要同步将AndroidManifest.xml中的改为，否则编译中会警告提示使用的版本过低。

参考 http://blog.sina.com.cn/s/blog_64edd5040100nu0d.html

android通过USB使用真机调试程序

我的机子很老，开启个android模拟器都要好几分钟，但幸亏有个android的真机，这样直接在andriod手机上调试也是一个不错的选择。下面我就介绍 一下使用android手机来调试android应用程序所需要的步骤：（典型的Hello World程序）

1、手机通过数据线连接在电脑上

2、设置android手机为USB调试模式。步骤： menu—> 设置 —> 应用程序 —> 开发 , 选择【USB调试】

3、如果是window系统，系统会提示安装驱动：

选择正确的android sdk安装目录，然后点击下一步，系统就开始安装驱动了

4、驱动安装完成之后，重启电脑（通常系统会有“安装新驱动，重启才能生效”的提示），这但应该明白吧

5、重复第1步和第2步，打开命令窗口，检测手机设备是否已经被识别，如下所示：

“HT99YLG11834 device”就是检测到得手机设备

6、接下来就开始在eclipse上调试android程序了，右击android工程->Run as->Android Application,弹出如下窗口：（重新启动系统之后才有这样的效果）

7、选中手机设备，点击OK之后，程序就开始在真机上安装了，控制台输出如下信息：

[2011-04-07 22:24:49 - HelloWorld] Uploading HelloWorld.apk onto device ‘HT99YLG11834′
[2011-04-07 22:24:49 - HelloWorld] Installing HelloWorld.apk…
[2011-04-07 22:24:53 - HelloWorld] Success!
[2011-04-07 22:24:53 - HelloWorld] Starting activity com.eightqiu.activity.StatsResultActivity on device
[2011-04-07 22:24:57 - HelloWorld] ActivityManager: Starting: Intent {act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER]cmp=com.eightqiu.activity/.StatsResultActivity }

8、运行这个应用程序，这样就可以使用手机来测试了

3， Android开发真机测试方法

方法如下：

（1）开机一部Android手机（当让Pad也行）

（2）在手机中：设置-->应用程序-->开发-->USB调试

（3）插上USB

（4）在CMD中测试一下，连接是否正常，CMD中命令如下：

adb devices   回车

若显示你的设备名，则证明连接正常。

（4）改写AndroidManifest.xml

注意：加的是绿的这句。

（5）执行真机调试操作：

在Eclipse中右键项目-->Debug As-->Debug Configurations-->Target选项卡-->选择Manual

-->点击下面Debug-->选择你的设备-->OK

这时你的设备就会开始执行你的Android程序啦！很流畅。

下次再想调试时，可以点击Run然后选择你的设备，然后OK，就可以啦。

（6）注意：无论是否用Eclipse

任何Android软件只要在真机上运行发生异常，都可以在命令行窗口下查看具体的异常

在CMD中输入：adb logc at    回车

注意查看以Causeby开头的行，这些行指明了在哪行代码出错了…………………….

4、Android Activity去除标题栏和状态栏

一、在代码中设置 

public void onCreate(Bundle savedInstanceState) { 
super.onCreate(savedInstanceState); 
//去除title  
requestWindowFeature(Window.FEATURE_NO_TITLE);  
//去掉Activity上面的状态栏 
getWindow().setFlags(WindowManager.LayoutParams. FLAG_FULLSCREEN , WindowManager.LayoutParams. FLAG_FULLSCREEN); 
   setContentView(R.layout.main); 
} 

或者 

requestWindowFeature(Window.FEATURE_CUSTOM_TITLE); 
getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.custom_title_1); 

R.layout.custom_title_1  这个就是你的标题文件布局 

二、在配置文件里修改 

(关键代码：android:theme="@android:style/Theme.NoTitleBar.Fullscreen"，如果想只是去除标题栏就后面不用加Fullscreen了，另外，如果想要整个应用都去除标题栏和状态栏，就把这句代码加到<application。。标签里面，如果只是想某个activity起作用，这句代码就加到相应的activity上): 

隐藏标题栏需要使用预定义样式：android:theme=”@android:style/Theme.NoTitleBar”. 

隐藏状态栏：android:theme=”@android:style/Theme.NoTitleBar.Fullscreen”. 
在这里我还想说明一下，用前者在我们应用运行后，会看到短暂的状态栏，然后才全屏，而第二种方法是不会有这种情况的，所以我建议大家使用后者！

Android Activity去除标题栏和状态栏

最简单的方法是在配置文件(AndroidManifest.xml)里修改

Xml代码  

1. android:theme="@android:style/Theme.NoTitleBar.Fullscreen"   

注意：

1. 如果想只是去除标题栏就后面不用加Fullscreen了。
2. 如果想要整个应用都去除标题栏和状态栏，就把这句代码加到标签里面。
3. 如果只是想某个activity起作用，这句代码就加到相应的标签上。

Android去掉标题栏和全屏都是件很容易的事情，最常见的有两种方法：

第一：在程序代码中实现
Java代码this.requestWindowFeature(Window.FEATURE_NO_TITLE);//去掉标题栏

this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);//去掉信息栏

this.requestWindowFeature(Window.FEATURE_NO_TITLE);//去掉标题栏

this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);//去掉信息栏
注意：这两行代码要写在页面显示之前，即setContentView(R.layout.XXX)之前
第二：在AndroidManifest.xml配置文件中实现标签android:theme
Java代码<activity android:name="Activity1"

android:theme="@android:style/Theme.NoTitleBar.Fullscreen">

<activity android:name="Activity1"

android:theme="@android:style/Theme.NoTitleBar.Fullscreen">
注意：如果不需要全屏，只需要写成android:theme="@android:style/Theme.NoTitleBar即可
总结：二者的区别
如果使用第一种方法，在Activity启动时会有短暂的标题栏和信息栏的出现，随后会消失。
使用第二种方法这不会出现这种情况，个人推荐使用第二种方式，看起来比较流畅。

Android Activity 常用功能设置（全屏、横竖屏等）

Activity全屏设置

方式1：AndroidManifest.xml

方式2：代码实现

requestWindowFeature(Window.FEATURE_NO_TITLE);  // 隐藏标题栏

getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);  // 隐藏状态栏

注意：设置全屏的俩段代码必须在setContentView(R.layout.main) 之前，不然会报错。

Activity横竖屏设置

方式1：AndroidManifest.xml

 // 或者 “portrait”

方式2：代码实现

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);

获取横屏方向

int orientation = this.getResources().getConfiguration().orientation;

orientation 的常用取值可以为 ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE（横屏） 或 ActivityInfo.SCREEN_ORIENTATION_PORTRAIT（竖屏）

Activity屏幕一直显示

1：AndroidManifest.xml添加权限

2：代码实现

getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

android中获得屏幕、视图、任务栏、状态栏的高宽以及屏幕的设置

首先，有一点需要声明，其实在android中，画布Canvas的高宽其实是屏幕的高宽。

如此一来，获得屏幕高宽的方法就很多了：

1. Java代码

2. WindowManager windowManager = getWindowManager();   

3. Display display = windowManager.getDefaultDisplay();   

4. screenWidth = display.getWidth();   

5. screenHeight = display.getHeight();  

[java] view plain copy print ?

1. WindowManager windowManager = getWindowManager();  

2. Display display = windowManager.getDefaultDisplay();  

3. screenWidth = display.getWidth();  

4. screenHeight = display.getHeight();  

Java代码

1. DisplayMetrics dm = new DisplayMetrics();   

2. this.getWindowManager().getDefaultDisplay().getMetrics(dm);//this指当前activity  

3. screenWidth =dm.widthPixels;   

4. screenHeight =dm.heightPixels;  

[java] view plain copy print ?

1. DisplayMetrics dm = new DisplayMetrics();  

2. this.getWindowManager().getDefaultDisplay().getMetrics(dm);//this指当前activity  

3. screenWidth =dm.widthPixels;  

4. screenHeight =dm.heightPixels;  

以上两种方法在屏幕未显示的时候，还是处于0的状态，即要在setContentView调用之后才有效。

3. 还可以在onDraw中由canvas来获得

Java代码

1. screenWidth =canvas.getWidth();   

2. screenHeight =canvas.getHeight();  

[java] view plain copy print ?

1. screenWidth =canvas.getWidth();  

2. screenHeight =canvas.getHeight();  

而视图的高宽则是大多数人所认为的canvas的高宽，其实他所指的是除了任务栏和状态栏的高宽，主要有如下方法：

1. Java代码

2. viewWidth=this.getWidth();   

3. viewHeight=this.getHeight();  

[java] view plain copy print ?

1. viewWidth=this.getWidth();  

2. viewHeight=this.getHeight();  

2.重写view的onSizeChanged，该方法会在onCreate之后，onDraw之前调用

Java代码

1. protected void onSizeChanged(int w, int h, int oldw, int oldh) {   
2. viewHeight=h;   
3. viewWidth=w;   
4. super.onSizeChanged(w, h, oldw, oldh);   
5. }  

[java] view plain copy print ?

1. protected void onSizeChanged(int w, int h, int oldw, int oldh) {  
2. viewHeight=h;  
3. viewWidth=w;  
4. super.onSizeChanged(w, h, oldw, oldh);  
5. }  

任务栏、状态栏的高宽的高宽我目前还不清楚，不过从网上查找可知：

引用

frameworks/core/res/values/themes.xml
25dip
frameworks/core/res/values/dimens.xml
25dip

在一个activity中如果要获取高宽，最好是放在onSizeChanged中比较保险。

以上是我对android获得高宽的一点总结，如果有错误的地方，欢迎留言探讨。

另外，还有对屏幕显示的一些设置：

//设置为无标题

Java代码

1. requestWindowFeature(Window.FEATURE_NO_TITLE);  

[java] view plain copy print ?

1. requestWindowFeature(Window.FEATURE_NO_TITLE);  

//设置为全屏模式getWindow().setFlags

Java代码

1. getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);  

[java] view plain copy print ?

1. getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);  

//设置为横屏

Java代码

1. setRequesteOrientation(ActivityInfo.SCREEN_ORIENTATION_LADSCAPE);  

转自 http://yuyanshan.javaeye.com/blog/750043

Android getWindow().setFlags方法

//设置窗体全屏

getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);

//设置窗体始终点亮

getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,

      WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

//设置窗体背景模糊

getWindow().setFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND,
WindowManager.LayoutParams.FLAG_BLUR_BEHIND);

设置Activity的背景颜色

前提是需要在value目录下的string.xml文件中加入一段代码：

Xml代码  

1. <drawable name="bkcolor">#ff00ff</drawable>  

其中的颜色值可以自己设置。

以下为两种方法:

一.从代码中设置

1.首先导入必要的包：

Java代码  

1. import android.content.res.Resources;  
2. import android.graphics.drawable.Drawable;  

2.然后在onCreate()函数中加入以下代码：

Java代码  

1. Resources res = getResources();  
2. Drawable drawable = res.getDrawable(R.drawable.bkcolor);  
3. this.getWindow().setBackgroundDrawable(drawable);  

二.从布局文件（例如main.xml）中设置

在<…layout>标签中加上以下代码

Xml代码  

1. android:background="@drawable/bkcolor"

Android自适应屏幕方向、大小和分辨率

Android自适应屏幕方向、大小和分辨率

屏幕大小

1、不同的layout

Android手机屏幕大小不一，有480x320，640x360，800x480.怎样才能让App自动适应不同的屏幕呢？ 其实很简单，只需要在res目录下创建不同的layout文件夹，比如：layout-640x360，layout-800x480，所有的layout文件在编译之后都会写入R.java里，而系统会根据屏幕的大小自己选择合适的layout进行使用。

2、hdpi、mdpi、ldpi

前的版本中，只有一个drawable，而2.1版本中有drawable-mdpi、drawable-ldpi、drawable-hdpi三个，这三个主要是为了支持多分辨率。

drawable- hdpi、drawable- mdpi、drawable-ldpi的区别：

1. drawable-hdpi里面存放高分辨率的图片，如WVGA (480x800),FWVGA (480x854)
2. drawable-mdpi里面存放中等分辨率的图片，如HVGA (320x480)
3. drawable-ldpi里面存放低分辨率的图片，如QVGA (240x320)

系统会根据机器的分辨率来分别到这几个文件夹里面去找对应的图片。在开发程序时为了兼容不同平台不同屏幕，建议各自文件夹根据需求均存放不同版本图片。

屏幕方向

1、横屏竖屏自动切换

可以在res目录下建立layout-port和layout-land两个目录，里面分别放置竖屏和横屏两种布局文件，这样在手机屏幕方向变化的时候系统会自动调用相应的布局文件，避免一种布局文件无法满足两种屏幕显示的问题。

2、禁用自动切换

只需要在AndroidManifest.xml文件中加入android:screenOrientation属性限制。

限制此页面横屏显示

Xml代码  

1. Android:screenOrientation="landscape"  

Xml代码  

限制此页面数竖屏显示

Xml代码  

1. Android:screenOrientation="portrait"   

字体自适应大小

方法1：

首先根据不同分辨率获取不同字体大小。 
在RES里创建
values-480x320/strings.xml 里面设置

Xml代码  

1. <dimen name="Text_size">30px</dimen>  

 和 
values-800x400/strings.xml 里面设置

Xml代码  

1. <dimen name="Text_size">40px</dimen>   

分别代表480X320 和 800X400分辨率情况下 字号为30px和40px;

在java文件中这样调用

Java代码  

1. int sizeOfText = (int) this.getResources().getDimension(R.dimen.Text_size);  

 

方法2：

在视图的onsizechanged里获取视图宽度，一般情况下默认宽度是320，所以计算一个缩放比率rate = (float) w/320   （w是实际宽度）
然后在设置字体尺寸时 paint.setTextSize((int)(8*rate));   （8是在分辨率宽为320 下需要设置的字体大小实际字体大小 = 默认字体大小 x  rate）

6,设置主Activity.

主Activity必须在manifest文件中使用标签，并包含MAIN action和LAUNCHER 内容。例如：

注： 当你创建一个新的Android项目，默认的项目会包含一个Activity类，并且此类会有如上的声明。

如果任何一个activity声明都不包含android.intent.action.MAIN或android.intent.category.LAUNCHER，那么您的应用程序的图标就不会出现在android的主屏菜单列表上了。.

7,销毁Activity的特例

注意 ：一般来说，系统会在调用onPause()方法和onStop()之后才调用onDestory()方法，但是，有一种情况是例外的，那就是在你在onCreate()方法中调用finish()方法。在一些情况下，你的Activity作为一个临时决定的操作对象而去启动另外一个Activity时，你可能需要在onCreate()方法中调用finish()方法去销毁Activity，在这种情况中，系统会直接调用onDestroy()方法而不用再去调用其他的生命周期函数。

Android结束Activity退出程序的一种有效方法

关于完全退出Android程序，网上这方面的帖子很多，方法也很多。记得当时自己写的第一个比较完整的项目的时候就遇上了这个问题，由于对Activity的生命周期了解不够，又使用了TabActivity使得层次关系比较复杂，在程序中添加的“退出”菜单项经常无法完全退出，之后网上各种搜索，各种方法也试过了，什么System.exit(0)啊，结束进程之类的啊，都依然无效果。

后面才发现的这个方法。思路也很简单，回想自己当初为了解决这个问题时的苦苦寻觅，遂决定将其共享，供遇到此问题人士作为参考。

啰嗦够了，上思路：添加一个全局变量作为程序退出的标记（boolean类型），当需要退出程序时置为true，程序中每个Activity的onStart方法中对该变量进行判断，为true就结束自己。

看代码吧：

使用Application来保存一个全局变量isProgramExit。（对Application使用不熟悉的话查看相关资料）

public class MyApplication extendsApplication {

// 程序退出标记
private static boolean isProgramExit = false;

public void setExit(booleanexit) {

isProgramExit= exit;

}

public booleanisExit() {

return isProgramExit;

}

}

在你退出时需要结束的每个Activity的 onStart方法加上以下代码：

protected voidonStart() {

super.onStart();

MyApplication mApp = (MyApplication)getApplication();

if(mApp.isExit()) {

finish();

}

}

比如，程序中有三个Activity，A —— B —— C；现在在C中有个按钮，点击退出整个程序。按照上面说的，在A和B的onStart方法中加入判断代码（C中可以不加），C中点击按钮时执行：

MyApplication mApp = (MyApplication)getApplication();

mApp.setExit(true);

finish();

这样C结束了自己，按照流程会回到B，然后B中会进行判断，因为退出条件满足，结束自己；再回到A，同样也结束……

可以看到，这种方法并不高明，甚至有些复杂，因为要在每个Activity的onStart中都加上判断。但不可否认的是这种方法却是绝对有效的，不管你的程序中Activity如何跳转来跳转去，只要一声令下，通通结束，屡试不爽。

所以，有遇到程序退出问题的朋友可以作为参考。

感觉这个方法似乎还存在些问题吧。如果直接这样写，那么虽然退出了程序，但是这只是让程序变成了空进程，如果这个时候再点击程序，那么Application中的全局变量应该还是有效的，这样将导致程序在启动的时候就直接退出。应该在activity的oncreate方法中重新设置这个值吧，但是这样会有一个潜在的问题，比如我们从启动的activity是A-B-C,那么这样栈里就依次存放着A,B,C, 如果此时由于某种原因导致A被销毁了（这种情况应该是存在的， onSaveInstanceStatus方法就是针对这种情况吧），那么这是用这个方法退出的话，当取得栈中A的时候，由于A被销毁了，这是会调用A的oncreate方法，而oncreate方法中如果又重新设置了全局变量的值，这时就不能正常退出了。 所以是不是需要在onSaveInstanceStatus这个方法里做一些特殊处理？

动态的修改自定义custom title

在android中 getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.text_title);     使用上面的话时 他所产生的并不是把以前的用现在的替换只是用   R.layout.text_title放在了默认样式的上面，如果你想通过一个按钮修改标题
以及view上的消息有两种方法：
private void setCustomTitleFeatureInt(int value) {  
       try {        // retrieve value for com.android.internal.R.id.title_container(=0x1020149)      
         int titleContainerId = (Integer) Class.forName(               
         "com.android.internal.R$id").getField("title_container").get(null);       
         // remove all views from titleContainer     
           ((ViewGroup) getWindow().findViewById(titleContainerId)).removeAllViews();     
             // add new custom title view       
              getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, value);
                  } catch(Exception ex) {       
                  // whatever you want to do here..    }
                  }

这种方法是取消以前的 不过这种方法可靠性不好
2.你可以用隐藏的方式：
findViewById(R.id.custom_title_1).setVisibility(View.GONE);getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.custom_title_2);

1.得到屏幕的screen dimensions
Display display = getWindowManager().getDefaultDisplay();
int width = display.getWidth();int height = display.getHeight();

2. 播放 gif图片在android
@Override protected void onDraw(Canvas canvas) {          
canvas.drawColor(0xFFCCCCCC);                      
  Paint p = new Paint();           
  p.setAntiAlias(true);         
     
     canvas.drawBitmap(mBitmap4, 210, 170, null);           
     mDrawable.draw(canvas);           
     long now = android.os.SystemClock.uptimeMillis();          
      if (mMovieStart == 0) {   // first time                mMovieStart = now;            }           
      if (mMovie != null) {               
        int dur = mMovie.duration();               
           if (dur == 0) {                   
              dur = 1000;                }               
              int relTime = (int)((now - mMovieStart) % dur);               
              mMovie.setTime(relTime);             
                mMovie.draw(canvas, getWidth() - mMovie.width(),                         
                  getHeight() - mMovie.height());              
                   invalidate();           
                   }      
                    }
http://developer.android.com/guide/samples/ApiDemos/src/com/example/android/apis/graphics/BitmapDecode.html
@Override
                    protected void onDraw(Canvas canvas) {
                        if(movie != null) {
                                long now = android.os.SystemClock.uptimeMillis();
                                        int dur = Math.max(movie.duration(), 1);
                                        // is it really animated?       
                                        int pos = (int)(now % dur);       
                                        movie.setTime(pos);       
                                        movie.draw(canvas, x, y);
                                         invalidate();   
                                 }}

4. 打开sd卡中的sqllite
File dbfile = new File("/sdcard/mydb.sqlite" );
                                  SQLiteDatabase db = SQLiteDatabase.openOrCreateDatabase(dbfile, null);

5.得到手机的IMEI
((TelephonyManager) getSystemService=(Context.TELEPHONY_SERVICE)).getDeviceId();

6. 不让程序 生成一个appliation 去掉

当然你的让你的程序 被引导启动

7.使用appliation 的id 可以获得不同appliation的数据：
android:sharedUserId="string" 在主xml中添加上面一句话，然后签名也要一样 两个app的id也要设置成一样 如都是string 那么这两个程序就可以相互访问彼此的数据，也可以在同一个process中了
8.判断相机设备存在不
private android.hardware.Camera mCameraDevice;
try { 
    mCameraDevice = android.hardware.Camera.open();}
catch (RuntimeException e) {  Log.e(TAG, "fail to connect Camera", e);

9使listView 透明
android:background="#00000000"
android:cacheColorHint="#00000000"
或者
android:background="@android:color/transparent"

•The background android screen image should be visible.
屏幕的背景图像可以看见
manifest file 添加attribute 到 activity.
android:theme="@android:style/Theme.Dialog"

Android开发：定制Activity的标题栏(Titlebar)

缺省的情况下，通常见到Activity的标题栏(Titlebar)是这样的(红色框内)：

HandleContacts是Activity的标题。

有时候，我们希望能改变一下这样单调的状况。比如，要在标题栏中增加一个用于美化界面的图标、增一个输入框或按钮之类的，怎样才能做到这一点呢？我们不妨来看一个实际的例子。

1.    首先如下创建一个Android项目

2.    将图片magnifier.png拖入该项目的res/drawable-mdpi文件夹下。magnifier.png图片的样子是这样的：

3.    在该项目的res/layout文件夹下，创建一个布局titlebar.xml，这个布局将用于定制Activity的标题栏

编辑titlebar.xml，使其内容如下：

<LinearLayout

xmlns:Android=_"http://schemas.android.com/apk/res/android"_

android:orientation="horizontal"

android:layout_width="fill_parent"

android:layout_height="wrap_content">

<ImageView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:src="@drawable/magnifier"

android:gravity="bottom"

/>

<TextView

android:layout_width="wrap_content"

android:layout_height="38dip"

android:text="@string/app_name"

android:textColor="#FFFFFFFF"

android:textSize="14dip"

android:paddingTop="1dip"

/>

<EditText

android:id="@+id/searchparameter"

android:layout_width="wrap_content"

android:layout_height="38dip"

android:text="ABCDEFGHIJ"

android:textSize="14dip"

android:layout_margin="1dip"

/>

<Button android:id="@+id/button"

android:layout_width="wrap_content"

android:layout_height="38dip"

android:text="OK"

android:textSize="14dip"

/>

在上面的LinearLayout中，增加了以下控件：

一个ImageView，用于显示一个图标

一个TextView，用于显示应用的名称

一个EditText，用于接收输入

一个Button，用于测试

4.    修改CustomizeTitlebar.java，使之如下：

public class CustomizeTitlebar extends Activity

{

@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);

setContentView(R.layout.main);

getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.titlebar);

}

}

以上加粗的两行很重要，而且必须要严格按照上面那样的顺序出现在代码中。即：

requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);必须出现在super.onCreate(savedInstanceState);之后，setContentView(R.layout.main);之前。其意思就是告诉系统，本程序要自己定义Titlebar；

getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE,R.layout.titlebar); 则必须出现在setContentView之后，其意思就是告诉系统，自定义的布局是R.layout.titlebar(即，我们前面编写的titlebar.xml)

到这里，不妨来运行一下，看看结果如何：

我们看到，Titlebar基本上按照我们的意思进行了改变，但也存在着一个缺陷：Titlebar太窄了，那么怎样改变Titlebar的高度呢？

5.    要改变Titlebar的高度，我们得先创建styles.xml：

编辑styles.xml，使其内容如下：

上面39dip这一句，就是用来设定Titlebar的高度的。

6.    在上面的基础上，我们需要修改AndroidManifest.xml中，相应Activity的属性。如下：

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

package="com.pat.customizetitlebar"

android:versionCode="1"

android:versionName="1.0">

<activity android:name=".CustomizeTitlebar"

android:label="@string/app_name"

android:theme="@style/titlebarstyle">

注意粗体字是新增上去的，其中的titlebar是在第5步中增加的。现在来看看运行结果：

可以看到结果完全符合了我们的要求。

7.    我们还可以改变Titlebar的背景颜色。为此我们修改前面的styles.xml，使之如下：

注意，其中的粗体字是新增加的。

项目其他文件，均无需变动。运行结果如下：

8.    最后，我们以OK按钮为例来测试Titlebar上的控件的事件响应。为此，修改CustomizeTitlebar.java，使之如下：

public class CustomizeTitlebar extends Activity

implements

OnClickListener

{

private Button button;

@Override

public void onCreate(Bundle savedInstanceState)

{

super.onCreate(savedInstanceState);

requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);

setContentView(R.layout.main);

getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.titlebar);

button = (Button)findViewById(R.id.button);

button.setOnClickListener(this);

}

public voidonClick(View v)

{

if(v.getId() == R.id.button)

{

Toast.makeText(this, "OK button in Titlebar clicked…", Toast.LENGTH_LONG).show();

}

}

}

粗体字部分是新增加的代码。重新运行本项目，等界面出来后，点击Titlebar上的OK按钮，将出现：

这说明，Titlebar上自己增加上去的控件，可以很好地响应相关的事件。

Android 应用程序窗体显示状态操作（requestWindowFeature()的应用）

我们在开发程序是经常会需要软件全屏显示、自定义标题（使用按钮等控件）和其他的需求，今天这一讲就是如何控制Android应用程序的窗体显示.

　　首先介绍一个重要方法那就是requestWindowFeature(featrueId),它的功能是启用窗体的扩展特性。参数是Window类中定义的常量。

一、枚举常量

1.DEFAULT_FEATURES：系统默认状态，一般不需要指定

2.FEATURE_CONTEXT_MENU：启用ContextMenu，默认该项已启用，一般无需指定

3.FEATURE_CUSTOM_TITLE：自定义标题。当需要自定义标题时必须指定。如：标题是一个按钮时

4.FEATURE_INDETERMINATE_PROGRESS：不确定的进度

5.FEATURE_LEFT_ICON：标题栏左侧的图标

6.FEATURE_NO_TITLE：吴标题

7.FEATURE_OPTIONS_PANEL：启用“选项面板”功能，默认已启用。

8.FEATURE_PROGRESS：进度指示器功能

9.FEATURE_RIGHT_ICON:标题栏右侧的图标

二、详解

默认显示状态

图1默认

1.FEATURE_CUSTOM_TITLE详解

this.requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);
        setContentView(R.layout.main);

图2 无标题

这是因为没设置Featrue

在上面代码后加：getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.title);　

　

图3自定义标题

自定义标题完成，它是一个xml文件布局

title.xml

xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="wrap_content"
android:layout_height="wrap_content" >

3.FEATURE_INDETERMINATE_PROGRESS详解

表示一个进程正在运行

　　　　图4标题进度条显示

实现代码

1.progress.xml

xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="wrap_content"
android:layout_height="wrap_content">

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_gravity="center_vertical"
style="?android:attr/progressBarStyleSmallTitle">

2.Java代码

this.requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.main);

getWindow().setFeatureInt(Window.FEATURE_INDETERMINATE_PROGRESS, R.layout.progress);
setProgressBarIndeterminateVisibility(true);

3.FEATURE_LEFT_ICON详解

左侧显示图标

图5

实现代码

  this.requestWindowFeature(Window.FEATURE_LEFT_ICON);
  setContentView(R.layout.main);
  
  getWindow().setFeatureDrawableResource(Window.FEATURE_LEFT_ICON, R.drawable.icon);

4.FEATURE_NO_TITLE详解

 可用于全屏显示

实现代码

this.requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.main);

getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);

 

图6全屏显示

android开发中经常会在setContentView(R.layout.XXX); 前设置requestWindowFeature(XXXX)。

他的意思是需要软件全屏显示、自定义标题（使用按钮等控件）和其他的需求

首先介绍一个重要方法那就是requestWindowFeature(featrueId),它的功能是启用窗体的扩展特性。参数是Window类中定义的常量。

一、枚举常量

1.DEFAULT_FEATURES：系统默认状态，一般不需要指定

2.FEATURE_CONTEXT_MENU：启用ContextMenu，默认该项已启用，一般无需指定

3.FEATURE_CUSTOM_TITLE：自定义标题。当需要自定义标题时必须指定。如：标题是一个按钮时

4.FEATURE_INDETERMINATE_PROGRESS：不确定的进度

5.FEATURE_LEFT_ICON：标题栏左侧的图标

6.FEATURE_NO_TITLE：没有标题

7.FEATURE_OPTIONS_PANEL：启用“选项面板”功能，默认已启用。

8.FEATURE_PROGRESS：进度指示器功能

9.FEATURE_RIGHT_ICON:标题栏右侧的图标

二、详解

默认显示状态

1.FEATURE_CUSTOM_TITLE详解

Java代码  

1. this.requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);  

2. setContentView(R.layout.main);  

这是因为没有设置Featrue

在上面代码后加：getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.title);

自定义标题完成，它是一个xml文件布局

Xml代码  

1.   

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

3.     android:layout_width="wrap_content"  

4.     android:layout_height="wrap_content" >  

5.     <ImageView  

6.         android:layout_width="wrap_content"  

7.         android:layout_height="wrap_content"  

8.         android:src="@drawable/ic_launcher"  

9.         />  

10.     <TextView  

11.         android:id="@+id/text"  

12.         android:layout_width="wrap_content"  

13.         android:layout_height="wrap_content"  

14.         android:layout_alignParentLeft="true"  

15.         android:textColor="#000000"  

16.         android:text="FEATURE_CUSTOM_TITLE" />  

17. </LinearLayout>  

2.FEATURE_INDETERMINATE_PROGRESS详解

可以用来表示一个进程正在运行

Java代码  

1. this.requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);  

2. setContentView(R.layout.main);  

3. getWindow().setFeatureInt(Window.FEATURE_INDETERMINATE_PROGRESS, R.layout.progress);  

4. setProgressBarIndeterminateVisibility(true);  

Xml代码  

1.   

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

3.     android:layout_width="wrap_content"  

4.     android:layout_height="wrap_content" >  

5.     <ProgressBar  

6.         android:id="@+id/progress"  

7.         style="?android:attr/progressBarStyleSmallTitle"  

8.         android:layout_width="wrap_content"  

9.         android:layout_height="wrap_content"  

10.         android:layout_gravity="center_vertical" >  

11.     </ProgressBar>  

12. </LinearLayout>  

3.FEATURE_LEFT_ICON和FEATURE_RIGHT_ICON详解

Java代码  

1. requestWindowFeature(Window.FEATURE_RIGHT_ICON);  
2. setContentView(R.layout.main);      
3. getWindow().setFeatureDrawableResource(Window.FEATURE_RIGHT_ICON,R.drawable.ic_launcher);  

Java代码  

1. requestWindowFeature(Window.FEATURE_LEFT_ICON);  
2. setContentView(R.layout.main);          
3. getWindow().setFeatureDrawableResource(Window.FEATURE_LEFT_ICON,R.drawable.ic_launcher);  

 

 4.FEATURE_NO_TITLE详解

Java代码  

1. this.requestWindowFeature(Window.FEATURE_NO_TITLE);  

2. setContentView(R.layout.main);  

Java代码  

1. getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);  

Manifast.xml中的属性 理解

        

[html] view plain copy

1. <activity     android:name=".Test"  android:theme="@style/Sub" android:screenOrientation="portrait"></activity>  

values文件夹下的themes.xml文件中

[html] view plain copy

1. <style name="SubTitleBackground">   

2.         <item name="android:background">#BA3A37</item>   

3.     </style>  

4.     <style name="Sub" parent="android:Theme">   

5.         <item name="android:windowTitleSize">40dp</item>   

6.         <item name="android:windowTitleBackgroundStyle">@style/SubTitleBackground</item>  

7.         <item name="android:windowBackground">#E88024</item>  

8.     </style> 

android退出整个程序

1. public boolean onKeyDown(int keyCode, KeyEvent event) {  
2.         // 当点击返回按钮时，退出程序  
3.         if (keyCode == KeyEvent.KEYCODE_BACK) {  
4.             android.os.Process.killProcess(android.os.Process.myPid());  
5.         }  
6.         return super.onKeyDown(keyCode, event);  
7.     } 

Android释放内存（结束进程）  

2012-06-06 22:04:46|  分类：Android|字号 订阅

这两天在搞个内存清理小插件，网上很少这方面资料，之前找过清理缓存的例子测试，结果不成功。后来自己思考该怎么清理内存，于是成功搞出来了。

这两个方法是网上拷别人的，分别用来得到可用内存和内存总数，这样我们就可用得到了已用内存数。

    private long getAvailMemory(Context context)
    {
        // 获取android当前可用内存大小
        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        MemoryInfo mi = new MemoryInfo();
        am.getMemoryInfo(mi);
        //mi.availMem; 当前系统的可用内存

        //return Formatter.formatFileSize(context, mi.availMem);// 将获取的内存大小规格化
        return mi.availMem/(1024*1024);
    }

    private long getTotalMemory(Context context)
    {
        String str1 = "/proc/meminfo";// 系统内存信息文件
        String str2;
        String[] arrayOfString;
        long initial_memory = 0;

        try
        {
            FileReader localFileReader = new FileReader(str1);
            BufferedReader localBufferedReader = new BufferedReader(
            localFileReader, 8192);
            str2 = localBufferedReader.readLine();// 读取meminfo第一行，系统总内存大小

            arrayOfString = str2.split(" \\s+");
            for (String num : arrayOfString) {
                Log.i(str2, num + "\t");
            }

            initial_memory = Integer.valueOf(arrayOfString[1]).intValue() * 1024;// 获得系统总内存，单位是KB，乘以1024转换为Byte
            localBufferedReader.close();

        } catch (IOException e) {
        }
        //return Formatter.formatFileSize(context, initial_memory);// Byte转换为KB或者MB，内存大小规格化
        return initial_memory/(1024*1024);
    }

在Service里面清理内存

自己写的小方法，通过判断进程信息来判断哪些进程是无用的可用杀掉

ActivityManager activityManger=(ActivityManager) this.getSystemService(ACTIVITY_SERVICE);
           List list=activityManger.getRunningAppProcesses();
           if(list!=null)
           for(int i=0;iActivityManager.RunningAppProcessInfo.IMPORTANCE_SERVICE)
               {
                  // Process.killProcess(apinfo.pid);
                   for(int j=0;j<pkgList.length;j++)
                   {
                       //2.2以上是过时的,请用killBackgroundProcesses代替
                       activityManger.restartPackage(pkgList[j]);
                   }
               }

           }

解析如下：

RunningAppProcessInfo 得到正在运行的进程信息

pkgList:得到该进程下运行的包名

importance:该进程的重要程度

importance分为几个级别，数值越低就越重要。数值对应的重要性请看api,我判断是大于ActivityManager.RunningAppProcessInfo.IMPORTANCE_SERVICE的都杀掉，一般数值大于ActivityManager.RunningAppProcessInfo.IMPORTANCE_SERVICE的进程都长时间没用或者空进程了。

最后通过for循环把包名对应进程杀掉：

2.2版本以下的用activityManger.restartPackage(pkgList[j]);   对应权限

2.2以上的用killBackgroundProcesses(包名);    对应权限

之前我以为可用android.os.Process.killProcess(pid);来杀掉其他进程，后来发觉不行

网上找到的解析是

对于这个方法，需要详细解释一下。在SDK的文档中，解释如下：

Kill the process with the given PID. Note that, though this API allows us to request to kill any process based on its PID, the kernel will still impose standard restrictions on which PIDs you are actually able to kill. Typically this means only the process running the caller's packages/application and any additional processes created by that app; packages sharing a common UID will also be able to kill each other's processes.

英语不好，不能准确翻译，所以希望大家自己理解，免得对大家造成误解。我个人对这句话的解释就是，这个方法使用是有条件的：

a、将被杀掉的进程 和 当前进程 处于同一个包或者应用程序中；

b、将被杀掉的进程 是由当前应用程序所创建的附加进程；

c、将被杀掉的进程 和 当前进程 共享了普通用户的UID。（这里的普通用户，是相对于Root权限的用户来说的）

android Debuger 出现："Waiting for Debugger - Application XXX is waiting for the debugger to Attach"

在eclipse中进行调试时经常出现下面这样的提示
Application XXX  is waiting for the debugger to attach

但是一般情况下，过了一会之后会进入调试状态，但有时进行调试的时候模拟器上九一直停留在上面这个提示对话框，一直不能进入调试状态。。。加打印调试太麻烦而且效率太低了。

解决办法如下：
 
1、在按照网上说的在dos命令行中进行
adb kill-server
adb start-server
两个命令操作之后偶尔会有效（进入调试状态）

2、同时打开了两个eclipse进行调试，关掉一个eclipse之后便正常了
个人认为这是一个eclipse的bug，即不能同时打开多个eclipse进行调试
这时模拟器可能不能正确辨别是哪个eclipse正在进行debug
从而会一直停留在“等待调试器连接”的提示上
但是不爽的一点是eclipse不能同时打开多个进行调试，想做手机之间的通信还真不方便debug

3、关掉eclipse重新启动试一下

4、关闭电脑或手机重新启动试一下

Android上dip、dp、px、sp等单位说明

Android的layout文件中有时候可能会指定具体的单位，比如有时候为px、dip或者sp等。他们的区别如下：

1. px (pixels)像素：这个大家用得比较多，一般我们HVGA代表320x480像素。

2. dip或dp (device independent pixels)设备独立像素：这个和设备硬件有关，一般我们为了支持WVGA、HVGA和QVGA cwj推荐使用这个，不依赖像素。在android上开发的程序将会在不同分辨率的手机上运行。为了让程序外观不至于相差太大，所以引入了dip的概念。比如定义一个矩形10 x 10dip.在分辨率为160dpi的屏上，比如G1，正好是10 x 10像素。而在240 dpi的屏，则是15 x 15像素.换算公式为pixs = dips * (density/160). density就是屏的分辨率

3. sp (scaled pixels — best for text size)放大像素：主要处理字体的大小。

下面的不经常用到:

4. in (inches)英寸

5. mm (millimeters)毫米

6. pt (points)点android:numColumns="auto_fit"，GridView的列数设置为自动android:columnWidth="90dp"，每列的宽度，也就是Item的宽度android:stretchMode="columnWidth"，缩放与列宽大小同步android:verticalSpacing="10dp"，两行之间的边距，如：行一(NO.0~NO.2)与行二(NO.3~NO.5)间距为10dp android:horizontalSpacing="10dp"，两列之间的边距。

dp与px转换的方法

public static int dip2px(Context context, float dipValue){

　　final float scale = context.getResources().getDisplayMetrics().density;

　　return (int)(dipValue * scale +0.5f);

　　} public static int px2dip(Context context, float pxValue){

　　final float scale = context.getResource().getDisplayMetrics().density;

　　return (int)(pxValue / scale +0.5f);

　　}

Android上dip、dp、px、sp等单位说明

[ dip: device independent pixels(设备独立像素).

不同设备有不同的显示效果,这个和设备硬件有关，一般我们为了支持WVGA、HVGA和QVGA 推荐使用这个，不依赖像素。

px: pixels(像素). 不同设备显示效果相同，一般我们HVGA代表320x480像素，这个用的比较多。  

pt: point，是一个标准的长度单位，1pt＝1/72英寸，用于印刷业，非常简单易用；

sp: scaled pixels(放大像素). 主要用于字体显示best for textsize。  

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

关于换算（以 sp 和 pt 为例）   

查看 TextView 等类的源码，可知：   

case COMPLEX_UNIT_PX:   

return value;   

case COMPLEX_UNIT_SP:   

return value * metrics.scaledDensity;   

case COMPLEX_UNIT_PT:   

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

－－－－－－－－－－－－－－－－－－－－－－－－－－   

scaledDensity = DENSITY_DEVICE / (float) DENSITY_DEFAULT;

xdpi = DENSITY_DEVICE;  

－－－－－－－－－－－－－－－－－－－－－－－－－－  

DENSITY_DEFAULT = DENSITY_MEDIUM = 160;   

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

所以： 假设 pt 和 sp 取相同的值 1，则可设 1pt 和 1sp 之间系数为 x，   

1 * DENSITY_DEVICE / 72 = x * 1 * DENSITY_DEVICE / 160 =>   

x = 160 / 72 = 2.2222   

也就是说在 Android 中， 1pt 大概等于 2.22sp   

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

 什么是Dip和Sp  

 过去，程序员通常以像素为单位设计计算机用户界面。例如，定义一个宽度为300像素的表 

单字段，列之间的间距为5个像素，图标大小为16×16像素 等。这样处理的问题在于，如 

果在一个每英寸点数（dpi）更高的新显示器上运行该程序，则用户界面会显得很小。在有 

些情况下，用户界面可能会小到难以看清 内容。    

与分辨率无关的度量单位可以解决这一问题。Android支持下列所有单位。   

px（像素）：屏幕上的点。   

in（英寸）：长度单位。   

mm（毫米）：长度单位。   

pt（磅）：1/72英寸。   

dp（与密度无关的像素）：一种基于屏幕密度的抽象单位。在每英寸160点的显示器上，1dp= 1px。   

dip：与dp相同，多用于android/ophone示例中。   

sp（与刻度无关的像素）：与dp类似，但是可以根据用户的字体大小首选项进行缩放。   

为了使用户界面能够在现在和将来的显示器类型上正常显示，建议大家始终使用sp作为文 字大小的单位，将dip作为其他元素的单位。当然，也可以考虑使用矢量图形，而不是用位图

android中不同手机分辨率适配问题 2011-06-22 12:59:02

标签： 分辨率 layout 匹配 android 移动开发

版权声明：原创作品，谢绝转载！否则将追究法律责任。

    在项目开发的过程中，同一个布局对应不同的手机会显示出不同的效果。导致这个现象产生的原因是不同手机的分辨率不同。在android sdk提供的帮助文档中，我们可以看到各种手机的分辨率和对应的屏大小。QVGA (240x320)，WQVGA400(240x400)，WQVGA432 (240x432)，HVGA (320x480)，WVGA800 (480x800)，WVGA854 (480x854)。

目前android手机的分辨率大致就是帮助文档中描述的几种，我们可以用两种方式进行不同手机的适配。一种是在java代码中，另外一种是在xml文件中。具体使用哪种方式更有效更合适，要看具体的情况而定。

在以前的项目中，我之前做过关于历史聊天记录，每页显示条数的匹配。不同的手机，每页可以显示历史记录的条数是不同的。我采用的是在java代码中做匹配。不同分辨率的手机，他们都有固定的屏高。例如，480x800，屏高是800,240x320，屏高是320。根据屏高为判定条件，为每一页显示历史记录的条数做一个限制。我个人觉得，在java代码中做手机匹配，要看匹配的布局中，控件是否太多，不太多，可以在java代码中根据不同的情况修改，否则，java代码将会显得很冗长，修改起来也很麻烦。

在xml进行手机匹配，主要是针对布局中控件太多，不方便在java代码中修改的情况。在xml中解决不匹配问题很简单，对于不同手机的分辨率，建立对应的layout文件即可。例如：480x800，之间建立layout-800x400,240x320，建立layout-320x240。特别注意：大的写在前面，例如800,320，小的写在后面，例如480,240。建立了相应的layout后，还要在不同的手机上调整布局中的控件大小和位置。

在本次项目中，我负责不同手机视图的匹配问题，我选择的是xml匹配方式，结果发现按上面的方式做了之后，对应分辨率的手机的显示没有任何的效果，后来，我查看帮助文档后，发现必须要在androidmainfest中进行如下代码的配置：

如果没有这几行代码，不管你怎么调整layout中的控件，对应分辨率的手机是没有任何效果的。注意：由于android版本的不同，有些版本不支持xlargeScreens，可以直接将android:xlargeScreens="true"去掉。

本文出自 “花样年华” 博客