BlogJava-咖啡伴侣-随笔分类-Android

新android的rom的log功能无法使用

oathleo — Thu, 21 Feb 2013 05:47:00 GMT

解决刷新rom后log功能默认屏蔽问题：
Logger
C:\Users\Leo>adb shell

shell@android:/ $ su

1|shell@android:/ # mount -o remount, rw /system

mount -o remount, rw /system

shell@android:/ # echo ANDROIDLOGGER >> /system/etc/tweaks.conf

echo ANDROIDLOGGER >> /system/etc/tweaks.conf

shell@android:/ # mount -o remount, ro /system

mount -o remount, ro /system

shell@android:/ #

oathleo 2013-02-21 13:47 发表评论

android手势效果-水果忍者刀锋效果/光刀效果

oathleo — Fri, 23 Sep 2011 03:29:00 GMT

请保留：

http://www.blogjava.net/oathleo/archive/2011/09/23/android_Fruit_Ninja.html

android手势加上了，比如左右滑动
但是用户经常不能感受到是否滑动了，

水果忍者刀锋效果/光刀效果就相当不错

网上搜了下，大多是ios的实现，想想原理可能不是很复杂，就实现了个最简单的。
原理
1.在背景view上再加一层view专门负责draw刀锋
2.刀锋就是随着手势move，动态画shape
3.接受到事件得dispatchTouchEvent，否则下面的组件无法获得事件了
4.下面的组件事件等无需更改，互不耦合
5.一个类实现，不涉及其他第三方
6.只实现了一个最简单的形状，水果忍者里面实现了很多复杂形状，可以在这个基础上进行扩展

效果如图

代码：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.view.MotionEvent;
import android.view.View;

/**
*
* 模仿水果忍者刀锋效果
* @author leooath@gmail.com
*
*/
public class GestureView extends View {

    private Paint paint;

    private float startX = Float.NaN;
    private float startY = Float.NaN;
    private float endX = Float.NaN;
    private float endY = Float.NaN;

    //下层view
    private View viewer;
    private static final int gestureColor = Color.rgb(153, 153, 153);
    private static final int alpha = 220;
    private static final int alpha_full = 255;
    //刀锋长度
    private static final int shape_length = 40;
    //刀锋截短时间
    private static final int shape_cut_time = 150;

    public GestureView(Context context, View viewer) {
        super(context);
        this.viewer = viewer;
        paint = new Paint();
        paint.setStyle(Paint.Style.FILL);
    }

    public void draw(Canvas canvas) {
        super.draw(canvas);
        if (!Float.isNaN(startX) && !Float.isNaN(endY)) {
            float gap = ViewUtils.getGap(startX, startY, endX, endY);
            float w = gap / 10;
            //背景shape外侧点高度
            float h = w > 7 ? 7 : w;
            //填充shape外侧点高度
            float h2 = h * 2 / 3;

            double length = Math.pow(Math.pow(w, 2) + Math.pow((h), 2), 0.5);
            double length2 = Math.pow(Math.pow(w, 2) + Math.pow((h2), 2), 0.5);

            double ang1_1 = Math.atan((endY - startY) / (endX - startX));
            double ang1_2 = Math.atan(h / w);
            double angle1_1 = ang1_1 + ang1_2;
            double angle1_2 = ang1_1 - ang1_2;

            double ang2_2 = Math.atan(h2 / w);
            double angle2_1 = ang1_1 + ang2_2;
            double angle2_2 = ang1_1 - ang2_2;
            if (endX > startX) {
                float xx1 = endX - (float) (length * Math.cos(angle1_1));
                float yy1 = endY - (float) (length * Math.sin(angle1_1));
                float xx2 = endX - (float) (length * Math.cos(angle1_2));
                float yy2 = endY - (float) (length * Math.sin(angle1_2));

                float xx12 = endX - (float) (length2 * Math.cos(angle2_1));
                float yy12 = endY - (float) (length2 * Math.sin(angle2_1));
                float xx22 = endX - (float) (length2 * Math.cos(angle2_2));
                float yy22 = endY - (float) (length2 * Math.sin(angle2_2));

                Path backPath = new Path();
                backPath.moveTo(startX, startY);
                backPath.lineTo(xx1, yy1);
                backPath.lineTo(endX, endY);
                backPath.lineTo(xx2, yy2);
                backPath.close();

                Path fillPath = new Path();
                fillPath.moveTo(startX, startY);
                fillPath.lineTo(xx12, yy12);
                fillPath.lineTo(endX, endY);
                fillPath.lineTo(xx22, yy22);
                fillPath.close();

                paint.setColor(gestureColor);
                paint.setAlpha(alpha);
                canvas.drawPath(backPath, paint);

                paint.setColor(Color.WHITE);
                paint.setAlpha(alpha_full);
                canvas.drawPath(fillPath, paint);
            } else {
                float xx1 = endX + (float) (length * Math.cos(angle1_1));
                float yy1 = endY + (float) (length * Math.sin(angle1_1));
                float xx2 = endX + (float) (length * Math.cos(angle1_2));
                float yy2 = endY + (float) (length * Math.sin(angle1_2));

                float xx12 = endX + (float) (length2 * Math.cos(angle2_1));
                float yy12 = endY + (float) (length2 * Math.sin(angle2_1));
                float xx22 = endX + (float) (length2 * Math.cos(angle2_2));
                float yy22 = endY + (float) (length2 * Math.sin(angle2_2));

                Path backPath = new Path();
                backPath.moveTo(startX, startY);
                backPath.lineTo(xx1, yy1);
                backPath.lineTo(endX, endY);
                backPath.lineTo(xx2, yy2);
                backPath.close();

                Path fillPath = new Path();
                fillPath.moveTo(startX, startY);
                fillPath.lineTo(xx12, yy12);
                fillPath.lineTo(endX, endY);
                fillPath.lineTo(xx22, yy22);
                fillPath.close();

                paint.setColor(gestureColor);
                paint.setAlpha(alpha);
                canvas.drawPath(backPath, paint);

                paint.setColor(Color.WHITE);
                paint.setAlpha(alpha_full);
                canvas.drawPath(fillPath, paint);
            }
        }
    }

    public boolean onTouchEvent(android.view.MotionEvent event) {
        if(event.getPointerCount() == 1){
            int action = event.getAction();
            if (MotionEvent.ACTION_DOWN == action) {
                startX = event.getX();
                startY = event.getY();
            } else if (MotionEvent.ACTION_MOVE == action) {
                endX = event.getX();
                endY = event.getY();

                //刀锋截短时间，则截短至一半
                if ((event.getEventTime() - event.getDownTime()) > shape_cut_time) {
                    if(Math.abs(endX - startX) > shape_length && Math.abs(endY - startY) > shape_length){
                        startX = (float) (startX + (endX - startX) * 0.5);
                        startY = (float) (startY + (endY - startY) * 0.5);
                    }
                }

                invalidate();
            } else if (MotionEvent.ACTION_UP == action) {
                startX = Float.NaN;
                startY = Float.NaN;
                endX = Float.NaN;
                endY = Float.NaN;
                invalidate();
            }
        }
        //该view消费了event，所以下层的view必须dispatchTouchEvent才能获得事件
        MotionEvent newEvent = MotionEvent.obtain(event);
        viewer.dispatchTouchEvent(newEvent);
        return true;
    }

}

oathleo 2011-09-23 11:29 发表评论

Android 事件返回值

oathleo — Mon, 19 Sep 2011 08:31:00 GMT

对于View来说，事件的返回值是关注的，down时返回true，才能接受up的事件

对于SurfaceView，事件返回值貌似没有什么作用

        setOnTouchListener(new OnTouchListener() {
            public boolean onTouch(View v, MotionEvent event) {
                System.out.println("touch");
                return true;
            }
        });

有兴趣的朋友可以试试上面的代码

oathleo 2011-09-19 16:31 发表评论

activity launchmode

oathleo — Fri, 02 Sep 2011 05:11:00 GMT

launchmode4种模式：
1，standard：
如果从A跳到A，intent5次，task里5个activity；
2，single Top:
如果从A 跳B,再从B跳A，如果此时栈顶为A，则不创建新实例，直接把Intent给A，但如果栈顶不是A，则还要创建A的实例
3，singleTask
如果从A跳B，再从B跳A，无论是否栈顶栈底，只要A在，则将Intent给A，不会创建A的新实例；
4，singleInstance
不同于前3种模式，前3种只是在同一个task的，而实例化的策略不同。这种模式下的activity会单独存在一个task下。
现成的例子是google地图。比如我有一个应用是导游方面的，其中调用的google地图Activity。那么现在我比如按home（后台 activity onstop，back是finish）键，然后到应用列表中打开google地图，你会发现显示的就是刚才的地图，实际上是同一个Activity。
如果使用上面三种模式，是无法实现这个需求的。google地图应用中有多个上下文Activity，比如路线查询等的，导游应用也有一些上下文Activity。在各自应用中回退要回退到各自的上下文Activity中。
总结：
1 2：会创建新实例
3 4：不会创建新实例
123：activity的taskid相同
4：activity的taskid不同。被分到单独一个task中

oathleo 2011-09-02 13:11 发表评论

PopupWindow自适应大小

oathleo — Fri, 02 Sep 2011 03:23:00 GMT

popupWindow.setWidth(LayoutParams.WRAP_CONTENT);
popupWindow.setHeight(LayoutParams.WRAP_CONTENT);

view自适应

                LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);
                LinearLayout linearLayout = new LinearLayout(c);
                linearLayout.setLayoutParams(params);

使用：

mPop.showAtLocation((View) v.getParent(), Gravity.TOP | Gravity.LEFT, 252, 50);

以上面一句为例：第一个参数是指PopupWindow显示在哪一个View之上．后面三个参数控制PopupWindow显示的位置，此处表明PopupWindow显示在距左上角x252个像素，y50个像素．

oathleo 2011-09-02 11:23 发表评论

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

oathleo — Fri, 02 Sep 2011 01:28:00 GMT

屏幕大小
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属性限制。

•Android:screenOrientation="landscape" //是限制此页面横屏显示
•Android:screenOrientation="portrait" //是限制此页面数竖屏显示
字体自适应大小
方法1：

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

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

在java文件中这样调用

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

oathleo 2011-09-02 09:28 发表评论

Android WebView Java和Javascript互调的例子转

oathleo — Thu, 25 Aug 2011 07:36:00 GMT

WebView对Javascript的支持也很强，google一个Java和Javascript互调的例子
整个Eclipse ADT工程例子中都有，这里重点分析一下代码：

Java代码  
public class WebViewDemo extends Activity {  
    private WebView mWebView;  
    private Handler mHandler = new Handler();  
  
    public void onCreate(Bundle icicle) {  
        super.onCreate(icicle);  
        setContentView(R.layout.webviewdemo);  
        mWebView = (WebView) findViewById(R.id.webview);  
        WebSettings webSettings = mWebView.getSettings();  
        webSettings.setJavaScriptEnabled(true);  
        mWebView.addJavascriptInterface(new Object() {  
            public void clickOnAndroid() {  
                mHandler.post(new Runnable() {  
                    public void run() {  
                        mWebView.loadUrl("javascript:wave()");  
                    }  
                });  
            }  
        }, "demo");  
        mWebView.loadUrl("file:///android_asset/demo.html");  
    }  
}  

这里的重点是addJavascriptInterface(Object obj,String interfaceName)方法，该方法将一个java对象绑定到一个javascript对象中，javascript对象名就是 interfaceName，作用域是Global。这样初始化webview后，在webview加载的页面中就可以直接通过 javascript:window.demo访问到绑定的java对象了。来看看在html中是怎样调用的：

Html代码  
<html>  
        <script language="javascript">  
                function wave() {  
                    document.getElementById("droid").src="android_waving.png";  
                }  
        script>  
        <body>  
            <a onClick="window.demo.clickOnAndroid()">  
                                <img id="droid" src="android_normal.png"/><br>  
                                Click me!  
            a>  
        body>  
html>  

这样在javascript中就可以调用java对象的clickOnAndroid()方法了，wave()方法是java中调用javascript的例子。

这里还有几个知识点：

1) 为了让WebView从apk文件中加载assets，Android SDK提供了一个schema，前缀为"file:///android_asset/"。WebView遇到这样的schema，就去当前包中的 assets目录中找内容。如上面的"file:///android_asset/demo.html"

2)addJavascriptInterface方法中要绑定的Java对象及方法要运行另外的线程中，不能运行在构造他的线程中，这也是使用Handler的目的。

oathleo 2011-08-25 15:36 发表评论

proguard ant 混淆

oathleo — Wed, 24 Aug 2011 06:39:00 GMT

    <property name="proguard-home" value="D:/proguard4.4/lib"/>
    <property name="android-jar" value="D:\android3.0\android-sdk_r12-windows\android-sdk-windows\platforms\android-8\android.jar"/>
//指定 proguard 地址和 android地址

<java jar="${proguard-home}/proguard.jar" fork="true" failonerror="true">
            <jvmarg value="-Dmaximum.inlined.code.length=32" />
            <arg value="-injars ${target_temp_jar}" />
            <arg value="-outjars ${target_jar}" />
            //第三方包
            <arg value="-libraryjars ${android-jar}" />
            <arg value="-libraryjars lib/android_script.jar" />


            <arg value="-dontpreverify" />
            <arg value="-dontoptimize" />
            <arg value="-dontusemixedcaseclassnames" />
            <arg value="-repackageclasses ''" />
            <arg value="-allowaccessmodification" />


            <arg value="-keepclassmembers public class * { public protected *; }" />

            <arg value="-keepattributes Signature" />

            <arg value="-keep public class com.xxxcore.*" />
            <arg value="-keep public class com.xxxviewer.**" />

            <arg value="-optimizationpasses 7" />
            <arg value="-verbose" />
            <arg value="-dontskipnonpubliclibraryclasses" />
            <arg value="-dontskipnonpubliclibraryclassmembers" />
        java>

        <signjar jar="${target_jar}" keystore="${sign.keystore}" alias="${sign.alias}" keypass="${sign.keypass}" storepass="${sign.storepass}"/>
        <delete file="${target_temp_jar}" />
    target>

参数：

-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}    设置源文件中给定的字符串常量

oathleo 2011-08-24 14:39 发表评论

android GestureListener 手势多指缩放

oathleo — Sun, 21 Aug 2011 03:59:00 GMT

注意
1.onDown 多指事件仍然响应成单指
2.onScroll滑动时触发,e1只能获得一个点，而e2却能获得多点。（搞不清楚为什么怎么设计）
3.想在view上加 GestureListener
可以使用下面的代码：

public class ViewerInnerTouchListener implements OnTouchListener {

    private GestureDetector gestureDetector;

    public ViewerInnerTouchListener(GAViewer viewer) {
        gestureDetector = new GestureDetector(new GestureListener(viewer));
    }

    public boolean onTouch(View v, MotionEvent event) {
        gestureDetector.onTouchEvent(event);
        return true;
    }

}

    setOnTouchListener(new ViewerInnerTouchListener(this));

判断手势：

    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
        if (e1.getX() - e2.getX() > SWIPE_MIN_DISTANCE && Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
            Log.i("onFling", "onFling");
            return true; // Right to left
        } else if (e2.getX() - e1.getX() > SWIPE_MIN_DISTANCE && Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
            return false; // Left to right
        }
        if (e1.getY() - e2.getY() > SWIPE_MIN_DISTANCE && Math.abs(velocityY) > SWIPE_THRESHOLD_VELOCITY) {
            return false; // Bottom to top
        } else if (e2.getY() - e1.getY() > SWIPE_MIN_DISTANCE && Math.abs(velocityY) > SWIPE_THRESHOLD_VELOCITY) {
            return false; // Top to bottom
        }
        return false;
    }

GestureListener 的几个方法要理解
   //Touch down时触发，不论是touch (包括long) ，scroll
   public boolean onDown(MotionEvent e) {
   return false;
   }

   //Touch了还没有滑动时触发
   //（与onDown，onLongPress比较
   //onDown只要Touch down一定立刻触发。
   public void onShowPress(MotionEvent e) {
   }

   //Touch了不移动一直Touch down时触发
   //Touchdown后过一会没有滑动先触发onShowPress再是onLongPress。
   public void onLongPress(MotionEvent e) {
   }

   //上面这两个函数都是在touch down后又没有滑动（onScroll），又没有长按（onLongPress），然后Touchup时触发。
   /**
   * 点击一下非常快的（不滑动）Touchup： onDown->onSingleTapUp->onSingleTapConfirmed
   *
   点击一下稍微慢点的（不滑动）Touchup：onDown->onShowPress->onSingleTapUp->onSingleTapConfirmed
   * 点击longpress ，onScroll 时不触发 onSingleTapUp
   */
   public boolean onSingleTapUp(MotionEvent e) {
   Log.i("onSingleTapUp", "onSingleTapUp");
   return false;
   }

   //Touch了滑动时触发
   public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
   float distanceY) {
   return true;
   }

   //Touch了滑动一点距离后，up时触发
   public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
   float velocityY) {
   return true;
   }

oathleo 2011-08-21 11:59 发表评论

android:padding和android:layout_margin的区别

oathleo — Thu, 18 Aug 2011 08:33:00 GMT

之前一直没有搞懂android:padding和android:layout_margin的区别，其实概念很简单，padding是站在父view的角度描述问题，它规定它里面的内容必须与这个父view边界的距离。margin则是站在自己的角度描述问题，规定自己和其他（上下左右）的view之间的距离，如果同一级只有一个view，那么它的效果基本上就和padding一样了

oathleo 2011-08-18 16:33 发表评论

android layout xml

oathleo — Tue, 16 Aug 2011 04:53:00 GMT

layout在xml里是无法使用findView 找到的

只能使用：

View menu = inflater.inflate(R.layout.main_left_layout, null);

获得

LayoutInflater 的方法：

1.Activity
LayoutInflater inflater = getLayoutInflater();
2.

LayoutInflater inflater = LayoutInflater.from(context);

oathleo 2011-08-16 12:53 发表评论

android 内部资源获取

oathleo — Mon, 08 Aug 2011 03:24:00 GMT

1、XML资源文件可以被AAPT打包进应用程序包，如果需要被打包，放置在/res/xml目录下，如果不需要被打包，放置在/res/raw下。

2、对/res/xml的支持

以读取/res/xml/test.xml为例

Resources res=activity.getResources();

XmlResourceParser xpp=res.getxml(R.xml.test);

inet eventType=xpp.getEventType();

再根据evenType的类型，判断读取了什么内容，比如说，读到了文档的开头，XmlPullParser.START_DOCUMENT等

使用xpp.getName()取得标志名称，使用xpp.getText()取得文本内容

最后

eventType=xpp.next();来读取下一行内容

3、对/res/raw的支持

以读取/res/raw/test.txt为例

Resources r=activity.getResources();

InputStream is=r.openRawResource(R.raw.test);

4、资产

/assets不会在R.java中生成资源ID，必须指定文件路径才能读取它们。文件路径是以/assets开头的相对路径。

AssetManger am=activity.getAssets();

InputStream is=am.open("test.txt");

oathleo 2011-08-08 11:24 发表评论

终于把script包源码扒出来了

oathleo — Mon, 01 Aug 2011 03:08:00 GMT

script包源码包括：

sun\script\javascript

script

和

org\mozilla\javascript

其中

org\mozilla\javascript

是真正的javascript实现源码1M多

一起打包完大概860K

oathleo 2011-08-01 11:08 发表评论

编写高效的Android代码(Designing for Performance)

oathleo — Sun, 31 Jul 2011 00:31:00 GMT

摘要: 中文: http://www.chinaup.org/docs/toolbox/performance.html 英文: /android-sdk/docs/guide/guide_toc.html 尽量避免创建对象使用自身方法使用虚拟优于使用接口使用静态优于使用虚拟避免内部使用Setter和Getter 缓冲属性调用声明Final常量慎重使... 阅读全文

oathleo 2011-07-31 08:31 发表评论

Can't create handler inside thread that has not called Looper.prepare() 异常问题

oathleo — Sat, 30 Jul 2011 02:04:00 GMT

遇到的情况

AsyncTask

protected GAViewer doInBackground(Activity... params) {
......

GAViewer viewer = new GAViewer(result, drawActivity.getApplicationContext());
return viewer;

}

产生

Can't create handler inside thread that has not called Looper.prepare()

异常

原因估计
1.viewer 是个 SurfaceView ，而doInBackground是不允许操作UI的
2.drawActivity.getApplicationContext() 已经操作了UI ？maybe

oathleo 2011-07-30 10:04 发表评论

XmlPullParser 效率问题

oathleo — Sat, 30 Jul 2011 02:00:00 GMT

3000行的多层次XML，
环境2.2，Xoom

XmlPullParser 2000ms 以上

SAXParser 200ms 不到

原因不知道~暂时没空深层研究了

oathleo 2011-07-30 10:00 发表评论

高级画布绘图（3）

oathleo — Tue, 26 Jul 2011 03:35:00 GMT

高级画布绘图（3）

DashPathEffect 可以使用DashPathEffect来创建一个虚线的轮廓(短横线/小圆点)，而不是使用实线。你还可以指定任意的虚/实线段的重复模式。

DiscretePathEffect 与DashPathEffect相似，但是添加了随机性。当绘制它的时候，需要指定每一段的长度和与原始路径的偏离度。

PathDashPathEffect 这种效果可以定义一个新的形状(路径)并将其用作原始路径的轮廓标记。

下面的效果可以在一个Paint中组合使用多个Path Effect。

SumPathEffect 顺序地在一条路径中添加两种效果，这样每一种效果都可以应用到原始路径中，而且两种结果可以结合起来。

ComposePathEffect 将两种效果组合起来应用，先使用第一种效果，然后在这种效果的基础上应用第二种效果。

对象形状的PathEffect的改变会影响到形状的区域。这就能够保证应用到相同形状的填充效果将会绘制到新的边界中。

使用setPathEffect方法可以把PathEffect应用到Paint对象中，如下所示:

borderPaint.setPathEffect(new CornerPathEffect(5));

PathEffect API示例给出了如何应用每一种效果的指导说明。

修改Xfermode

可以通过修改Paint的Xfermode来影响在Canvas已有的图像上面绘制新的颜色的方式。

在正常的情况下，在已有的图像上绘图将会在其上面添加一层新的形状。如果新的Paint是完全不透明的，那么它将完全遮挡住下面的Paint；如果它是部分透明的，那么它将会被染上下面的颜色。

下面的Xfermode子类可以改变这种行为：

AvoidXfermode 指定了一个颜色和容差，强制Paint避免在它上面绘图(或者只在它上面绘图)。

PixelXorXfermode 当覆盖已有的颜色时，应用一个简单的像素XOR操作。

PorterDuffXfermode 这是一个非常强大的转换模式，使用它，可以使用图像合成的16条Porter-Duff规则的任意一条来控制Paint如何与已有的Canvas图像进行交互。

要应用转换模式，可以使用setXferMode方法，如下所示：

AvoidXfermode avoid = new AvoidXfermode(Color.BLUE, 10, AvoidXfermode.Mode. AVOID);  
borderPen.setXfermode(avoid);

3. 使用抗锯齿效果提高Paint质量

在绘制一个新的Paint对象时，可以通过传递给它一些标记来影响它被渲染的方式。ANTI_ALIAS_FLAG是其中一种很有趣的标记，它可以保证在绘制斜线的时候使用抗锯齿效果来平滑该斜线的外观。

在绘制文本的时候，抗锯齿效果尤为重要，因为经过抗锯齿效果处理之后的文本非常容易阅读。要创建更加平滑的文本效果，可以应用SUBPIXEL_TEXT_FLAG，它将会应用子像素抗锯齿效果。

也可以手工地使用setSubpixelText和setAntiAlias方法来设置这些标记，如下所示：

myPaint.setSubpixelText(true);  
myPaint.setAntiAlias(true);

4. 2D图形的硬件加速

在当前这个到处都是2D图形爱好者的时代，Android允许你使用硬件加速来渲染你的应用程序。

如果设备可以使用硬件加速，那么通过设置这个标记可以让活动中的每一个View都能使用硬件渲染。尽管减少了系统处理程序的负载，但在极大地提高了图像处理速度的同时，硬件加速也带来了相应的负面效果。

使用requestWindowFeature方法，可以在你的活动中应用Window.FEATURE_OPENGL标记来打开硬件加速，如下所示：

myActivity.requestWindowFeature(Window.FEATURE_OPENGL);

遗憾的是，天上不会掉馅饼，这次也不例外。

并不是Android中所有的2D绘图基本图形都被硬件支持(特别是前面描述的大部分PathEffect)。

与此同时，由于整个活动实际上是作为一个Canvas进行渲染的，所以对任何View的无效请求都将会导致整个活动被重新绘制。

5. Canvas绘图最佳实践经验

2D自绘操作是非常耗费处理程序资源的；低效的绘图方法会阻塞GUI线程，并且会对应用程序的响应造成不利的影响。对于那些只有一个处理程序的资源受限的环境来说，这一点就更加现实了。

这里需要注意onDraw方法的资源消耗以及CPU周期的耗费，这样才能保证不会把一个看起来很吸引人的应用程序变得完全没有响应。

目前有很多技术可以帮助将与自绘控件相关的资源消耗最小化。我们关心的不是一般的原则，而是某些Android特定的注意事项，从而保证你可以创建外观时尚、而且能够保持交互的活动(注意，以下这个列表并不完整)：

考虑硬件加速 OpenGL硬件加速对2D图形的支持是非常好的，所以你总是应该考虑它是否适合你的活动。另一种比较优秀的方法是只用一个单独的View和迅速的、耗时的更新来组成活动。一定要保证你使用的基本图形能够被硬件支持。

考虑大小和方向当在设计View和布局的时候，一定要保证考虑(和测试)它们在不同的分辨率和大小下的外观。

只创建一次静态对象在Android中对象的创建是相当昂贵的。因此，在可能的地方，应用只创建一次像Paint对象、Path和Shader这样的绘图对象，而不是在View每次无效的时候都重新创建它们。

记住onDraw是很消耗资源的执行onDraw方法是很消耗资源的处理，它会强制Android执行多个图片组合和位图构建操作。下面有几点建议可以让你修改Canvas的外观，而不用重新绘制它：

使用Canvas转换可以使用像rotate和translate这样的转换，来简化Canvas中元素复杂的相关位置。例如，相比放置和旋转一个表盘周围的每一个文本元素，你可以简单地将canvas旋转22.5?，然后在相同的位置绘制文本。

使用动画可以考虑使用动画来执行View的预设置的转换，而不是手动地重新绘制它。在活动的View中可以执行缩放、旋转和转换动画，并可以提供一种能够有效利用资源的方式来提供缩放、旋转或者抖动效果。

考虑使用位图和9 Patch 如果View使用了静态背景，那么你应该考虑使用一个图片，如位图或者9 patch，而不是手动地重新绘制。

oathleo 2011-07-26 11:35 发表评论

高级画布绘图（2）

oathleo — Tue, 26 Jul 2011 03:33:00 GMT

11.4.3 高级画布绘图（2）

提示：

图11-1中没有包含的是ComposerShader，它可以创建多个Shader和BitmapShader的组合，从而可以在一个位图图像的基础上创建一个绘图刷。

要在绘图的时候使用一个Shader，可以使用setShader方法将其应用到一个Paint中，如下面的代码所示：

Paint shaderPaint = new Paint();  
shaderPaint.setShader(myLinearGradient);

你使用这个Paint所绘制的任何东西都将使用你指定的Shader进行填充，而不是使用Paint本身的颜色进行填充。

定义渐变Shader

如上所示，使用渐变Shader可以让你使用交替改变的颜色来填充图片；你可以将颜色渐变定义为两种颜色的简单交替，如下所示：

int colorFrom = Color.BLACK;  
int colorTo = Color.WHITE;  
 
LinearGradient linearGradientShader = new LinearGradient(x1, y1, x2, y2,  
                                                         colorFrom,  
                                                         colorTo,  
                                                         TileMode.CLAMP);

或者，你还可以定义更复杂的按照设定比例进行分布的颜色序列，如下面的RadialGradientShader例子所示：

int[] gradientColors = new int[3];  
gradientColors[0] = Color.GREEN;  
gradientColors[1] = Color.YELLOW;  
gradientColors[2] = Color.RED;  
 
float[] gradientPositions = new float[3];  
gradientPositions[0] = 0.0f;  
gradientPositions[1] = 0.5f;  
gradientPositions[2] = 1.0f;  
 
RadialGradient radialGradientShader=new RadialGradient(centerX,centerY, radius,  
                                                         gradientColors,  
                                                         gradientPositions,  
                                                         TileMode.CLAMP);

每一种渐变Shader(线性的、辐射形的和扫描状的)都可以使用以上这两种技术来定义渐变填充。

使用Shader TileModes

渐变Shader的画刷大小既可以显式地使用有边界的矩形来定义，也可以使用中心点和半径长度来定义。Bitmap Shader可以通过它的位图大小来决定它的画刷大小。

如果Shader画刷所定义的区域比要填充的区域小，那么TileMode将会决定如何处理剩余的区域：

CLAMP 使用Shader的边界颜色来填充剩余的空间。

MIRROR 在水平和垂直方向上拉伸Shader图像，这样每一个图像就都能与上一个缝合了。

REPEAT 在水平和垂直方向上重复Shader图像，但不拉伸它。

使用MaskFilter

MaskFilter类可以为Paint分配边缘效果。

对MaskFilter的扩展可以对一个Paint边缘的alpha通道应用转换。Android包含了下面几种MaskFilter：

BlurMaskFilter 指定了一个模糊的样式和半径来处理Paint的边缘。

EmbossMaskFilter 指定了光源的方向和环境光强度来添加浮雕效果。

要应用一个MaskFilter，可以使用setMaskFilter方法，并传递给它一个MaskFilter对象。下面的例子是对一个已经存在的Paint应用一个EmbossMaskFilter：

// 设置光源的方向  
float[] direction = new float[]{ 1, 1, 1 };  
//设置环境光亮度  
float light = 0.4f;  
// 选择要应用的反射等级  
float specular = 6;  
// 向mask应用一定级别的模糊  
float blur = 3.5f;  
EmbossMaskFilter emboss=new EmbossMaskFilter(direction,light,specular,blur);  
 
// 应用mask  
myPaint.setMaskFilter(emboss);

SDK中包含的FingerPaint API demo是说明如何使用MaskFilter的一个非常好的例子。它展示了这两种filter的效果。

使用ColorFilter

MaskFilter是对一个Paint的alpha通道的转换，而ColorFilter则是对每一个RGB通道应用转换。所有由ColorFilter所派生的类在执行它们的转换时，都会忽略alpha通道。

Android包含三个ColorFilter：

ColorMatrixColorFilter 可以指定一个4×5的ColorMatrix并将其应用到一个Paint中。ColorMatrixes通常在程序中用于对图像进行处理，而且由于它们支持使用矩阵相乘的方法来执行链接转换，所以它们很有用。

LightingColorFilter 乘以第一个颜色的RGB通道，然后加上第二个颜色。每一次转换的结果都限制在0到255之间。

PorterDuffColorFilter 可以使用数字图像合成的16条Porter-Duff 规则中的任意一条来向Paint应用一个指定的颜色。

使用setColorFilter方法应用ColorFilter，如下所示：

myPaint.setColorFilter(new LightingColorFilter(Color.BLUE, Color.RED));

API中的ColorMatrixSample是说明如何使用ColorFilter和Color Matrix的非常好的例子。

使用PathEffect

到目前为止，所有的效应都会影响到Paint填充图像的方式；PathEffect是用来控制绘制轮廓(线条)的方式。

PathEffect对于绘制Path基本图形特别有用，但是它们也可以应用到任何Paint中从而影响线条绘制的方式。

使用PathEffect，可以改变一个形状的边角的外观并且控制轮廓的外表。Android包含了多个PathEffect，包括：

CornerPathEffect 可以使用圆角来代替尖锐的角从而对基本图形的形状尖锐的边角进行平滑。

oathleo 2011-07-26 11:33 发表评论

高级画布绘图（1）

oathleo — Tue, 26 Jul 2011 03:14:00 GMT

11.4.3 高级画布绘图（1）

我们已经在第4章中介绍了Canvas，在那里，已经学习了如何创建自己的View。在第7章中也使用了Canvas来为MapView标注覆盖。

画布(Canvas)是图形编程中一个很普通的概念，通常由三个基本的绘图组件组成：

Canvas 提供了绘图方法，可以向底层的位图绘制基本图形。

Paint 也称为"刷子"，Paint可以指定如何将基本图形绘制到位图上。

Bitmap 绘图的表面。

这一章中描述的大部分高级技术都涉及到了对Paint对象的变化和修改，从而可以向那些平面的光栅图片添加深度和纹理。

Android绘图API支持透明度、渐变填充、圆边矩形和抗锯齿。遗憾的是，由于资源限制，它还不支持矢量图形，它使用的是传统光栅样式的重新绘图。

这种光栅方法的结果是提高了效率，但是改变一个Paint对象不会影响已经画好的基本图形，它只会影响新的元素。

提示：

如果你拥有Windows开发背景，那么Android的2D绘图能力大致相当于GDI+的能力。

1. 可以画什么？

Canvas类封装了用作绘图表面的位图；它还提供了draw*方法来实现设计。

下面的列表提供了对可用的基本图形的简要说明，但并没有深入地探讨每一个draw方法的详细内容：

drawARGB / drawRGB / drawColor 使用单一的颜色填充画布。

drawArc 在一个矩形区域的两个角之间绘制一个弧。

drawBitmap 在画布上绘制一个位图。可以通过指定目标大小或者使用一个矩阵来改变目标位图的外观。

drawBitmapMesh 使用一个mesh(网)来绘制一个位图，它可以通过移动网中的点来操作目标的外观。

drawCircle 以给定的点为圆心，绘制一个指定半径的圆。

drawLine(s) 在两个点之间画一条(多条)直线。

drawOval 以指定的矩形为边界，画一个椭圆。

drawPaint 使用指定的Paint填充整个Canvas

drawPath 绘制指定的Path。Path对象经常用来保存一个对象中基本图形的集合。

drawPicture 在指定的矩形中绘制一个Picture对象。

drawPosText 绘制指定了每一个字符的偏移量的文本字符串。

drawRect 绘制一个矩形。

drawRoundRect 绘制一个圆角矩形。

drawText 在Canvas上绘制一个文本串。文本的字体、大小和渲染属性都设置在用来渲染文本的Paint对象中。

drawTextOnPath 在一个指定的path上绘制文本。

drawVertices 绘制一系列三角形面片，通过一系列顶点来指定它们。

这些绘图方法中的每一个都需要指定一个Paint对象来渲染它。在下面的部分中，将学习如何创建和修改Paint对象，从而在绘图中完成大部分工作。

2. 从Paint中完成工作

Paint类相当于一个笔刷和调色板。它可以选择如何使用上面描述的draw方法来渲染绘制在画布上的基本图形。通过修改Paint对象，可以在绘图的时候控制颜色、样式、字体和特殊效果。最简单地，setColor可以让你选择一个Paint的颜色，而Paint对象的样式(使用setStyle 控制)则可以决定是绘制绘图对象的轮廓(STROKE)，还是只填充每一部分(FILL)，或者是两者都做(STROKE_AND_FILL)

除了这些简单的控制之外，Paint类还支持透明度，另外，它也可以通过使用各种各样的阴影、过滤器和效果进行修改，从而提供由更丰富的、复杂的画笔和颜料组成的调色板。

Android SDK包含了一些非常好的实例，它们说明了Paint类中可用的大部分功能。你可以在API demos的graphics子目录中找到它们：

[sdk root folder]\samples\ApiDemos\src\com\android\samples\graphics

在下面的部分中，将学习和使用其中的部分功能。这些部分只是简单地罗列了它们能实现的效果(例如渐变和边缘浮雕)，而没有详细地列出所有可能的情况。

使用透明度

Android中的所有颜色都包含了一个不透明组件(alpha通道)。

当创建一个颜色的时候，可以使用argb或者parseColor方法来定义它的alpha值，如下所示：

// 使用红色，并让它50%透明  
int opacity = 127;  
int intColor = Color.argb(opacity, 255, 0, 0);  
int parsedColor = Color.parseColor("#7FFF0000");

或者，也可以使用setAlpha方法来设置已存在的Paint对象的透明度：

// 让颜色50%透明  
int opacity = 127;  
myPaint.setAlpha(opacity);

创建一个不是100%透明的颜色意味着，使用它绘制的任何基本图形都将是部分透明的--也就是说，在它下面绘制的所有基本图形都是部分可见的。

可以在任何使用了颜色的类或者方法中使用透明效果，包括Paint、Shader和Mask Filter。

Shader介绍

Shader类的派生类可以创建允许使用多种固体颜色填充绘图对象的Paint。

对Shader最常见的使用是定义渐变填充；渐变是在2D图像中添加深度和纹理的最佳方式之一。Android包含了一个Bitmap Shader和一个Compose Shader，同时，还包含了三个渐变的Shader。

试图用语言来描述绘图的效果本来就是没有意义的，所以看一下图11-1就应该可以知道每一种Shader是如何工作的。图中从左到右依次代表的是LinearGradient、RadialGradient和 SweepGradient.

（点击查看大图）图11-1

oathleo 2011-07-26 11:14 发表评论

Android 渐变 -- Shader

oathleo — Mon, 25 Jul 2011 03:41:00 GMT

大家好，今天和大家分享的是Android中渲染图像和图形的类，这也是我第一次在Linux上写Android程序，呵呵，感觉还不错！

切入正题：Shader有几个直接子类：

BitmapShader : 图像渲染

LinearGradient : 线性渐变

RadialGradient : 环形渐变

SweepGradient : 扫描渐变---围绕一个中心点扫描渐变就像电影里那种雷达扫描

ComposeShader : 组合渲染

先看效果图：

先保存好你要在BitmapShader中显示的图片.

看代码(代码中带有注释)：

我采用的还是SurefaceView框架,

view plain

package com.ldj.helloshader;
import android.content.Context;
import android.graphics.*;
import android.graphics.Shader.TileMode;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.ShapeDrawable;
import android.graphics.drawable.shapes.OvalShape;
import android.view.*;
public class ShaderView extends SurfaceView implements SurfaceHolder.Callback,Runnable{
//声明渐变的颜色数组
private int[] color =
new int[]{Color.GREEN,Color.GRAY,Color.MAGENTA,Color.RED,Color.WHITE};
private boolean loop = false;
private SurfaceHolder surfaceHolder;
private Bitmap bitPic = null;
int bitPicWidth = 0;
int bitPicHeight = 0;
//声明一个图片渲染
BitmapShader bitmapShader = null;
//声明一个线性渐变
LinearGradient linearGradient = null;
//声明一个环形渐变
RadialGradient radialGradient = null;
//声明一个扫描渐变
//-围绕一个中心点扫描渐变就像电影里那种雷达扫描
SweepGradient sweepGradient = null;
//声明一个组合渲染
ComposeShader composeShader = null;
//定义画笔
Paint paint = null;
//利用这个类也可以实现绘制图像的功能
ShapeDrawable shapeDrawable = null;
public ShaderView(Context context) {
super(context);
surfaceHolder = this.getHolder();
//增加回调
surfaceHolder.addCallback(this);
loop = true;
paint = new Paint();
//获取图像资源
bitPic =
((BitmapDrawable)this.getResources().getDrawable(R.drawable.screenshot))
.getBitmap();
//将图片的长和高的值赋给变量
bitPicWidth = bitPic.getWidth();
bitPicHeight = bitPic.getHeight();
/*
* ~~~BitmapShader(Bitmap,TileMode,TileMode)~~~
*/
bitmapShader = new BitmapShader(bitPic, TileMode.REPEAT, TileMode.MIRROR);
/*
* ~~~LinearGradient(x0,y0,x1,y1,int[Color],float[],TileMode)~~~
*/
linearGradient = new LinearGradient(0,0,100,100,color,null,TileMode.REPEAT);
/*
* ~~~RadialGradient~~~
*/
radialGradient = new RadialGradient(160,240,66,color,null,TileMode.MIRROR);
/*
* ~~~SweepGradient~~~
*/
sweepGradient = new SweepGradient(100,350,color,null);
//~~~ComposeShader（shaderA,shaderB,Mode）~~~
//组合线性和环形两种渐变,当然其他的也可以的
composeShader
= new ComposeShader(linearGradient,radialGradient,PorterDuff.Mode.DARKEN);
}
@Override
public void run() {
while(loop) {
draw();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3) {
}
@Override
public void surfaceCreated(SurfaceHolder arg0) {
new Thread(this).start();
}
@Override
public void surfaceDestroyed(SurfaceHolder arg0) {
loop = false;
}
private void draw() {
Canvas canvas = surfaceHolder.lockCanvas();
/*
* ~~~BitmapShader
*/
//构造形状为椭圆的shapeDrawable对象
shapeDrawable = new ShapeDrawable(new OvalShape());
//设置显示的图片
shapeDrawable.getPaint().setShader(bitmapShader);
//设置显示的长和高
shapeDrawable.setBounds(0, 0, bitPicWidth, bitPicHeight);
//绘制图像
shapeDrawable.draw(canvas);
//~~~LinearGradient~~~
//设置画笔的渲染类型
paint.setShader(linearGradient);
canvas.drawRect(0, bitPicHeight, 320, 150, paint);
//~~~RadialGradient~~~
paint.setShader(radialGradient);
canvas.drawCircle(160, 240, 66, paint);
//~~~SweepGradient
paint.setShader(sweepGradient);
canvas.drawCircle(100, 350, 66, paint);
//~~~ComposeShader~~~
paint.setShader(composeShader);
canvas.drawRect(bitPicWidth, 320, 320, 480, paint);
surfaceHolder.unlockCanvasAndPost(canvas);
}
}

总结：

配色弄的不是很好看，大家可别见怪，大体来说渲染图像或图形三步：

首先是声明渲染或渐变类。

然后将画笔setShader为声明的类。

最后绘制的时候用此画笔即可。

好了，今天到这里了，谢谢大家阅读。

oathleo 2011-07-25 11:41 发表评论

Paint类常用方法

oathleo — Mon, 25 Jul 2011 02:52:00 GMT

void setARGB(int a, int r, int g, int b) 设置Paint对象颜色，参数一为alpha透明通道

void setAlpha(int a) 设置alpha不透明度，范围为0~255

void setAntiAlias(boolean aa) //是否抗锯齿

void setColor(int color) //设置颜色，这里Android内部定义的有Color类包含了一些常见颜色定义
.
void setFakeBoldText(boolean fakeBoldText) //设置伪粗体文本

void setLinearText(boolean linearText) //设置线性文本

PathEffect setPathEffect(PathEffect effect) //设置路径效果

Rasterizer setRasterizer(Rasterizer rasterizer) //设置光栅化

Shader setShader(Shader shader) //设置阴影

void setTextAlign(Paint.Align align) //设置文本对齐

void setTextScaleX(float scaleX) //设置文本缩放倍数，1.0f为原始

void setTextSize(float textSize) //设置字体大小

Typeface setTypeface(Typeface typeface) //设置字体，Typeface包含了字体的类型，粗细，还有倾斜、颜色等。

void setUnderlineText(boolean underlineText) //设置下划线

Paint paint = new Paint();

     paint.setAntiAlias(true);        //防锯齿
        paint.setDither(true);            //防抖动
        paint.setStyle(Paint.Style.STROKE);          //画笔类型 STROKE空心 FILL 实心

oathleo 2011-07-25 10:52 发表评论

SurfaceView 翻转

oathleo — Thu, 21 Jul 2011 07:18:00 GMT

触发

android.view.SurfaceHolder.Callback

1.surfaceDestroyed

2.surfaceCreated
3.surfaceChanged

oathleo 2011-07-21 15:18 发表评论

android中context

oathleo — Thu, 21 Jul 2011 06:57:00 GMT

在android中context可以作很多操作，但是最主要的功能是加载和访问资源。在android中有两种context，
一种是 application context，一种是activity context，通常我们在各种类和方法间传递的是activity context。
比如一个activity的onCreate：
protected void onCreate(Bundle state) {
        super.onCreate(state);

        TextView label = new TextView(this); //传递context给view control
        label.setText("Leaks are bad");

        setContentView(label);
}
把activity context传递给view，意味着view拥有一个指向activity的引用，进而引用activity占有的资源：view hierachy, resource等。
这样如果context发生内存泄露的话，就会泄露很多内存。
这里泄露的意思是gc没有办法回收activity的内存。

Leaking an entire activity是很容易的一件事。

当屏幕旋转的时候，系统会销毁当前的activity，保存状态信息，再创建一个新的。

比如我们写了一个应用程序，它需要加载一个很大的图片，我们不希望每次旋转屏幕的时候都销毁这个图片，重新加载。
实现这个要求的简单想法就是定义一个静态的Drawable，这样Activity 类创建销毁它始终保存在内存中。
实现类似：
public class myactivity extends Activity {
        private static Drawable sBackground;
        protected void onCreate(Bundle state) {
                super.onCreate(state);

                TextView label = new TextView(this);
                label.setText("Leaks are bad");

                if (sBackground == null) {
                        sBackground = getDrawable(R.drawable.large_bitmap);
                }
        label.setBackgroundDrawable(sBackground);//drawable attached to a view

        setContentView(label);
        }
}
这段程序看起来很简单，但是却问题很大。当屏幕旋转的时候会有leak（即gc没法销毁activity）。
我们刚才说过，屏幕旋转的时候系统会销毁当前的activity。但是当drawable和view关联后，drawable保存了view的 reference，即sBackground保存了label的引用，
而label保存了activity的引用。既然drawable不能销毁，它所引用和间接引用的都不能销毁，这样系统就没有办法销毁当前的activity，于是造成了内存泄露。
gc对这种类型的内存泄露是无能为力的。

避免这种内存泄露的方法是避免activity中的任何对象的生命周期长过activity，避免由于对象对 activity的引用导致activity不能正常被销毁。
我们可以使用application context。application context伴随application的一生，与activity的生命周期无关。
application context可以通过Context.getApplicationContext或者Activity.getApplication方法获取。

避免context相关的内存泄露，记住以下几点：
1. 不要让生命周期长的对象引用activity context，即保证引用activity的对象要与activity本身生命周期是一样的
2. 对于生命周期长的对象，可以使用application context
3. 避免非静态的内部类，尽量使用静态类，避免生命周期问题，注意内部类对外部对象引用导致的生命周期变化

oathleo 2011-07-21 14:57 发表评论

Android提高第三篇之SurfaceView与多线程的混搭转载

oathleo — Thu, 21 Jul 2011 02:11:00 GMT

http://blog.csdn.net/hellogv/article/details/5986835

上一篇简单介绍了SurfaceView的基本使用，这次就介绍SurfaceView与多线程的混搭。SurfaceView与多线程混搭，是为了防止动画闪烁而实现的一种多线程应用。android的多线程用法与JAVA的多线程用法完全一样，本文不做多线程方面的介绍了。直接讲解SurfaceView与多线程的混合使用，即开一条线程专门读取图片，另外一条线程专门绘图。

本文程序运行截图如下，左边是开单个线程读取并绘图，右边是开两个线程，一个专门读取图片，一个专门绘图：

对比一下，右边动画的帧速明显比左边的快，左右两者都没使用Thread.sleep()。为什么要开两个线程一个读一个画，而不去开两个线程像左边那样都 “边读边画”呢？因为SurfaceView每次绘图都会锁定Canvas,也就是说同一片区域这次没画完下次就不能画，因此要提高动画播放的效率，就得开一条线程专门画图，开另外一条线程做预处理的工作。

main.xml的源码：

view plain

android:layout_width="fill_parent" android:layout_height="fill_parent"
android:orientation="vertical">
android:layout_width="wrap_content" android:layout_height="wrap_content">
android:layout_height="wrap_content" android:text="单个独立线程">
android:layout_height="wrap_content" android:text="两个独立线程">
android:layout_width="fill_parent" android:layout_height="fill_parent">

本文程序的源码：

view plain

package com.testSurfaceView;
import java.lang.reflect.Field;
import java.util.ArrayList;
import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Rect;
import android.os.Bundle;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.widget.Button;
public class testSurfaceView extends Activity {
/** Called when the activity is first created. */
Button btnSingleThread, btnDoubleThread;
SurfaceView sfv;
SurfaceHolder sfh;
ArrayList imgList = new ArrayList();
int imgWidth, imgHeight;
Bitmap bitmap;//独立线程读取，独立线程绘图
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btnSingleThread = (Button) this.findViewById(R.id.Button01);
btnDoubleThread = (Button) this.findViewById(R.id.Button02);
btnSingleThread.setOnClickListener(new ClickEvent());
btnDoubleThread.setOnClickListener(new ClickEvent());
sfv = (SurfaceView) this.findViewById(R.id.SurfaceView01);
sfh = sfv.getHolder();
sfh.addCallback(new MyCallBack());// 自动运行surfaceCreated以及surfaceChanged
}
class ClickEvent implements View.OnClickListener {
@Override
public void onClick(View v) {
if (v == btnSingleThread) {
new Load_DrawImage(0, 0).start();//开一条线程读取并绘图
} else if (v == btnDoubleThread) {
new LoadImage().start();//开一条线程读取
new DrawImage(imgWidth + 10, 0).start();//开一条线程绘图
}
}
}
class MyCallBack implements SurfaceHolder.Callback {
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width,
int height) {
Log.i("Surface:", "Change");
}
@Override
public void surfaceCreated(SurfaceHolder holder) {
Log.i("Surface:", "Create");
// 用反射机制来获取资源中的图片ID和尺寸
Field[] fields = R.drawable.class.getDeclaredFields();
for (Field field : fields) {
if (!"icon".equals(field.getName()))// 除了icon之外的图片
{
int index = 0;
try {
index = field.getInt(R.drawable.class);
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 保存图片ID
imgList.add(index);
}
}
// 取得图像大小
Bitmap bmImg = BitmapFactory.decodeResource(getResources(),
imgList.get(0));
imgWidth = bmImg.getWidth();
imgHeight = bmImg.getHeight();
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
Log.i("Surface:", "Destroy");
}
}
/*
* 读取并显示图片的线程
*/
class Load_DrawImage extends Thread {
int x, y;
int imgIndex = 0;
public Load_DrawImage(int x, int y) {
this.x = x;
this.y = y;
}
public void run() {
while (true) {
Canvas c = sfh.lockCanvas(new Rect(this.x, this.y, this.x
+ imgWidth, this.y + imgHeight));
Bitmap bmImg = BitmapFactory.decodeResource(getResources(),
imgList.get(imgIndex));
c.drawBitmap(bmImg, this.x, this.y, new Paint());
imgIndex++;
if (imgIndex == imgList.size())
imgIndex = 0;
sfh.unlockCanvasAndPost(c);// 更新屏幕显示内容
}
}
};
/*
* 只负责绘图的线程
*/
class DrawImage extends Thread {
int x, y;
public DrawImage(int x, int y) {
this.x = x;
this.y = y;
}
public void run() {
while (true) {
if (bitmap != null) {//如果图像有效
Canvas c = sfh.lockCanvas(new Rect(this.x, this.y, this.x
+ imgWidth, this.y + imgHeight));
c.drawBitmap(bitmap, this.x, this.y, new Paint());
sfh.unlockCanvasAndPost(c);// 更新屏幕显示内容
}
}
}
};
/*
* 只负责读取图片的线程
*/
class LoadImage extends Thread {
int imgIndex = 0;
public void run() {
while (true) {
bitmap = BitmapFactory.decodeResource(getResources(),
imgList.get(imgIndex));
imgIndex++;
if (imgIndex == imgList.size())//如果到尽头则重新读取
imgIndex = 0;
}
}
};
}

oathleo 2011-07-21 10:11 发表评论

Android提高第五篇之Service 转载

oathleo — Thu, 21 Jul 2011 02:10:00 GMT

Android提高第五篇之Service

分类： Android提高 2010-11-08 11:48 5360人阅读评论(11) 收藏举报

本文来自http://blog.csdn.net/hellogv/ ，引用必须注明出处！

上次介绍了Activity以及Intent的使用，这次就介绍Service，如果把Activity比喻为前台程序，那么Service就是后台程序，Service的整个生命周期都只会在后台执行。 Service跟Activity一样也由Intent调用。在工程里想要添加一个Service，先新建继承Service的类，然后到 AndroidManifest.xml -> Application ->Application Nodes中的Service标签中添加。

Service要由Activity通过startService 或者 bindService来启动，Intent负责传递参数。先贴出本文程序运行截图：

本文主要讲解Service的调用，以及其生命周期。

上图是startService之后再stopService的Service状态变化。

上图是bindService之后再unbindService的Service状态变化。

startService与bindService都可以启动Service，那么它们之间有什么区别呢？它们两者的区别就是使Service的周期改变。由 startService启动的Service必须要有stopService来结束Service，不调用stopService则会造成 Activity结束了而Service还运行着。bindService启动的Service可以由unbindService来结束，也可以在 Activity结束之后(onDestroy)自动结束。

上图是startService之后再Activity.finish()的Service状态变化，Service还在跑着。

上图是bindService之后再Activity.finish()的Service状态变化，Service最后自动unbindService。

main.xml代码：

view plain

android:orientation="vertical" android:layout_width="fill_parent"
android:layout_height="fill_parent">
android:layout_height="wrap_content" android:id="@+id/btnStartMyService"
android:text="StartMyService">
android:layout_height="wrap_content" android:id="@+id/btnStopMyService"
android:text="StopMyService">
android:layout_height="wrap_content" android:id="@+id/btnBindMyService"
android:text="BindMyService">
android:layout_height="wrap_content" android:id="@+id/btnUnbindMyService"
android:text="UnbindMyService">
android:layout_height="wrap_content" android:id="@+id/btnExit"
android:text="退出程序">

testService.java的源码：

view plain

package com.testService;
import android.app.Activity;
import android.app.Service;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.View;
import android.widget.Button;
public class testService extends Activity {
Button btnStartMyService,btnStopMyService,btnBindMyService,btnUnbindMyService,btnExit;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btnStartMyService=(Button)this.findViewById(R.id.btnStartMyService);
btnStartMyService.setOnClickListener(new ClickEvent());
btnStopMyService=(Button)this.findViewById(R.id.btnStopMyService);
btnStopMyService.setOnClickListener(new ClickEvent());
btnBindMyService=(Button)this.findViewById(R.id.btnBindMyService);
btnBindMyService.setOnClickListener(new ClickEvent());
btnUnbindMyService=(Button)this.findViewById(R.id.btnUnbindMyService);
btnUnbindMyService.setOnClickListener(new ClickEvent());
btnExit=(Button)this.findViewById(R.id.btnExit);
btnExit.setOnClickListener(new ClickEvent());
}
@Override
public void onDestroy()
{
super.onDestroy();
Log.e("Activity","onDestroy");
}
private ServiceConnection _connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName arg0, IBinder arg1) {
// TODO Auto-generated method stub
}
@Override
public void onServiceDisconnected(ComponentName name) {
// TODO Auto-generated method stub
}
};
class ClickEvent implements View.OnClickListener{
@Override
public void onClick(View v) {
Intent intent=new Intent(testService.this,MyService.class);
if(v==btnStartMyService){
testService.this.startService(intent);
}
else if(v==btnStopMyService){
testService.this.stopService(intent);
}
else if(v==btnBindMyService){
testService.this.bindService(intent, _connection, Service.BIND_AUTO_CREATE);
}
else if(v==btnUnbindMyService){
if(MyService.ServiceState=="onBind")//Service绑定了之后才能解绑
testService.this.unbindService(_connection);
}
else if(v==btnExit)
{
testService.this.finish();
}
}
}
}

MyService.java的源码：

view plain

package com.testService;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
public class MyService extends Service {
static public String ServiceState="";
@Override
public IBinder onBind(Intent arg0) {
Log.e("Service", "onBind");
ServiceState="onBind";
return null;
}
@Override
public boolean onUnbind(Intent intent){
super.onUnbind(intent);
Log.e("Service", "onUnbind");
ServiceState="onUnbind";
return false;
}
@Override
public void onCreate(){
super.onCreate();
Log.e("Service", "onCreate");
ServiceState="onCreate";
}
@Override
public void onDestroy(){
super.onDestroy();
Log.e("Service", "onDestroy");
ServiceState="onDestroy";
}
@Override
public void onStart(Intent intent,int startid){
super.onStart(intent, startid);
Log.e("Service", "onStart");
ServiceState="onStart";
}
}

oathleo 2011-07-21 10:10 发表评论

Android入门第十六篇之Style与Theme 转载

oathleo — Thu, 21 Jul 2011 02:04:00 GMT

Android入门第十六篇之Style与Theme

分类： Android入门 2011-01-11 11:16 10361人阅读评论(28) 收藏举报

本文来自http://blog.csdn.net/hellogv/ ，引用必须注明出处！

越来越多互联网企业都在Android平台上部署其客户端，为了提升用户体验，这些客户端都做得布局合理而且美观.......Android的Style设计就是提升用户体验的关键之一。Android上的Style分为了两个方面：

Theme是针对窗体级别的，改变窗体样式；
Style是针对窗体元素级别的，改变指定控件或者Layout的样式。

Android 系统的themes.xml和style.xml(位于/base/core/res/res/values/)包含了很多系统定义好的style，建议在里面挑个合适的，然后再继承修改。以下属性是在Themes中比较常见的，源自Android系统本身的themes.xml：

view plain

@android:drawable/screen_background_dark
@null
false
false
false
@android:drawable/title_bar_shadow
@android:style/WindowTitle
25dip
@android:style/WindowTitleBackground
@android:style/Animation.Activity

至于控件的Style设计就范围大多了，看看Eclipse的Android控件属性编辑器[Properties]就大概知道有哪些条目，而Android内置的style.xml也只是定义每个控件的默认样式而已....不过控件的style不建议大改，耐看的style更能让用户长时间使用软件。另外，控件的Style在很多情况下都用到9.png，学习9.png就必须到/base/core/res/res/drawable- hdpi里面看看，里面有很多系统内置的9.png。

PS:为了研究Android的Style和Theme，强烈建议下载Android的base.git！

接下来看看本文程序的效果图：

本文程序的themes.xml代码如下，自定义了WindowTitle,：

要为Activity使用theme，要么使用代码 setTheme(R.style.Theme)，要么在Application Manifest里面设置。

本文程序的styles.xml代码如下,background默认使用的是9.png,xml定义在/base/core/res/res/drawable/之下：

main.xml代码如下：

view plain

android:orientation="vertical" android:layout_width="fill_parent"
android:layout_height="fill_parent">
android:layout_height="wrap_content" android:text="@string/hello"
style="@style/TextView" />
style="@style/EditText" android:layout_width="fill_parent"
android:text="类似Button的EditText">
android:layout_width="fill_parent" android:text="普通的EditText">
style="@style/Button" android:layout_width="fill_parent" android:text="类似EditText的Button">

oathleo 2011-07-21 10:04 发表评论

android中使用2D动画 — SurfaceView 转载

oathleo — Thu, 21 Jul 2011 01:45:00 GMT

android中使用2D动画 — SurfaceView

Posted on 2011 年 04 月 25 日 by Mr.Cai

通过之前介绍的如何自定义View，我们知道使用它可以做一些简单的动画效果。它通过不断循环的执行View.onDraw方法，每次执行都对内部显示的图形做一些调整，我们假设 onDraw方法每秒执行20次，这样就会形成一个20帧的补间动画效果。但是现实情况是你无法简单的控制View.onDraw的执行帧数，这边说的执行帧数是指每秒View.onDraw方法被执行多少次，这是为什么呢？首先我们知道，onDraw方法是由系统帮我们调用的，我们是通过调用View的 invalidate方法通知系统需要重新绘制View，然后它就会调用View.onDraw方法。这些都是由系统帮我们实现的，所以我们很难精确去定义View.onDraw的执行帧数，这个就是为什么我们这边要了解SurfaceView了，它能弥补View的一些不足。

首先我们先写一个自定义View实现动画效果，AnimateViewActivity.java：

package com.android777.demo.uicontroller.graphics;

import android.app.Activity;

import android.content.Context;

import android.graphics.Canvas;

import android.graphics.Color;

import android.graphics.Paint;

import android.os.Bundle;

import android.view.View;

public class AnimateViewActivity extends Activity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(new AnimateView(this));

}

class AnimateView extends View{

float radius = 10;

Paint paint;

public AnimateView(Context context) {

super(context);

paint = new Paint();

paint.setColor(Color.YELLOW);

paint.setStyle(Paint.Style.STROKE);

}

@Override

protected void onDraw(Canvas canvas) {

canvas.translate(200, 200);

canvas.drawCircle(0, 0, radius++, paint);

if(radius > 100){

radius = 10;

}

invalidate();//通过调用这个方法让系统自动刷新视图

}

运行上面的Activity，你将看到一个圆圈，它原始半径是10，然后不断的变大，直到达到100后又恢复到10，这样循环显示，视觉效果上说你将看到一个逐渐变大的圆圈。

上面就是一个简单的自定义View实现的动画效果，它能做的只是简单的动画效果，具有一些局限性。首先你无法控制动画的显示速度，目前它是以最快的速度显示，但是当你要更快，获取帧数更高的动画呢？因为View的帧数是由系统控制的，所以你没办法完成上面的操作。如果你需要编写一个游戏，它需要的帧数比较高，那么View就无能为力了，因为它被设计出来时本来就不是用来处理一些高帧数显示的。你可以把View理解为一个经过系统优化的，可以用来高效的执行一些帧数比较低动画的对象，它具有特定的使用场景，比如有一些帧数较低的游戏就可以使用它来完成：贪吃蛇、俄罗斯方块、棋牌类等游戏，因为这些游戏执行的帧数都很低。但是如果是一些实时类的游戏，如射击游戏、塔防游戏、RPG游戏等就没办法使用View来做，因为它的帧数太低了，会导致动画执行不顺畅。所以我们需要一个能自己控制执行帧数的对象，SurfaceView因此诞生了。

什么是SurfaceView呢？

为什么是SurfaceView呢？Surface的意思是表层，表面的意思，那么SurfaceView就是指一个在表层的View对象。为什么说是在表层呢，这是因为它有点特殊跟其他View不一样，其他View是绘制在表层外，而它就是充当表层对象。假设你要在一个球上画画，那么球的表层就当做你的画布对象，你画的东西会挡住它的表层，我们默认没使用SurfaceView，那么球的表层就是空白的，如果我们使用了SurfaceView，我们可以理解为我们拿来的球本身表面就具有纹路，你是画再纹路之上的，如果你画的是半透明的，那么你将可以透过你画的东西看到球面本身的纹路。SDK的文档说到：SurfaceView就是在Window上挖一个洞，它就是显示在这个洞里，其他的View是显示在Window上，所以View可以显式在 SurfaceView之上，你也可以添加一些层在SurfaceView之上。

SurfaceView还有其他的特性，上面我们讲了它可以控制帧数，那它是什么控制的呢？这就需要了解它的使用机制。一般在很多游戏设计中，我们都是开辟一个后台线程计算游戏相关的数据，然后根据这些计算完的新数据再刷新视图对象，由于对View执行绘制操作只能在UI线程上，所以当你在另外一个线程计算完数据后，你需要调用View.invalidate方法通知系统刷新View对象，所以游戏相关的数据也需要让UI线程能访问到，这样的设计架构比较复杂，要是能让后台计算的线程能直接访问数据，然后更新View对象那改多好。我们知道View的更新只能在UI线程中，所以使用自定义View没办法这么做，但是SurfaceView就可以了。它一个很好用的地方就是允许其他线程(不是UI线程)绘制图形(使用Canvas)，根据它这个特性，你就可以控制它的帧数，你如果让这个线程1秒执行50次绘制，那么最后显示的就是50帧。

如何使用SurfaceView？

首先SurfaceView也是一个View，它也有自己的生命周期。因为它需要另外一个线程来执行绘制操作，所以我们可以在它生命周期的初始化阶段开辟一个新线程，然后开始执行绘制，当生命周期的结束阶段我们插入结束绘制线程的操作。这些是由其内部一个SurfaceHolder对象完成的。 SurfaceHolder，顾名思义，它里面保存了一个队Surface对象的引用，而我们执行绘制方法就是操作这个 Surface，SurfaceHolder因为保存了对Surface的引用，所以使用它来处理Surface的生命周期，说到底 SurfaceView的生命周期其实就是Surface的生命周期，因为SurfaceHolder保存对Surface的引用，所以使用 SurfaceHolder来处理生命周期的初始化。首先我们先看看建立一个SurfaceView的大概步骤，先看看代码：

DemoSurfaceView.java：

package com.android777.demo.uicontroller.graphics;

import android.content.Context;

import android.view.SurfaceHolder;

import android.view.SurfaceHolder.Callback;

import android.view.SurfaceView;

public class DemoSurfaceView extends SurfaceView implements Callback{

public DemoSurfaceView(Context context) {

super(context);

init(); //初始化,设置生命周期回调方法

}

private void init(){

SurfaceHolder holder = getHolder();

holder.addCallback(this); //设置Surface生命周期回调

}

@Override

public void surfaceChanged(SurfaceHolder holder, int format, int width,

int height) {

}

@Override

public void surfaceCreated(SurfaceHolder holder) {

}

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

}

上面代码我们在SurfaceView的构造方法中执行了init初始化方法，在这个方法里，我们先获取SurfaceView里的 SurfaceHolder对象，然后通过它设置Surface的生命周期回调方法，使用DemoSurfaceView类本身作为回调方法代理类。 surfaceCreated方法，是当SurfaceView被显示时会调用的方法，所以你需要再这边开启绘制的线程，surfaceDestroyed方法是当SurfaceView被隐藏会销毁时调用的方法，在这里你可以关闭绘制的线程。上面的例子运行后什么也不显示，因为还没定义一个执行绘制的线程。下面我们修改下代码，使用一个线程绘制一个逐渐变大的圆圈：

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

package com.android777.demo.uicontroller.graphics;

import android.content.Context;

import android.graphics.Canvas;

import android.graphics.Color;

import android.graphics.Paint;

import android.view.SurfaceHolder;

import android.view.SurfaceHolder.Callback;

import android.view.SurfaceView;

public class DemoSurfaceView extends SurfaceView implements Callback{

LoopThread thread;

public DemoSurfaceView(Context context) {

super(context);

init(); //初始化,设置生命周期回调方法

}

private void init(){

SurfaceHolder holder = getHolder();

holder.addCallback(this); //设置Surface生命周期回调

thread = new LoopThread(holder, getContext());

}

@Override

public void surfaceChanged(SurfaceHolder holder, int format, int width,

int height) {

}

@Override

public void surfaceCreated(SurfaceHolder holder) {

thread.isRunning = true;

thread.start();

}

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

thread.isRunning = false;

try {

thread.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

/**

* 执行绘制的绘制线程

* @author Administrator

*

*/

class LoopThread extends Thread{

SurfaceHolder surfaceHolder;

Context context;

boolean isRunning;

float radius = 10f;

Paint paint;

public LoopThread(SurfaceHolder surfaceHolder,Context context){

this.surfaceHolder = surfaceHolder;

this.context = context;

isRunning = false;

paint = new Paint();

paint.setColor(Color.YELLOW);

paint.setStyle(Paint.Style.STROKE);

}

@Override

public void run() {

Canvas c = null;

while(isRunning){

try{

synchronized (surfaceHolder) {

c = surfaceHolder.lockCanvas(null);

doDraw(c);

//通过它来控制帧数执行一次绘制后休息50ms

Thread.sleep(50);

}

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

surfaceHolder.unlockCanvasAndPost(c);

}

public void doDraw(Canvas c){

//这个很重要，清屏操作，清楚掉上次绘制的残留图像

c.drawColor(Color.BLACK);

c.translate(200, 200);

c.drawCircle(0,0, radius++, paint);

if(radius > 100){

radius = 10f;

}

上面代码编写了一个使用SurfaceView制作的动画效果，它的效果跟上面自定义View的一样，但是这边的SurfaceView可以控制动画的帧数。在SurfaceView中内置一个LoopThread线程，这个线程的作用就是用来绘制图形，在SurfaceView中实例化一个 LoopThread实例，一般这个操作会放在SurfaceView的构造方法中。然后通过在SurfaceView中的SurfaceHolder的生命周期回调方法中插入一些操作，当Surface被创建时(SurfaceView显示在屏幕中时)，开启LoopThread执行绘制，LoopThread会一直刷新SurfaceView对象，当SurfaceView被隐藏时就停止改线程释放资源。这边有几个地方要注意下：

1.因为SurfaceView允许自定义的线程操作Surface对象执行绘制方法，而你可能同时定义多个线程执行绘制，所以当你获取 SurfaceHolder中的Canvas对象时记得加同步操作，避免两个不同的线程同时操作同一个Canvas对象，当操作完成后记得调用 SurfaceHolder.unlockCanvasAndPost方法释放掉Canvas锁。

2.在调用doDraw执行绘制时，因为SurfaceView的特点，它会保留之前绘制的图形，所以你需要先清空掉上一次绘制时留下的图形。(View则不会，它默认在调用View.onDraw方法时就自动清空掉视图里的东西)。

3. 记得在回调方法：onSurfaceDestroyed方法里将后台执行绘制的LoopThread关闭，这里是使用join方法。这涉及到线程如何关闭的问题，多数人建议是通过一个标志位：isRunning来判断线程是否该停止运行，如果你想关闭线程只需要将isRunning改成false即可，线程会自动执行完run方法后退出。

总结：

通过上面的分析，现在大家应该会简单使用SurfaceView了，总的归纳起来SurfaceView和View不同之处有：

1. SurfaceView允许其他线程更新视图对象(执行绘制方法)而View不允许这么做，它只允许UI线程更新视图对象。

2. SurfaceView是放在其他最底层的视图层次中，所有其他视图层都在它上面，所以在它之上可以添加一些层，而且它不能是透明的。

3. 它执行动画的效率比View高，而且你可以控制帧数。

4. 因为它的定义和使用比View复杂，占用的资源也比较多，除非使用View不能完成，再用SurfaceView否则最好用View就可以。(贪吃蛇，俄罗斯方块，棋牌类这种帧数比较低的可以使用View做就好)

oathleo 2011-07-21 09:45 发表评论

Android surfaceView 与View 的区别 (转载)

oathleo — Thu, 21 Jul 2011 01:36:00 GMT

Android surfaceView 与View 的区别

如果你的游戏不吃CPU，用View就比较好，符合标准Android操作方式，由系统决定刷新surface的时机。

　　但如果很不幸的，你做不到不让你的程序吃CPU，你就只好使用SurfaceView来强制刷新surface了，不然系统的UI进程很可能抢不过你那些吃CPU的线程。

　　当然其实不止这两种方法来刷新Surface的，这两种只是纯Java应用比较常见的方法。

　　SurfaceView和View最本质的区别在于，surfaceView是在一个新起的单独线程中可以重新绘制画面而View必须在UI的主线程中更新画面。

　　那么在UI的主线程中更新画面可能会引发问题，比如你更新画面的时间过长，那么你的主UI线程会被你正在画的函数阻塞。那么将无法响应按键，触屏等消息。

　　当使用surfaceView 由于是在新的线程中更新画面所以不会阻塞你的UI主线程。但这也带来了另外一个问题，就是事件同步。比如你触屏了一下，你需要surfaceView中 thread处理，一般就需要有一个event queue的设计来保存touch event，这会稍稍复杂一点，因为涉及到线程同步。

　　所以基于以上，根据游戏特点，一般分成两类。

　　1 被动更新画面的。比如棋类，这种用view就好了。因为画面的更新是依赖于 onTouch 来更新，可以直接使用 invalidate。因为这种情况下，这一次Touch和下一次的Touch需要的时间比较长些，不会产生影响。

　　2 主动更新。比如一个人在一直跑动。这就需要一个单独的thread不停的重绘人的状态，避免阻塞main UI thread。所以显然view不合适，需要surfaceView来控制。

oathleo 2011-07-21 09:36 发表评论

Android 1.5 1.6 2.0 2.1 2.2 2.3 3.0的区别 (转载)

oathleo — Fri, 15 Jul 2011 01:32:00 GMT

Android 1.5 API变更概要:
UI framework
· Framework for easier background/UI thread interaction
· 新SlidingDrawer 组件
· 新HorizontalScrollview 组件
AppWidget framework
· 一些关于创建桌面AppWidget 的API.
· 提供根据自定义的内容创建LiveFolders的API
Media framework
· 原声录音和回放 APIs
· 交互式的MIDI 回放引擎
· 开发者使用的视频录像API (3GP format).
· 视频相片分享 Intents
· 媒体搜索Intent
Input Method framework
· 输入法服务framework
· 文本预测引擎
· 提供具有下载能力的IME给使用者
Android软键盘的隐藏显示研究：
http://winuxxan.blog.51cto.com/2779763/522810
android软键盘出来的时候覆盖底部的tab导航:
http://www.eoeandroid.com/thread-67098-1-1.html
android 软键盘Enter键图标的设置:
http://archive.cnblogs.com/a/1994418/
Application-defined hardware requirements
应用可定义硬件需求,应用程序可以定义说明此程序需要什么硬件需求.比如是否需要物理键盘或者轨迹球.
Speech recognition framework
· 支持语音识别库.
Miscellaneous API additions
· LocationManager -应用可以接收到位置改变的信息.
· WebView - 触摸start/end/move/cancel   DOM 事件的支持
· 重建Sensor Manager APIs
· GLSurfaceView - 创建OpenGL 应用更加方便的framework .
· 软件升级安装成功的Broadcast Intent - 更加平和优秀的软件升级体验

Android 1.6 API变更概要:
UI framework
· 新的类 android.view.animation 控制动画行为:
o AnticipateInterpolator
o AnticipateOvershootInterpolator
o BounceInterpolator
o OvershootInterpolator
· 新的XML 属性android:onClick ,从一个layout文件描述一个view的 View.OnClickListener.
· 对不同分辨率的屏幕的新的支持. 对于Bitmap和Canvas会执行有针对性的缩放行为.该框架会根据屏幕分辨率和其他内容自动缩放bitmap等.
要在你的应用中使用Android 1.6包含的API的话你必须要设置 "4"属性在manifest的元素中
Search framework
· 应用程序现在可以公开的有关内容，作为建议放入快速搜索框，新的设备范围内的搜索功能，是可从主屏幕搜索。为了支持这一点，搜索框架增加了新的属性，可搜索的元数据文件。有关完整的信息，请参阅SearchManager
文档。
Accessibility framework
· New android.accessibility package that includes classes for capturing accessibility events and forwarding them to an AccessibilityService handler.
· New AccessibilityService package that lets your application track user events and provide visual, audible, or haptic feedback to the user.
Gesture Input
· 新的gesture API :创建,识别,读取,保存手势.
Text-to-speech
· 新的android.speech.tts 包提供了TTS文本朗读功能,从一个文本生成一个声音文件的回放.
http://blog.csdn.net/CBirdLG/archive/2010/10/10/5931728.aspx
Graphics
· android.graphics 中的类,现在支持为不同的屏幕尺寸进行缩放.
Telephony
· 新的SmsManager 发送和接受短信.
Utilities
· 新的DisplayMetrics 字段决定当前设备屏幕的密度.
Android Manifest elements
o 新的元素
o 新的标签
o glEsVersion: 指定最小openGL ES的版本
·
元素的新的属性:
o 目标SDK版本: 应用程序能够指定目标版本. 它能够运行在旧版本（低至minSdkVersion）, 他是按照应用程序的指定版本开发的. Specifying this version allows the platform to disable compatibility code that is not required or enable newer features that are not available to older applications.
o maxSdkVersion: 指定设计这个程序运行的最高版本重要: 当使用这些属性前请认真阅读文档.
New Permissions
· CHANGE_WIFI_MULTICAST_STATE: 允许应用进入Wi-Fi 多点传送模式.
· GLOBAL_SEARCH: 允许全局搜索系统,以便精确确定 content provider.
· INSTALL_LOCATION_PROVIDER: 允许应用在Location Manager.安装一个location provider.
· READ_HISTORY_BOOKMARKS: 允许应用读取(并不能写) 用户的浏览记录和书签
· WRITE_HISTORY_BOOKMARKS: 允许应用写入 (并不能读) 用户的浏览记录和书签
· WRITE_EXTERNAL_STORAGE: 允许程序写入外部存储器.应用程序使用API级别3下将默认授予此权限 (这对用户可见的); 应用程序使用API level4 或者更高的,必须要明确的宣告此权限.

Android 2.0 API变更概要:
Bluetooth
· 开启关闭蓝牙
· 设备和服务发现
· 使用 RFCOMM连接一个可插拔的设备收发数据
· 公布RFCOMM 服务和监听接收 RFCOMM 连接
Sync adapters
· 新的APIs, 同步桥接器连接任何backend
Account Manager
· 集中的帐户管理器 API ,安全的储存和使用可信的tokens/passwords
Contacts
· 新的通信APIs 允许获取多个账户的数据.
· 新的快速通信framework APIs 允许开发者在他们的应用中创建通信标记, 一键点击标记打开一个新的窗口展示一个如何联系当前人的列表.
WebView
· 不赞成使用的类: UrlInterceptHandler, Plugin, PluginData, PluginList, UrlInterceptRegistry.
Camera
· 颜色模式, 场景模式闪光模式, 焦点模式, 白平衡旋转和其他设置的新的特征.
· 当缩放级别改变的时候,会回调新的缩放回调接口.
Media
· MediaScanner现在为所有图片生成缩微图when they are inserted into MediaStore.
· 新的缩微图 API : 检索需要的图片和视频的缩微图.
Other Framework
· android.R.style 中新的系统主题,能够更加简单的显示当前acitivities的系统壁纸或者保持之前的activity在后台.新的壁纸管理器API 取代并且增加了wallpaper APIs ,我们可以允许我们的应用要求设置系统壁纸.
· 新的Service APIs帮助应用准确的处理Service 生命周期 ,在指定的低内存状态下service将会被关闭.
o Service.setForeground() 不推荐使用,并且现在这个方法并没有实际执行. .他被一个新的API所取代, startForeground(), that helps (and requires) associating an ongoing notification with the foreground state.
· MotionEvent 如果设备允许的话,MotionEvent 会返回多点触摸信息.最多可同时获取3点
· KeyEvent 现在有了新的按键发送 APIs,去帮助实现 action-on-up 和长按键行为, 一个新的机制取消按键 (虚拟按键).
· WindowManager.LayoutParams 现在有了新的常量允许窗口能够在被锁或者其他的状况中唤醒屏幕,这个允许程序能够让例如闹钟等的应用实现唤醒设备.
· New Intent APIs 广播设备的对接状态,当这个设备放在桌面或者停车场,允许程序启动特殊的activity.
Key events executed on key-up
Android 2.0能够使用虚拟按键HOME, MENU, BACK和SEARCH,而非物理按键,为了让用户在他们的设备中获得最好的用户体验,android平台现在把这些按键执行加入到了key-up,做了 key-down/key-up 配对,而非只有key-down.,这有助于防止意外按钮事件，并让使用者按下按钮区域，然后拖动而不生成一个事件出来。
这种改变只会影响你的应用程序一点,如果它是拦截按钮事件，最好用key-down，而不是key-up.。特例,如果您的应用程序拦截BACK 键，你应该确保你的应用妥善处理按键事件。

Android 2.0.1 API变更概要:
· 新的快速联系人标记风格(quickContactBadgeStyle)* 属性,让应用的QuickContactBadge 组件接收必要的风格.
· 当在manifest里面宣布了filter,取消了支持 ACTION_CONFIGURATION_CHANGED 广播 ,如果想要去接收这个广播, 这个应用必须注册 registerReceiver(BroadcastReceiver, IntentFilter).
性能上的改变:
Bluetooth
改变了 ACTION_REQUEST_ENABLE 和ACTION_REQUEST_DISCOVERABLE的返回值
· ACTION_REQUEST_ENABLE 如果蓝牙是成功开启的,现在返回RESULT_OK .如果使用者拒绝开启蓝牙的请求,则会返回RESULT_CANCELED .
· ACTION_REQUEST_DISCOVERABLE 如果使用者拒绝启动蓝牙或者蓝牙的可发现功能,则返回 RESULT_CANCELED .
通讯
The ACTION_INSERT Intent returns RESULT_CANCELED in cases where the contact was not persisted (例如剪切保存到一个空的操作里面).
修复错误:
资源
现在framework可以正选择应用资源的根据API等级划分的文件夹(drawable-v4是API level4版本用的资源).现在的版本这个功能不能正常工作的问题已经修复.
Contacts
The ACTION_INSERT Intent now returns the appropriate kind of URI when the request is made using the (now deprecated) Contacts APIs.
Other Framework fixes
· getCallingPackage() 现在正确的报告包名, 而不是进程名.

Android 2.1 API变更概要:
Live Wallpapers 动态桌面
以下增加的API可以提供你开发动态的桌面:
· 新android.service.wallpaper 包.
· 新WallpaperInfo 类.
· 升级的WallpaperManager.

附加说明, 如果你的应用相提供Live Wallpapers的功能, 你必须记得增加一个元素到你的应用manifest里面. 宣布这个属性android:name="android.software.live_wallpaper". 举例:
电话

· 新的SignalStrength 类提供当前网络信号的一些信息这些信息可以从onSignalStrengthsChanged(SignalStrength) 回调.
· 新的onDataConnectionStateChanged(int, int) 回调.
Views
· 新的View 方法isOpaque() 和onDrawScrollBars(Canvas).
· 新的RemoteViews 方法addView(int, RemoteViews) 和removeAllViews(int).
· 新的ViewGroup 方法isChildrenDrawingOrderEnabled() 和setChildrenDrawingOrderEnabled(boolean).

WebKit
· 新的WebStorage 方法操作网页数据缓存.
· 新的GeolocationPermissions 方法获取 Geolocation permissions 的出处, 把他们设置到 WebView上.
· 新的WebSettings 方法管理软件缓存, 网页缓存和屏幕的缩放.
· 新的WebChromeClient 方法处理视频, 历史记录, 自定义view, 软件缓存限制还有其他

Android 2.2 API变更概要:
对Microsoft Exchange更好的支持。Android的几个新特性使之更适于Exchange企业环境。其中一些新特性列举如下：

基于用户名/密码的Exchange帐号自动检测
支持Exchange日历的同步
改进的安全性，管理员可以跨越设备强制应用安全策略
恢复出场设置——管理员可以将设备重置为出场设置，这样就能在设备被偷或丢失后擦除上面的敏感数据了
全局的地址列表查找——可以根据服务器端返回的列表帮助用户自动填充收件人的邮件地址
设备管理API。Android 2.2改进并新增了大量的设备管理API，开发者可以将其用在应用当中：
应用数据备份API——可以将应用数据备份到云中。如果用户切换到另一个Android设备，他就可以从之前的设备中恢复数据。
Cloud-to-Device消息API。云中的用户/系统可以凭借这种增强在设备上触发动作。该特性可以将移动警告发给手机并且支持双向的推同步服务。
可以直接在外部的内存设备（SD卡）上安装应用，还可以将应用从内部迁移到SD卡上，反之亦然。
网络共享。Android 2.2可以通过一台Android电话提供的热点将多个服务连接到Internet上。

性能。借助于新式的Dalvik JIT编译器，对于CPU密集型应用来说，Android 2.2的速度要比Android 2.1快2～5倍。根据Linpack基准测试结果，安装了Froyo的Nexus
One电话可以达到37.5 MFlops，而同样的电话如果使用Android 2.1的话才有6.5 MFlops。

更快的浏览速度。由于浏览器现在使用了Chrome V8引擎，JavaScript代码的处理速度要比Android 2.1快2～3倍。

从浏览器中访问设备API。现在可以直接从浏览器中访问大量的设备API，如加速器、相机、声音识别、翻译等，这样Web应用就能以前所未有的方式与设备交互了。比如说，用户可以在拍完照后将其上传到网上，而这一切都是在浏览器内完成的。

支持Flash 10.1。Froyo支持最新的Flash 10.1
Beta版。最近，JIT编译器的引入极大地改进了性能，这对Flash应用的运行起到了巨大的帮助作用，因为大家都知道，Flash应用是一种CPU密集型应用。

Android商店。Android 2.2开发者和商店用户会从如下新特性中受益无穷：

可以在Android商店搜索应用，包括应用数据

更新——点击一次按钮后会自动更新所有应用

崩溃与冻结报告。Android
2.2集成了崩溃/冻结报告特性，这样在崩溃时用户就可以将完整的细节信息报告给应用发布者了

从PC上浏览商店并将应用直接下载到设备上。用户可以通过PC选择商店的应用，之后应用就可以发到到加载的设备上。要想使用这个特性，用户需要登录并且设备需要在Android商店注册-
音乐管理。用户可以将Windows Media或Mac iTunes上的所有非DRM音乐转换到Android设备上播放。

Android 2.3 API变更概要:
Android 2.3姜饼发布，代号Gingerbread，包含哪些新特性和改进呢?

   1. 新增android.net.sip包，名为SipManager类，可以轻松开发基于Sip的Voip应用。同时使用时必须至少包含这两个权限 and ，如果需要在Market上过滤仅显示支持VoIP API的机型，可以在发布时androidmanifest.xml中加入和这两个标志。

2. Near Field Communications (NFC) 近距离通讯的支持，NFC可以在不接触的情况下实现数据交换通讯，可以很好的代替RFID SIM卡实现手机支付等扩展功能，当然Android123提示这需要硬件的支持
，新增包在 android.nfc包含NfcAdapter,NdefMessage,NdefRecord等类，类似蓝牙的处理方式，使用该API需要声明权限，同时在Market上过滤支持NFC的设备需要加入这句。

3. 新增陀螺仪和其他的传感器支持
Android 2.3加入了一些新的感应器，比如gyroscope陀螺仪, rotation vector旋转向量, linear acceleration线性加速器 gravity和barometer气压计的支持。如果过滤这些功能，发布时加入类似到androidmanifest.xml中。

4. 多摄像头支持
新增 Camera.CameraInfo 可以管理摄像头前置或后置
新增 getNumberOfCameras(), getCameraInfo() 和 getNumberOfCameras() 获取摄像头数量。
新增 get() 方法，可以获取摄像头配置信息 CamcorderProfile
新增 getJpegEncodingQualityParameter() 获取jpeg编码质量参数可以在 CameraPreview.java 文件从ApiDemos示例程序中查看。

5. 新增拍照API
比如获取焦距getFocusDistances()获取预览FPS getPreviewFpsRange(), 获取焦距范围 getSupportedPreviewFpsRange() 和设置教育 setPreviewFpsRange()

6. 混响音效
本次Android 2.3框架中加入了对混响音效的支持，比如低音，耳机和虚拟化等效果.
新增 android.media.audiofx 包
新增 AudioEffect 类提供音效控制
新增音频会话ID，设置 AudioTrack 和 MediaPlayer.
新 AudioTrack 新增 attachAuxEffect()、getAudioSessionId()和 setAuxEffectSendLevel()。
新 attachAuxEffect() ,getAudioSessionId(), setAudioSessionId(int), 和 setAuxEffectSendLevel() .
相关音效在 AudioFxDemo.java 的 ApiDemos 示例。

6. 照片EXIF信息改进
新增经纬度标签在JPG格式的EXIF中，同时可以使用 getAltitude() 方法获取经纬度的EXIF信息
新增setOrientationHint() 可以让程序获取视频录制的方向.

7. 下载管理
在Android 2.3中新增的下载管理支持长时间运行的Http下载服务支持。可以保证在手机重启后仍然重试下载等操作，整个过程在后台执行。
通过 DownloadManager 类使用getSystemService(DOWNLOAD_SERVICE) 来实例化，通过 ACTION_NOTIFICATION_CLICKED 这个Intent来处理。
http://www.android123.com.cn/androidkaifa/723.html

8. 限制模式
可以帮助开发者监控他的应用的性能，处理线程阻塞，避免ANR的发生。

StrictMode.ThreadPolicy 和 StrictMode.VmPolicy 获取VM相关信息.
使用限制模式优化的Android应用程序可以查看android.os.StrictMode包的具体介绍。

Android 3.0 API变更概要:
Android 3.0 SDK中新增了哪些API呢? 我们总结下平板系统honeycomb中的新特性, 首先需要澄清的是经过Android123发现设置模拟器的分辨率到普通WVGA这样的解析度时平板的特性自动消失和Android 2.3没有什么太大区别，按照这样来看未来Android 3.0除了兼容平板外还继续可以被手机所支持，据称3.0的代码针对A9双核CPU进行了进一步的改进。

　　一、Fragments 碎片容器
　　有关Android Fragments的内容，Android开发网在前几天已经用几篇文章详细讲解了下，大家可以从Fragment对比Activity - Android碎片介绍一文开始了解。

　　二、Action Bar 活动栏
　　活动栏Action Bar可以替换传统的标题栏在Activity窗口中，包括程序图标和一些新接口在activity的选项菜单中，另外Action Bar允许你
　　Include select menu items directly in the Action Bar—as "action items"—for quick access to global user actions.
　　In your XML declaration for the menu item, include the attribute, android:showAsAction with a value of "ifRoom". When there's enough room in the Action Bar, the menu item appears directly in the bar. Otherwise, the item is placed in the overflow menu, revealed by the icon on the right side of the Action Bar.
　　Add interactive widgets to the Action Bar—as "action views"—such as a search box.
　　In the XML for the menu item that should behave as an action view, include the android:actionViewLayout attribute with a layout resource for the action view or android:actionViewClass with the class name of the widget. Like action items, an action view appears only when there's room for it in the Action Bar. If there's not enough room, it is placed in the overflow menu and behaves like a regular menu item (for example, an item can provide a SearchView as an action view, but when in the overflow menu, selecting the item activates the search dialog).
　　Add an action to the application logo when tapped and replace it with a custom logo
　　The application logo is automatically assigned the android.R.id.home ID,
which the system deliveres to your activity's onOptionsItemSelected() callback when tapped. Simply respond to this ID in your callback method to perform an action such as go to your application's "home" activity.
　　To replace the icon with a logo,
　　Add breadcrumbs for navigating backward through fragments
　　Add built in tabs and a drop-down list for navigation
　　Customize the Action Bar themes and custom backgrounds
　　有关ActionBar的文章，可以参考 Action Bar使用方法 - Android活动栏系列文章

　　三、System clipboard系统剪切板
　　Android 3.0中的剪切板进行了增强，本次可以支持除了纯文本外更多的内容，如，URL和Intent，对于剪切板类ClipboardManager仍然通过 getSystemService(CLIPBOARD_SERVICE)来实例化，新增的ClipData类用于管理具体的复制对象，可以在SDK的 android.content.ClipData.Item中找到。具体的使用Android123将在今后的文章中写道。

　　四、拖拽
　　开始拖拽内容在你的Activity中可以使用startDrag()方法在一个View中，这里 View.DragShadowBuilder提供了拖拽时的阴影，对于拖拽的过程处理可以通过OnDragListener通过View的 setOnDragListener()来设置，在拖拽的时候系统会自动调用onDrag()方法。

　　五、增强的appWidgets
　　Android 3.0的appWidget开始支持更丰富的控件，比如GridView, ListView, StackView, ViewFlipper和AdapterViewFlipper.而以前必须通过RemoteView显示一个文本或图片，本次全新的 RemoteViewsService增强了桌面小插件的功能。

　　六、增强的状态提示栏
　　新增的Notification API可以丰富你的状态栏，新的Notification.Builder类可以帮助你轻松实现，支持大图标提示信息通过setLargeIcon方法，通常显示一些社交类的软件，比如联系人照片，或相册缩略图，设置自定义状态栏，可以使用setTicker()方法。

　　七、内容加载器
　　新框架API提供了一个异步加载内容的泪，合并和UI组件和fragment来动态加载数据从工作者现成，使用CursorLoader子类来获取ContentResolver中的数据.

　　八、A2DP蓝牙和耳机控制API
　　Android honeycomb中没有忘记再次增强蓝牙，你可以通过初始化BluetoothProfile通过调用getProfileProxy()在处理 A2DP或耳机HEADSET设置，BluetoothProfile.ServiceListener可以获取客户端连接或断开的回调。
　　九、动画框架
　　3.0中Android再次增强动画播放类，ObjectAnimator和LayoutTransition需要大家了解一些。

　　十、扩展UI框架
　　新增以下UI控件
　　AdapterViewAnimator
　　AdapterViewFlipper
　　CalendarView
　　ListPopupWindow
　　NumberPicker
　　PopupMenu
　　SearchView
　　StackView

　　十一、图形相关
　　1. 2D图形硬件加速Hardware accelerated 2D graphics ，在androidmanifest.xml的元素中添加android:hardwareAccelerated="true" 即可。他可以优化程序运行更平滑高效，在滚动和动画方面。
　　2.设置渲染模式，比如 LAYER_TYPE_HARDWARE 硬件加速和 LAYER_TYPE_SOFTWARE 使用 setLayerType() 方法.
　　3.渲染脚本对于3D图形方面大家可以看看Renderscript类。

　　上面是Android 3.0的主要改进，明天Android开发网将和大家一起说下强大的对于平板电脑比较重要的Action Bar活动栏。

oathleo 2011-07-15 09:32 发表评论

Android 最常见功能 Demo

oathleo — Wed, 04 Aug 2010 08:37:00 GMT

功能很简单：
1.从后台实时取数据展示 Demo 是用socket取，起Task每秒去取
2.把取得数据展示成图表形式
3.把取得数据展示成拓扑图形式
代码很简单，拓扑部分在另个项目中，以后集成进Demo

oathleo 2010-08-04 16:37 发表评论

BlogJava-咖啡伴侣-随笔分类-Android

新android的rom的log功能无法使用

android手势效果-水果忍者 刀锋效果/光刀效果

Android 事件返回值

activity launchmode

PopupWindow自适应大小

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

Android WebView Java和Javascript互调的例子 转

proguard ant 混淆

android GestureListener 手势 多指缩放

android:padding和android:layout_margin的区别

android layout xml

android 内部资源获取

终于把script包源码扒出来了

编写高效的Android代码(Designing for Performance)

Can't create handler inside thread that has not called Looper.prepare() 异常问题

XmlPullParser 效率问题

高级画布绘图（3）

高级画布绘图（2）

高级画布绘图（1）

Android 渐变 -- Shader

Paint类常用方法

SurfaceView 翻转

android中context

Android提高第三篇之SurfaceView与多线程的混搭 转载

Android提高第五篇之Service 转载

Android提高第五篇之Service

Android入门第十六篇之Style与Theme 转载

Android入门第十六篇之Style与Theme

android中使用2D动画 — SurfaceView 转载

android中使用2D动画 — SurfaceView

什么是SurfaceView呢？

如何使用SurfaceView？

总结：

Android surfaceView 与View 的区别 (转载)

Android surfaceView 与View 的区别

Android 1.5 1.6 2.0 2.1 2.2 2.3 3.0的区别 (转载)

Android 最常见功能 Demo

android手势效果-水果忍者刀锋效果/光刀效果

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

Android WebView Java和Javascript互调的例子转

android GestureListener 手势多指缩放

Android提高第三篇之SurfaceView与多线程的混搭转载