博客园_谦虚的天下

Android学习系列(24)--App代码规范之使用CheckStyle

2012-01-01T15:45:00Z

最近经常思考团队开发的一些东西，其中代码风格不统一是最常见的问题之一。按理说，大家协商和沟通一下，风格统一一下就可以了，其实不然，因为这是个个性张扬的时代！
工作code review中用了CheckStyle小半年了，觉得很好很强大很方便，使用起来也很方便，大家写出来的代码就像一个人写出来的一样，值此辞旧迎新，特简做说明，与尔同飨。

1.简介
官方网站：http://checkstyle.sourceforge.net/
CheckStyle提供了一个帮助JAVA开发人员遵守某些编码规范的工具。它能够自动化代码规范检查过程，从而使得开发人员从这项重要，但是枯燥的任务中解脱出来。
CheckStyle检验的主要内容
(1). Javadoc注释
(2). 命名约定
(3). 标题
(4). Import语句
(5). 体积大小
(6). 空白
(7). 修饰符
(8). 块
(9). 代码问题
(10). 类设计
(11). 混合检查（包活一些有用的比如非必须的System.out和printstackTrace）

2.定制
官方提供的代码规范往往太过严格，在工作中使用不太现实，所以有必要根据具体情况来定制具体的代码规范，CheckStyle对代码规范的定制提供了很多大灵活性。
下面我们来定义一些基本的规范，后续有增加我们再修改。
(1). 不要tab键;
(2). 避免重复的import, 多余的import和import *
(3). 常量全部大写字母(static final);
(4). 成员变量以m开头;
(5). 当有多重修饰符时,修饰符采用以下顺序:(public,protected,private,abstract,static,final,transient,volatile,synchronized,native,strictfp)
... ...
其他的我们后面慢慢的修改。

3.配置文件
在运行checkstyle时，需要一个参数(注:我的ubuntu服务器上安装的checkstyle5.4版本，最新的是5.5版本)：

这个配置文件就是用来定义你自己定制的代码规范，你可以参考官方说明：http://checkstyle.sourceforge.net/availablechecks.html
这里，我们根据上面说的，来写这样一个code_check.xml :

<?xml version="1.0"?>
<!DOCTYPE module PUBLIC
    "-//Puppy Crawl//DTD Check Configuration 1.2//EN"
    "http://www.puppycrawl.com/dtds/configuration_1_2.dtd">

<module name="Checker">

    <!-- 检查文件是否以一个新行结束-->
    <module name="NewlineAtEndOfFile"/>
    
	<!-- 检查文件中是否含有tab键-->
	<module name="FileTabCharacter"/>
		
	<module name="TreeWalker">

	    <!-- 常量全部用大写-->
	    <module name="ConstantName"/>

		<!-- 避免.*,重复多余的和不使用的import-->
		<module name="AvoidStarImport"/>
        <module name="RedundantImport"/>
        <module name="UnusedImports"/>
		
	    <!-- 成员变量格式为:m+大写+字母-->
		<module name="MemberName">
			<property name="format" value="^m[A-Z][a-zA-Z0-9]*$"/>
		</module>

		<!-- 检查代码块:起始大括号和if等同行，不能有空的代码块，结束大括号另起一行-->
		<module name="LeftCurly"/>
        <module name="NeedBraces"/>
        <module name="RightCurly"/>
        <!-- 当有多重修饰符时,修饰符采用以下顺序:
             (public,protected,private,abstract,static,final,
             transient,volatile,synchronized,native,strictfp) -->
		<module name="ModifierOrder"/>
    </module>

</module>

更多检查规范中文说明参考园子里地址： http://www.cnblogs.com/liugang/archive/2010/10/26/1860903.html

4.使用checkstyle
插件工具的使用我就不介绍了，我只想起个抛砖引玉的作用，checkstyle命令非常简单，这里我只说明3个参数：-c, -r, -o。

/*******************
 ***CheckStyle Usage**
 ******************/
/***
 *参数
 *1. -c  配置文件,并验证文件
 *2. -o 输出结果
 *3. -r  遍历目录
 **/

//用我们定制的code_checks.xml检查文件
$>checkstyle -c ~/GitProj/world/code_checks.xml 
  ~/GitProj/world/floworld/src/com/tianxia/app/floworld/appreciate/AppreciateLatestActivity.java

//用我们定制的code_checks.xml检查目录下的所有源文件，并把结果输出到result.txt中
$>checkstyle -c ~/GitProj/world/code_checks.xml  
  -r ~/GitProj/world/floworld/src/com/tianxia/app/floworld/appreciate/

我们打开result.txt来看下输出结果：

又是tab又是命名不规范，非常的准确。

5.与Git挂钩
快12点了，我先把文章发表出来，这部分随后我再补写。

本文链接

Android学习系列(17)--App列表之圆角ListView(续)

2011-12-11T03:47:00Z

本来这篇文章想并到上篇Android学习系列(16)--App列表之圆角ListView中的，但是若是如此就让大家错过一篇新的好的文章，着实可惜。
上篇中我们使用shape，corners，gradient实现了一个渐变的圆角效果，但是在完文之后的实践中，我发现有时效果不甚满意，选中和放手的事件监听没有去正确的判断，然后渐变效果也比较单一，性能也觉得不是很快，不如用图片来的惊艳和迅速，又懒的去改原来的，所以我又用图片来实现一个更完美的效果。

1. 准备
您可能需要参考我之前的两篇文章:
(1). Android学习系列(16)--App列表之圆角ListView
(2). Android学习系列(4)--App自适应draw9patch不失真背景
了解圆角的基本实现原理和9patch图片的制作和注意事项。

2. 效果图(我准备了3套皮肤)

3. 圆角类CornerListView的实现：

/**
 * 圆角ListView
 */
public class CornerListView extends ListView {

    public CornerListView(Context context) {
        this(context, null);
    }

    public CornerListView(Context context, AttributeSet attrs) {
        super(context, attrs);
        //整个listview的圆角背景
        this.setBackgroundResource(R.drawable.corner_list_bg);
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
        case MotionEvent.ACTION_DOWN:
                int x = (int) ev.getX();
                int y = (int) ev.getY();
                int itemnum = pointToPosition(x, y);

                if (itemnum == AdapterView.INVALID_POSITION){
                    break;
                } else {
                        if (itemnum == 0){
                                if (itemnum == (getAdapter().getCount()-1)) {
                                    //只有一项
                                    setSelector(R.drawable.corner_list_single_item);
                                } else {
                                    //第一项
                                    setSelector(R.drawable.corner_list_first_item);
                                }
                        } else if (itemnum==(getAdapter().getCount()-1)){
                             //最后一项
                            setSelector(R.drawable.corner_list_last_item);
                        } else {
                            //中间项
                            setSelector(R.drawable.corner_list_item);
                        }
                }
                break;
        case MotionEvent.ACTION_UP:
                break;
        }
        return super.onInterceptTouchEvent(ev);
    }
}

从上面看到，我们用到了一张ListView的背景图片和4个项选择器。

4. 素材
一种5张图片素材：1张背景图片和4个项选择器对应的选中图片，都是9patch图片：

分别对应的是：
R.drawable.corner_list_bg，
R.drawable.corner_list_first_pressed，
R.drawablecorner_list_last_pressed，
R.drawablecorner_list_pressed，
R.drawablecorner_list_single_pressed

5.选择器构造
根据前面的后4张图片我们来构造选中时的对应选择器：

<!-- corner_list_first_item.xml -->
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_enabled="true" android:state_selected="true" android:drawable="@drawable/corner_list_first_pressed" />
    <item android:state_enabled="true" android:state_pressed="true" android:drawable="@drawable/corner_list_first_pressed" />
</selector>

<!-- corner_list_last_item.xml -->
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_enabled="true" android:state_selected="true" android:drawable="@drawable/corner_list_last_pressed" />
    <item android:state_enabled="true" android:state_pressed="true" android:drawable="@drawable/corner_list_last_pressed" />
</selector>

<!-- corner_list_item.xml -->
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_enabled="true" android:state_selected="true" android:drawable="@drawable/corner_list_pressed" />
    <item android:state_enabled="true" android:state_pressed="true" android:drawable="@drawable/corner_list_pressed" />
</selector>

<!-- corner_list_single_item.xml -->
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_enabled="true" android:state_selected="true" android:drawable="@drawable/corner_list_single_pressed" />
    <item android:state_enabled="true" android:state_pressed="true" android:drawable="@drawable/corner_list_single_pressed" />
</selector>

6. 应用
我直接把使用圆角的Activity代码贴出来：

public class SettingTabActivity extends Activity{

    private CornerListView cornerListView = null;

    private List<Map<String,String>> listData = null;
    private SimpleAdapter adapter = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main_tab_setting);

        cornerListView = (CornerListView)findViewById(R.id.setting_list);
        setListData();

        adapter = new SimpleAdapter(getApplicationContext(), listData, R.layout.main_tab_setting_list_item , 
new String[]{"text"}, new int[]{R.id.setting_list_item_text});
        cornerListView.setAdapter(adapter);
    }
    
    /**
     * 设置列表数据
     */
    private void setListData(){
        listData = new ArrayList<Map<String,String>>();

        Map<String,String> map = new HashMap<String, String>();
        map.put("text", "图库更新");
        listData.add(map);

        map = new HashMap<String, String>();
        map.put("text", "检查新版本");
        listData.add(map);

        map = new HashMap<String, String>();
        map.put("text", "反馈意见");
        listData.add(map);

        map = new HashMap<String, String>();
        map.put("text", "关于我们");
        listData.add(map);

        map = new HashMap<String, String>();
        map.put("text", "支持我们，请点击这里的广告");
        listData.add(map);
    }
}

ps：记得设置cacheColorHit属性为0或者"#00000000"！

7. 总结
在平时Android使用的过程中，发现很多设置界面的选项大量应用到了这种圆角效果，非常的漂亮，同时也发现很多应用，这个效果做的很不如意，包括一些大公司，要么没有选中效果，要么listview整个的背景是圆角，但是选中的第一项和最后一项的选中效果还是直角，要么干脆为圆角里设定一定像素的内边距等等，我对此总结，算是对这个问题有一个比较好的解决方案（我已经在网上搜过，未发现有人把这个效果分享过来），独乐乐不如众乐乐。

ps：附上3套皮肤素材：/Files/qianxudetianxia/cornerlist-skin.zip

本文链接

Android拓展系列(5)--CyanogenMod源码下载和编译(Android ROM定制基础篇)

2011-09-27T14:19:00Z

本来想下载Android官方源代码，没想到android.git.kernel.org维护，不能访问，非常遗憾，并因此还郁闷了几天。
后来转投MIUI,没找到它的源码，不知道它的"超过40万人社区开发团队"是什么意思，求解具体开发人员几何，都是谁？
后来一想，竟然忘记了CyanogenMod这茬，这可是的的确确的开源啊，我的手机一直也在用CyanogenMod系统的，感觉确实不错。

1.准备
我得环境如下，
VirtualBox 4.1.2.r73507
Ubuntu11.10 Beta2(32位)
下载CyanogenMod的gingerbread分支
Ubuntu的环境配置大家可以参考我前面写的《Android拓展系列(3)--Android源码下载》，也可以参考http://source.android.com/。
这里着重说下Android 2.3以上需要借助JAVA6，安装Java6，我推荐如下安装：

$ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
$ sudo add-apt-repository "deb-src http://archive.canonical.com/ubuntu lucid partner"
$ sudo apt-get update
$ sudo apt-get install sun-java6-jdk

其中第二句可能会出错，不过没关系，跳过即可。

2.安装repo
因为android.git官方已经不能访问，所以我这里提供一个repo文件的下载地址，免的大家到处搜索：http://115.com/file/cl15goo2#repo
把repo拷贝到ubuntu根目录下得bin下
操作方法：

$mkdir bin
//下载的repo脚本拷贝本地bin文件夹下
//设置本地repo的可执行权限
$chmod a+x ~/bin/repo
$alias repo="~/bin/repo"
//这里我用特意用别名，大家也可以按常规方法把repo的路径添加到PATH中

3.ubuntu中环境的配置
JDK前面已经说了，其他的软件列表如下：

$sudo apt-get install git-core gnupg flex bison gperf libsdl1.2-dev libesd0-dev libwxgtk2.6-dev squashfs-tools build-essential zip curl libncurses5-dev zlib1g-dev sun-java6-jdk pngcrush schedtool

这些软件都安装好之后我们开始下载CyanogenMod源码。

4.下载CyanogenMod源码

//从用户根目录下开始
//创建CyanogenMod文件夹来放置后面所有的代码
$mkdir CyanogenMod
//获取gingerbread的分支源代码
$repo init -u git://github.com/CyanogenMod/android.git -b gingerbread  
//同步服务器代码到本地，-j16据网友反应是多开网络连接，从而能提高下载速度
$repo sync -j16

这个过程非常的漫长，大家慢慢的等吧，本人是晚上睡觉的时候下载，第二天早上醒来就Done了。

5.编译源码
在CyanogenMod/device目录下有很多款手机的对应版本：

里面有个htc，本人是htc G9，也就是Liberty，我们点击看看：

我的liberty静静的优雅的舒服的躺在那里。
所以本人决定编译一个我手头上的liberty对应的系统版本，编译完成后我们直接刷机。
第一步：读取手机上的一些私有配置文件

$cd CyanogenMod/device/htc/liberty
$./extract-files.sh

图示如下：

第二步：生成编译脚本文件

$cd ~/CyanogenMod/vendor/cyanogen  
$./get-rommanager
$./extract-google-files
//复制编译脚本文件到CyanogenMod目录下，后面编译整个系统用的就是这个文件
$cp ~/CyanogenMod/vendor/cyanogen/products/cyanogen_lieberty.mk  ~/CyanogenMod/buildspec.mk

贴上进行时图片：

第三步：编译脚本
回到CyanogenMod目录下，执行脚本。

//初始化脚本，这个是后面的重要基础步骤
$source build/envsetup.sh
//选择编译的产品
//这个命令需要一小会儿时间，但是又没提示，耐性等待一下
$lunch cyanogen_liberty-eng
//开始编译
$make -j4 CYANOGEN_WITH_GOOGLE=true otapackage

这个过程也是相当的漫长，还好一般情况下我们只是第一次需要项目整个编译，后面只需要编译某个模块。
可惜完成的时候我忘记截图了，可惜不能上图了。
在编译的过程中，我们有一点要特别注意，虚拟机的内存不要太小，本人刚开始分配虚拟机512M内存，一会儿就出错，重新编译又一会儿出错，如此重复，而且还导致某个文件被破坏掉了（values-cs/strings.xml中某行少一个右尖括号，这个我百思不得其解），后来我把虚拟机内存调到1024M就一直编译通过了。

第四步：生产刷机zip包。

./vendor/cyanogen/tools/squisher

有图为赏：

用这个zip包，我刷到我手机上，一切正常。

6.定制ROM
有了以上的环境后，我们就可以大展手脚，深度定制ROM, 做自己的操作系统，自己的CyanogenMod，自己的MIUI，自己的Android系统。
举个最简单的例子：
我们换一下默认menu菜单的选中背景图，我们进入CyanogenMod/frameworks/base/core/res/res/mdpi目录下(因为htc liberty的分辨率是480x320)，找到图片highlight_pressed.png，替换为绿色的背景：

那么修改资源文件后，我们需要重新编译framework-res.apk:

//回到根目录
$cd
//切换到管理员权限
$sudo -s
//进入CyanogenMod目录，并初始化脚本文件
$cd CyanogenMod
$source build/envsetup.h
//选择产品
$lunch cyanogen_liberty-eng
//进入资源编译目录(或者它的子目录也可以)
$cd frameworks/base/core/res
//开始编译framework-res.apk
$mm

编译完成，示意图如下：

在CyanogenMod/out/target/product/liberty/system/framework目录下生成了一个framework-res.apk文件，就是我们修改Menu选中项图片后新打的资源包。
现在我们需要把这个资源包更新到手机中。
USB连上手机后，一切正常的话(adb当然也是事前要装好的哦)，打开终端：

//使其可写
$adb remount
//替换手机中资源包
$adb push ~/CyanogenMod/out/target/product/liberty/system/framework/framework-res.apk /system/framework/
//重启手机后生效
$adb reboot

重启后，进入桌面，我们点击Menu，选择一项：

修改资源包，可以修改样式，显示图片，调整布局等等。
你也可以直接修改framework代码，在framework/base/core/java目录下，修改对应的类，比如逻辑处理，样式重绘等等，然后同上面类似编译，把生成的framework.jar替换掉手机的/system/framework下的framework.jar，重启手机即可看到效果。
你也可以添加系统应用，删除系统应用等等，这里特别提到一点，系统应用可以通过如下命令删除(具有root权限)：

$adb remount
$adb shell
#cd system/app
//用rm删除系统FM应用
#rm FM.apk

有了这些基础知识，我相信我们后面的深度定制ROM一定非常精彩！

7.小结
本文以CyanogenMod源码编译总结了Android改造系统的一个基本环境，是我们之后ROM系统定制，优化的基础，是android深入学习的必会技能，特此分享，共勉！

本文链接

Android拓展系列(4)--vim编辑器的基本使用

2011-09-24T17:34:00Z

从接触Linux到现在，也已经好几年了，对于linux的感觉一直是分分离离，充满了遗憾，最大的遗憾之一就是一直没能精通vim，不能完全适应vim下的代码开发。
最近工作中又广泛接触到vim的使用，我觉得有必要总结一下。
但是我又无法针对vim的所有命令使用展开叙述，反而认为针对android，或者说java的一些常用编辑相关的操作命令做一个解说更具有效性。

1.vim的三种命令模式
(1).命令模式：用于输入命令，简单更改
(2).插入模式：用于插入文本，修改文本
(3).末行模式：用于输入命令，视化操作，查找替换等
这三种模式熟悉后，颠覆了windows里面编辑+工具栏（或者菜单栏）的方式，是我们进入命令介面的重要认知，经过使用之后，相信大家一定会喜欢这种操作模式的。
三种模式之间的切换方式如下：
(1).命令模式进入到插入模式：输入文本插入命令。
文本插入命令有:i,I,a,A,o,O
(2).插入模式退出到命令模式：ESC。
(3).命令模式进入到末行模式：冒号：。
如：:set nu 表示行号显示
:set nonu 取消行号显示
(4).末行模式推出到命令模式：Enter或者ESC。
由此我们也看出命令模式是这里还起了一个枢纽的作用，非常重要。

2.文本插入命令
上面说到文本插入命令了，正好我们就趁势说完。
文本插入命令主要是这几个i,I,a,A,o,O。

i(insert)         在光标前插入文本
I                 在光标所在行首插入文本
a(append)         在光标后插入文本
A                 在光标所在行尾添加文本
o(open)           在光标所在行下面添加一行
O                 在光标所在行上面添加一行

说句实话，这几个命令都还真是有用，必须掌握，我建议先记住小写的即可，大写先不管，到后面熟悉之后，大写的自然就记住了。

3.vim的退出和保存
退出vim也是基本操作基本涉及如下几个命令：

:q                     退出vim返回到shell，若有修改未被保存，vi在末行给出提示信息并不退出vim到shell
:q!                    退出vim返回到shell，放弃未保存的修改
:wq                    先保存，然后退出vim返回到shell
:x                     和wq命令功能类似，区别是如果是文件没有修改的话，x不会更新文件的修改时间，而wq则会更新文件的修改时间，无论是否有修改。
:w filename            写入当前文件到filename文件

wq和x应该用的很多吧。

4.命令模式的常用操作
在命令模式最常用操作大概包括，删除，复制，粘贴，撤销，移动等等，我列举几个最常用的如下：

dd       删除当前1行
5dd      删除当前行向下5行
x        删除光标后字符
X        删除光标前字符

yy       复制当前1行
5yy      复制当前行向下5行

p        粘贴

u        撤销

hjkl     向左下上右方向移动光标
^        光标移动到本行行首
$        光标移动到本行行尾
gg       跳到文件首行
5gg      跳到第5行
G        跳到文件尾行

Ctrl + f 向后滚一页。
Ctrl + d 向后滚半页。
Ctrl + b 向前滚一页。
Ctrl + u 向前滚半页。
Ctrl + e 屏幕向下滚一行。
Ctrl + y 屏幕项上滚一行。

上述命令是我们编辑文件经常使用的一些操作，必须掌握，非常有用。

5.查找替换

/android                 查找android，然后如果按n，表示向下查找，如果按N，表示向上查找
?android                 查找android，然后如果按n，表示向上查找，如果按N，表示向下查找

shift+8                  向后搜索当前光标指向的单词
shift+3                  向前搜索当前光标指向的单词      

:%s/old/new/g            将编辑器的缓冲区的"old"替换为new
:19,20s/old/new/g        将文件的19到20行的的"old"替换为new

用vim查找和替换还是挺方便的。

6.小结
差不多，上述是vim编辑器的基本用法，今天写在这里，做一总结，同时与大家共勉。

本文链接

Android学习系列(16)--App列表之圆角ListView

2011-09-19T13:23:00Z

有些东西看多了，就厌烦了：extjs对我这种感觉最为强烈。甚至，有时觉得设计之殇是审美疲劳。
直角看多了，就想看看圆角，不知何时，这几年刮起了一阵阵的圆角设计风：CSS新标准纳入圆角元素，iphone中几乎随处可见圆角设计，也开始出现很多圆角名片了...
今天我们就实现一个圆角的ListView效果。
圆角的设计，我们并不追求到处都用，无处不用，android中有少数界面用直角确实容易显得锋利，和周边界面太过对比而显得不协调，比如大栏目列表，设置等等，而采用圆角实现，则会活泼，轻松的多，也融合的特别好。

1.感觉
实际上在Android中因为SDK中没有默认对圆角的一个完整的支持，需要麻烦自定义设置才能实现完美的圆角效果，所以绝大多数应用都是采用分组直角列表这种样式。
所以我觉得很有必要让大家看看这些少数的不一样的东西，看看有什么不一样的感觉。
先让我们来看两张图片：

左边的是Android的一个应用的设置界面，右边是iphone系统的设置界面。
ps:上述只是效果，并不是说左边的圆角列表就是用listview是实现的，事实上它是用LinearLayout布局一个一个堆起来的。

2.原理
通过判断ListView上点击的项的位置，我们切换不同的选择器，当然这个切换的动作我们需要定义在重写ListView的onInterceptTouchEvent()方法中。

if(itemnum==0){
    if(itemnum==(getAdapter().getCount()-1)){
        //只有一项
        setSelector(R.drawable.app_list_corner_round);
    }else{
        //第一项                            
        setSelector(R.drawable.app_list_corner_round_top);
    }
}else if(itemnum==(getAdapter().getCount()-1))
    //最后一项
    setSelector(R.drawable.app_list_corner_round_bottom);
else{
    //中间一项                            
    setSelector(R.drawable.app_list_corner_shape);
}

3.定义选择器
如果只有一项，我们需要四个角都是圆角，app_list_corner_round.xml文件定义如下：

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <gradient android:startColor="#B5E7B8" 
        android:endColor="#76D37B" 
        android:angle="270"/>
    <corners android:topLeftRadius="4dip"
        android:topRightRadius="4dip"
        android:bottomLeftRadius="4dip"
        android:bottomRightRadius="4dip"/>
</shape>

如果是顶部第一项，则上面两个角为圆角，app_list_corner_round_top.xml定义如下：

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <gradient android:startColor="#B5E7B8" 
        android:endColor="#76D37B" 
        android:angle="270"/>
    <corners android:topLeftRadius="4dip"
        android:topRightRadius="4dip"/>
</shape>

如果是底部最后一项，则下面两个角为圆角，app_list_corner_round_bottom.xml定义如下：

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <gradient android:startColor="#B5E7B8" 
        android:endColor="#76D37B" 
        android:angle="270"/>
    <corners android:bottomLeftRadius="4dip"
        android:bottomRightRadius="4dip" />
</shape>

如果是中间项，则应该不需要圆角， app_list_corner_shape.xml定义如下：

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <gradient android:startColor="#B5E7B8" 
        android:endColor="#76D37B" 
        android:angle="270"/>
</shape>

4.背景图片
因为默认的情况下，ListView就要显示一个圆角的边框，这个我们使用一张9patch背景图片来实现app_list_corner_border.9.png：

在这里提示一下，做9patch背景图片的时候，记得把内容区域定义为边框线以内的区域。

5. 初步实现
参考前面提供的素材和核心代码，我们初步实现如下:
(1).自定义CornerListView.java:

/**
 * 圆角ListView
 */
public class CornerListView extends ListView {

    public CornerListView(Context context) {
        super(context);
    }

    public CornerListView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public CornerListView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
        case MotionEvent.ACTION_DOWN:
                int x = (int) ev.getX();
                int y = (int) ev.getY();
                int itemnum = pointToPosition(x, y);

                if (itemnum == AdapterView.INVALID_POSITION)
                        break;                 
                else
                {  
                        if(itemnum==0){
                                if(itemnum==(getAdapter().getCount()-1)){                                    
                                    setSelector(R.drawable.app_list_corner_round);
                                }else{
                                    setSelector(R.drawable.app_list_corner_round_top);
                                }
                        }else if(itemnum==(getAdapter().getCount()-1))
                                setSelector(R.drawable.app_list_corner_round_bottom);
                        else{                            
                            setSelector(R.drawable.app_list_corner_shape);
                        }
                }

                break;
        case MotionEvent.ACTION_UP:
                break;
        }
        return super.onInterceptTouchEvent(ev);
    }
}

这个CornerListView主要处理了点击项的选择器的切换。
(2).列表布局文件和列表项布局文件：
列表布局文件main_tab_setting.xml：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <com.tianxia.app.floworld.view.CornerListView android:id="@+id/setting_list"
        android:layout_width="fill_parent" 
        android:layout_height="wrap_content"
        android:layout_margin="10dip"
        android:background="@drawable/app_list_corner_border"
        android:cacheColorHint="#00000000">
    </com.tianxia.app.floworld.view.CornerListView>
</LinearLayout>

列表项布局文件main_tab_setting_list_item.xml：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <ImageView android:id="@+id/setting_list_item_arrow"
        android:layout_alignParentRight="true"
        android:layout_centerVertical="true"
        android:layout_width="wrap_content"
        android:layout_height="fill_parent"
        android:layout_marginLeft="15dip"
        android:layout_marginRight="15dip"
        android:src="@drawable/appreciate_tab_list_item_arrow_small"/>
    <TextView  android:id="@+id/setting_list_item_text"
        android:layout_toLeftOf="@id/setting_list_item_arrow"
        android:layout_width="fill_parent" 
        android:layout_height="wrap_content"
        android:textSize="16dip"
        android:textColor="#000000"
        android:paddingTop="10dip"
        android:paddingBottom="10dip"
        android:paddingLeft="10dip" />
</RelativeLayout>

(3)界面实现
显示界面SettingTabActivity.java:

public class SettingTabActivity extends Activity{
    
    private CornerListView cornerListView = null;
    
    private List<Map<String,String>> listData = null;
    private SimpleAdapter adapter = null;
    
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main_tab_setting);
        
        cornerListView = (CornerListView)findViewById(R.id.setting_list);
        setListData();
        
        adapter = new SimpleAdapter(getApplicationContext(), listData, R.layout.main_tab_setting_list_item , new String[]{"text"}, new int[]{R.id.setting_list_item_text});
        cornerListView.setAdapter(adapter);
    }
    
    /**
     * 设置列表数据
     */
    private void setListData(){
        listData = new ArrayList<Map<String,String>>();
        
        Map<String,String> map = new HashMap<String, String>();
        map.put("text", "图库更新");
        listData.add(map);
        
        map = new HashMap<String, String>();
        map.put("text", "收藏图片");
        listData.add(map);
        
        map = new HashMap<String, String>();
        map.put("text", "下载目录");
        listData.add(map);
    }
}

(4).效果图
通过以上实现，我们基本达到了圆角的ListView的效果：

本文链接

Android学习系列(23)--App主界面实现

2011-09-03T08:45:00Z

在上篇文章《Android学习系列(22)--App主界面比较》中我们浅略的分析了几个主界面布局，选了一个最大众化的经典布局。
今天我们就这个经典布局，用代码具体的实现它。

1.预览图
先看下最终的界面设计图：

上面顶部是一个9patch背景图片+标题文字；
下面底部是5个tab标签，表示应用的5大模块。
中间内容部分则是各个模块的具体内容，可以再分类，或者直接显示内容。

2.准备素材
按照上篇文章的界面，我们需要事先提供两大方面的素材：顶部+底部。
顶部的素材非常简单，最重要的是背景（9patch的图片）：

底部的素材稍微多一点：
(1).每个tab的背景都需要正常和选中两种，一共10张图片;
(2).每个tab之间有一张分割线，1张图片;
(3).为了自适应屏幕宽度，并保持图形不变形，必须tab背景和下面botton这个背景色一致，所以需要1张同背景的背景图片。
如下：
(1).

(2).

(3).

在这里呢，我再三考量，决定还是把图片和文字放在一起，这样一能大大降低代码的复杂性，而且能保证漂亮的样式，我们通过Photoshop来控制，灵活性大大增强。
以上是我在网上随便找了几张照片，稍微处理了一下，作为下面我们实现的素材。

3.实现原理
这里，我采用了getDecorView方法，发现这种方法布局和代码比较简洁，看上去性能也不错(待查)。
用核心代码来说明一下原理：

//mainTabContainer是一个空布局，做为每个tab的容器
        //activity是每个tab对应的activity
        //getDecorView是对应的activity的视图，添加到tab容器中，就能实现切换activity的效果了
        mainTabContainer.removeAllViews();
        mainTabIntent = new Intent(this,activity);
        mainTabContainer.addView(localActivityManager.startActivity(id, mainTabIntent).getDecorView());

通过切换不同的activity的decorView,实现tab的视图切换。

4.基本框架
布局界面思路非常清晰，顶部+底部+中间tab内容
我采用相对布局(相对于线性布局，我经常选择帧布局和相对布局，我更喜欢这两个小巧的布局)：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <LinearLayout android:id="@+id/main_tab_banner"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:paddingLeft="10dip"
        android:orientation="horizontal"
        android:gravity="center"
        android:background="@drawable/main_banner_bg"
        android:layout_alignParentTop="true">
        <!-- 标题 -->
    </LinearLayout>
    <LinearLayout android:id="@+id/main_tab"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        android:gravity="center"
        android:background="@drawable/tab_bg"
        android:layout_alignParentBottom="true">
        <!-- 内容 -->
    </LinearLayout>
    <LinearLayout android:id="@+id/main_tab_container"
        android:layout_above="@id/main_tab"
        android:layout_below="@id/main_tab_banner"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:background="#FFFFE0">
    </LinearLayout>
</RelativeLayout>

看起来很复杂的东西，分解一下就简单的多了。
在标题处，加上一个TextView，做为标题显示。
在内容处，我们需要填充5个Tab背景和1个分割线，请参考《Android学习系列(5)--App布局初探之简单模型》中的模型四,使用了layout_weight的属性，平均分割了5个tab.
最终我们的布局文件如下：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <LinearLayout android:id="@+id/main_tab_banner"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:paddingLeft="10dip"
        android:orientation="horizontal"
        android:gravity="center"
        android:background="@drawable/main_banner_bg"
        android:layout_alignParentTop="true">
        <TextView android:id="@+id/main_tab_banner_title"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="欣赏美花"
            android:textSize="20dip"
            android:textColor="#000000"/>
    </LinearLayout>
    <LinearLayout android:id="@+id/main_tab"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        android:gravity="center"
        android:background="@drawable/tab_bg"
        android:layout_alignParentBottom="true">
        <ImageView android:id="@+id/appreciate_tab_btn"
            android:layout_weight="1"
            android:layout_width="wrap_content"
            android:layout_height="fill_parent"
            android:gravity="center_horizontal|bottom"
            android:src="@drawable/appreciate_press"/>
        <ImageView android:gravity="center"
            android:layout_gravity="center_vertical"
            android:layout_width="5dip"
            android:layout_height="wrap_content"
            android:src="@drawable/tab_split"/>
        <ImageView android:id="@+id/discuss_tab_btn"
            android:layout_weight="1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:gravity="center_horizontal|bottom"
            android:textSize="16dip"
            android:src="@drawable/discuss_normal"
            android:textColor="#000000"/>
        <ImageView android:gravity="center"
            android:layout_gravity="center_vertical"
            android:layout_width="5dip"
            android:layout_height="wrap_content"
            android:src="@drawable/tab_split"/>
        <ImageView android:id="@+id/identification_tab_btn"
            android:layout_weight="1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:gravity="center_horizontal|bottom"
            android:textSize="16dip"
            android:src="@drawable/identification_normal"
            android:textColor="#000000"/>
        <ImageView android:gravity="center"
            android:layout_gravity="center_vertical"
            android:layout_width="5dip"
            android:layout_height="wrap_content"
            android:src="@drawable/tab_split"/>
        <ImageView android:id="@+id/favorite_tab_btn"
            android:layout_weight="1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:gravity="center_horizontal|bottom"
            android:textSize="16dip"
            android:textColor="#000000"
            android:src="@drawable/favorite_normal"/>
        <ImageView android:gravity="center"
            android:layout_gravity="center_vertical"
            android:layout_width="5dip"
            android:layout_height="wrap_content"
            android:src="@drawable/tab_split"/>
        <ImageView android:id="@+id/setting_tab_btn"
            android:layout_weight="1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:gravity="center_horizontal|bottom"
            android:textSize="16dip"
            android:src="@drawable/setting_normal"
            android:textColor="#000000"/>
    </LinearLayout>
    <LinearLayout android:id="@+id/main_tab_container"
        android:layout_above="@id/main_tab"
        android:layout_below="@id/main_tab_banner"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:background="#FFFFE0">
    </LinearLayout>
</RelativeLayout>

其中的main_tab_container是容器布局，到时候动态存放切换的activity的视图。
这时候，效果图如下：

中间的内容为空，tab点击也没有任何效果，我们继续实现。
这就是布局文件main_tab_frame.xml.

5.事件效果
现在我们把点击效果，切换标题，这些效果关联起来。
选择不同的tab，显示不同的标题，同时切换不同的activity.
以点击评花的主要代码为例子：

//评花
        discussImageView.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                //标题
                mainTabTitleTextView.setText("评花论花");
                //切换内容
                setContainerView("discuss", DiscussTabActivity.class);
                //切换tab页背景                   
                appreciateImageView.setImageResource(R.drawable.appreciate_normal);
                discussImageView.setImageResource(R.drawable.discuss_press);
                identificationImageView.setImageResource(R.drawable.identification_normal);
                favoriteImageView.setImageResource(R.drawable.favorite_normal);
                settingImageView.setImageResource(R.drawable.setting_normal);
            }
        });
        //切换activity
        public void setContainerView(String id,Class<?> activity){
            mainTabContainer.removeAllViews();
            mainTabIntent = new Intent(this,activity);
            mainTabContainer.addView(localActivityManager.startActivity(id, mainTabIntent).getDecorView());
        }

我们继承ActivityGroup这个类，实现这个完整的类MainTabFrame.java:

public class MainTabFrame extends ActivityGroup {
    
    //Tab Activity Layout
    private LocalActivityManager localActivityManager = null;
    private LinearLayout mainTabContainer = null;
    private Intent mainTabIntent = null;

    //Tab banner title
    private TextView mainTabTitleTextView = null; 
    //Tab ImageView
    private ImageView appreciateImageView = null;
    private ImageView discussImageView = null;
    private ImageView identificationImageView = null;
    private ImageView favoriteImageView = null;
    private ImageView settingImageView = null;
    
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main_tab_frame);
        
        mainTabContainer = (LinearLayout)findViewById(R.id.main_tab_container);
        localActivityManager = getLocalActivityManager();
        setContainerView("appreciate", AppreciateTabActivity.class);
        
        initTab();
        
    }

    
    /**
     * 初始化Tab项
     */
    private void initTab() {
        mainTabTitleTextView = (TextView)findViewById(R.id.main_tab_banner_title);
        appreciateImageView = (ImageView)findViewById(R.id.appreciate_tab_btn);
        discussImageView = (ImageView)findViewById(R.id.discuss_tab_btn);
        identificationImageView = (ImageView)findViewById(R.id.identification_tab_btn);
        favoriteImageView = (ImageView)findViewById(R.id.favorite_tab_btn);
        settingImageView = (ImageView)findViewById(R.id.setting_tab_btn);
        
        //赏花
        appreciateImageView.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                mainTabTitleTextView.setText("欣赏美花");
                setContainerView("appreciate", AppreciateTabActivity.class);
                appreciateImageView.setImageResource(R.drawable.appreciate_press);
                discussImageView.setImageResource(R.drawable.discuss_normal);
                identificationImageView.setImageResource(R.drawable.identification_normal);
                favoriteImageView.setImageResource(R.drawable.favorite_normal);
                settingImageView.setImageResource(R.drawable.setting_normal);
            }
        });
        
        //评花
        discussImageView.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                mainTabTitleTextView.setText("评花论花");
                setContainerView("discuss", DiscussTabActivity.class);
                appreciateImageView.setImageResource(R.drawable.appreciate_normal);
                discussImageView.setImageResource(R.drawable.discuss_press);
                identificationImageView.setImageResource(R.drawable.identification_normal);
                favoriteImageView.setImageResource(R.drawable.favorite_normal);
                settingImageView.setImageResource(R.drawable.setting_normal);
            }
        });
        
        //识花
        identificationImageView.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                mainTabTitleTextView.setText("亮眼识花");
                setContainerView("identification", IdentificationTabActivity.class);
                appreciateImageView.setImageResource(R.drawable.appreciate_normal);
                discussImageView.setImageResource(R.drawable.discuss_normal);
                identificationImageView.setImageResource(R.drawable.identification_press);
                favoriteImageView.setImageResource(R.drawable.favorite_normal);
                settingImageView.setImageResource(R.drawable.setting_normal);
            }
        });
        
        //收藏
        favoriteImageView.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                mainTabTitleTextView.setText("我的收藏");
                setContainerView("favorite", FavoriteTabActivity.class);
                appreciateImageView.setImageResource(R.drawable.appreciate_normal);
                discussImageView.setImageResource(R.drawable.discuss_normal);
                identificationImageView.setImageResource(R.drawable.identification_normal);
                favoriteImageView.setImageResource(R.drawable.favorite_press);
                settingImageView.setImageResource(R.drawable.setting_normal);
            }
        });
        
        //设置
        settingImageView.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                mainTabTitleTextView.setText("定义设置");
                setContainerView("setting", SettingTabActivity.class);
                appreciateImageView.setImageResource(R.drawable.appreciate_normal);
                discussImageView.setImageResource(R.drawable.discuss_normal);
                identificationImageView.setImageResource(R.drawable.identification_normal);
                favoriteImageView.setImageResource(R.drawable.favorite_normal);
                settingImageView.setImageResource(R.drawable.setting_press);
            }
        });
    }
    
    public void setContainerView(String id,Class<?> activity){
        mainTabContainer.removeAllViews();
        mainTabIntent = new Intent(this,activity);
        mainTabContainer.addView(localActivityManager.startActivity(id, mainTabIntent).getDecorView());
    }
}

具体的每个activity怎么显示的，再通过AppreciateTabActivity，DiscussTabActivity，IdentificationTabActivity，FavoriteTabActivity，SettingTabActivity这些独自实现，不再累述。

6.扩展建议
这里补充两点：
(1).标题栏在上述示例中，我是放在MainTabFrame，这样做的好处是，统一了，方便了；这样做的缺点是，如果每个activity的标题栏是不同的按钮，不同的操作，会有些膨胀。所以，标题栏放在主Acvtivity和子Activity中，考虑一下即可。
(2).tab的切换效果，我做的非常简单，具体的图片阴影，凹凸，文字色彩区分都没有去做（本人对Photoshop实在不熟），美化方面还可以大大改进。

7.小结
通过实现这么个简单的主界面框架，能使我们快速的开始我们相应的感兴趣项目，提供了一种大众化得参考，是android学习者必备基础。
这种东西的积累和分析也是能提高我们感觉应用的审美感。

本文链接

Android学习系列(22)--App主界面比较

2011-08-28T02:33:00Z

本文算是一篇漫谈，谈一谈当前几个流行应用的主界面布局，找个经典的布局我们自己也来实现一个。
不是为了追求到底有多难，而是为了明白我们确实需要这么做。
走个题，android的UI差异化市场依然很大，依然值得去挖掘。
铸就经典，是为了超越经典！
下面我们以下面10个应用来分析比较它们的主界面：
1.QQ2011
2.新浪微博
3.凤凰周刊
4.小米读书
5.微信
6.太平洋电脑网
7.360卫士
8.Camera360
9.大众点评网
10.挖财

1.QQ2011
QQ应用最新版本QQ2011 Beta3，从最新的版本看，界面比之前简洁了一些。
我以夜间模式为例子：

从图中可以看出来，QQ分为3大模块：空间动态，QQ聊天，其他QQ应用。这些最大的模块现实在底部
因为QQ聊天业务本身也有很多重要东西，如好友，qq群，历史记录等等，所以qq聊天在上部分又分成3部分了。这也算是较大的模块。
基本上这么一分，qq上该用的东西我们都能直觉上都看的见，寥寥数笔，就已经勾画出最基本最重要的轮廓。
除此之外，qq有大量的设置和子功能，如状态设置，搜索好友，添加好友，皮肤设置等等， qq做法很简单，就是分类分级，然后通过menu菜单显示。
因为这部分功能不是聊天的最主要的需求，这样分类分级非常的合理，不影响用户界面，又能无声无影的添加到应用中。

总而言之，qq能把这么多斑驳的功能融合一体，简约而不失强大，合理而不失风采。

2.新浪微博
新浪微博很早的版本给我得印象好像是挺垃圾的，不知道什么时候升级的，现在的界面看行。

这个界面就不比qq了：
底部bottom则是业务划分。
顶部banner为当前页面的一个标题（主要标志），能携带若干功能的快捷方式；
qq之前的版本好像也是这种划分，这种布局的特点就是简简单单，大众化，用户一打开就知道怎么找相应的功能。
缺点就是大众化，没什么特色，不够炫。

3.凤凰周刊
凤凰周刊的主界面不是一般的简陋：

模块的划分在顶部，这种布局个人觉得不如在底部进行模块的划分。
主要是这个应用是提供杂志下载的，并没有提供其他的功能和设置，不然在顶部简单的划分，打开界面第一眼就看到一排模块挤挤的，确实不大美观。
而且最重要的是，它和新浪微博的布局比较，无形中少了顶部banner，导致无法直接添加若干主要的功能快捷方式。
所以说，这个布局的特点就是简单，简单还是简单，对应用的要求也是要简单。
顺便扯一个，其实凤凰移动台的应用主界面还是挺大气的：

4.小米读书、微信、太平洋电脑网、挖财
这几个应用的主界面和新浪微博接近，一个top banner+ bottom menu,在bottom中划分模块，在top中做功能切入点，如果子模块还需要划分，则top banner下面增加一个类似bottom的业务模块划分。

这种布局的特点就是模块划分分明，每个模块在第一界面能携带一两个功能或者功能快捷方式。

5.360卫士、大众点评网、Camera360
下面这几个应用的界面又是一类，它们或许也有bottom的模块划分，但是它们更喜欢把功能通过更直接的方式显示在界面的正中央，这样做的目的是凸显这些功能在此应用的重要性，而的确如此，没有这些功能，或者看不到这些功能，我们甚至就不知道这个应用意欲何为，如何使用等等。

这类应用与前面的应用最大的不同，应该从应用本身的服务目的来分析，这类应用强调的是用户的主动交互性，而前面应用强调的是提供用户最新的资讯。
目的不同，界面的设计相应的不同，各尽其用，都非常的合理。
当然，这类应用主界面布局和前面布局的不同，从效果上强调二级功能点，而且掩盖了直接内容，从这点上资讯类应用一般不采用这种布局，但是反过来这类应用布局却可以采用资讯类布局，比如360卫士就介如两者之间。

6.小结
从上面我们看到这些流行应用的主要布局方式，各有特点。
本文只是从整体布局分析，并没有考虑局部布局和色彩调配的因素。
接下来我们选择第四种模式作为我们的经典模式，草图如下：

下篇文章中我们来实现这样的一个经典界面。

本文链接

Android设计模式系列(8)--SDK源码之工厂方法模式

2011-08-20T03:07:00Z

工厂方法模式，往往是设计模式初学者入门的模式，的确，有人称之为最为典型最具启发效果的模式。
android中用到了太多的工厂类，其中有用工厂方法模式的，当然也有很多工厂并不是使用工厂方法模式的，只是工具管理类。
今天以ThreadFactory举例说明一下简单工厂模式和工厂方法模式。
工厂方法模式，Factory Method,简单的方式，不简单的应用。

1.意图
定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方式模式使一个类的实例化延迟到其子类。
热门词汇:虚构造器延迟创建对象子类

2.结构图和代码
我们先看看标准的工厂方法结构图：

先抽象的产品类，抽象的工厂类，然后用客户端具体的工厂生产相应的具体的产品，但是客户端并不知道具体的产品是怎么生产的，生产的过程封装在工厂里。所以说，某种程度上，工厂方法模式改变了我们直接用new创建对象的方式，一个很好的开始，意义重大。
以ThreadFactory为例：

这张图其实和原本的结构图有细微的区别，那就是参数化得工厂，而且从业务意义上也有些不同，但是思想是一样的。
我们来看下具体的代码：

//抽象产品
public interface Runnable {
    public abstract void run();
}

//抽象工厂
public interface ThreadFactory {
    Thread newThread(Runnable r);
}

下面是具体的实现：
比如AsyncTask类中工厂的具体实现如下：

//工厂实现类
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };
    //那么产品类在哪里呢？
    //做为参数Runnable r，我们可以创建千千万万个此系列的产品类
    //同理，我们可以创建另外类似的工厂，生产某种专门的线程，非常容易扩展

看到这里，我们一方面为它的生产便利性感叹，一方面又为没创建某类产品都要创建一个工厂而感到繁琐，所以我们下面介绍简单工厂，它的结构图如下：

简单工厂把抽象工厂去掉了，你就创建一个专门生产某类产品就好。在一些特定而又不负责的领域非常实用方便套用这个模式。
在android中的Connection类中使用到了这个类：

其中Connection这个抽象类，既充当抽象产品类，也充当具体工厂类。
因为这种情况下，我们往往需要的是马上生产子类，getConnection方法往往是静态的，所以简单工厂，也叫静态工厂方法。
我们看看代码如下：

abstract class Connection{    
    static Connection getConnection(
            Context context, HttpHost host, HttpHost proxy,
            RequestFeeder requestFeeder) {

        if (host.getSchemeName().equals("http")) {
            return new HttpConnection(context, host, requestFeeder);
        }

        // Otherwise, default to https
        return new HttpsConnection(context, host, proxy, requestFeeder);
    }
}

这就是简单工厂，一个很简单的参数化工厂，真的很简单。

3.效果
1. 创建型模式;
2.参数化工厂方法模式得到相应的对象;
3.为子类提供挂钩;
4.连接平行的类层次。

本文链接

Android设计模式系列(7)--SDK源码之命令模式

2011-08-12T16:36:00Z

命令模式，在.net，java平台的事件机制用的非常多，几乎每天都与之打交道。
android中对我印象最深的就是多线程多进程的环境，所以必然大量使用到Runbable,Thread,其实用的就是最简单的命令模式。
命令模式，Command Pattern，把请求封装为一个对象，多么巧妙的一个说法啊。

1.意图
将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。
热门词汇：动作事物请求封装排队打包异步

2.结构

Command接口提供了Execute方法，客户端通过Invoker调用命令操作来调用Recriver，绕了一大圈，但是却把具体对Receiver的操作请求封装在具体的命令中，是客户端对recriver的操作清晰简明。
但是在实际项目中，我们常常忽略Receiver，而把命令对象的目标对象直接设置为子类自己的成员变量或者作为execute()方法的临时变量。
以Android中的Runnable(在java.lang包下)为例，我们画出UML结构图如下：

想不到我们天天写的代码无意识中就是用到了命令模式，所谓模式，就是无所不在。

3.代码
命令接口Runnable定义如下：

public interface Runnable {
    public abstract void run();
}

调用者Thread简化版代码：

//命令模式这里不需要继承Runnable接口，但是这里考虑到实际情况，比如方便性等，继承了Runnable接口，实现了run方法，这个是Thread自身的运行run的方法
class Thread implements Runnable {
    private Runnable target;
    
    public Thread(Runnable target) {
        this.target = target;
    }

     public synchronized void start() {

        if (threadStatus != 0 || this != me)
            throw new IllegalThreadStateException();
        group.add(this);
        start0();//这个是本地方法，调用run方法
        if (stopBeforeStart) {
	    stop0(throwableFromStop);
	}
    }

    //可选
    public void run() {
	if (target != null) {
	    target.run();
	}
    }
}

客户端只需要new Thread(new Runnable(){}).start()就开始执行相关的一系列的请求，这些请求大部分都是实现Runnable接口的匿名类。

4.效果
(1).行为型模式;
(2).将调用对象的操作和知道如何实现该操作的对象解耦;
(3).多个命令可以装配成一个复合命令;
(4).增加新的命令很容易。

本文链接

Android设计模式系列(6)--SDK源码之享元模式

2011-08-10T14:00:00Z

享元模式,给我的感觉就是对象池，缓存单例对象。
java中的享元模式最经典的例子就是String类了，还有一个最容易理解的就是word文档字符共享的例子，也是享元模式的经典应用。
本文对android中的sql编译类SQLiteCompiledSql说明，展开分析，也是很容易理解的一个例子，其实，android SDK中必然有很多地方需要用到享元模式。
享元模式，Flyweight Pattern,说的严重点，一些程序如果不使用享元模式的话，根本不能使用面向对象的方法实现，对象会多的撑爆你的内存："用面向对象思想设计的应用常常会面临对象实例过多的问题"。

1.意图
运用共享技术有效地支持大量细粒度的对象。
热门词汇：共享池缓存内部状态外部状态对象单例

2.结构

这是一个完整的享元模式结构图。
客户端通过享元工厂获取享元对象，享元对象的创建则根据工厂的享元池来控制，如果有享元池中没有这个对象，则创建这个对象并保存到享元池中，如果享元池中有这个对象，则直接使用这个对象。因为享元对象在共享的同时，说明它重用属性的不变性，不然都是变化的东西，不存在共享，这些不变得属性我们称之为内部状态，独立与外部场景。而另外一些属性，可以根据外部场景变化的，我们称之为外部状态，在上图中我们也看到，我们可以通过Operation改变外部状态。
Android中SQLiteCompiledSql的使用，其实是很多数据库系统典型的实现。从应用启动，通过各种数据库操作，我们不知道进行了多少次的查询操作，而这些操作中又有相当一部分sql语句是相同的，这些编译后的sql编译对象其实是一样的，是可以共用共享的，其实就是缓存。SQLiteCompiledSql就是这样的一个需要共享的享元对象，画出相关的UML图如下：

其中SqliteDatabase中的mCompiledQuerie就是存放享元对象的容器。
通过这种方式大大减少了sql编译对象的创建，提高了数据库操作的性能。

3.代码
享元对象类SQLiteCompiledSql，主要是内部状态sql语句：

class SQLiteCompiledSql {
    private String mSqlStmt = null;
    native_compile(sql); 
    native_finalize();
}

享元工厂类：

public class SQLiteDatabase{
     Map<String, SQLiteCompiledSql> mCompiledQueries = Maps.newHashMap();
     SQLiteCompiledSql getCompiledStatementForSql(String sql) {
        SQLiteCompiledSql compiledStatement = null;
        boolean cacheHit;
        synchronized(mCompiledQueries) {
            if (mMaxSqlCacheSize == 0) {
                return null;
            }
            cacheHit = (compiledStatement = mCompiledQueries.get(sql)) != null;
        }
        if (cacheHit) {
            mNumCacheHits++;
        } else {
            mNumCacheMisses++;
        }
        return compiledStatement;
    }

    private void deallocCachedSqlStatements() {
        synchronized (mCompiledQueries) {
            for (SQLiteCompiledSql compiledSql : mCompiledQueries.values()) {
                compiledSql.releaseSqlStatement();
            }
            mCompiledQueries.clear();
        }
    }

    void addToCompiledQueries(String sql, SQLiteCompiledSql compiledStatement) {
         //省略具体代码
    }
}

其他类几个相关类是对这个集合的操作相关，和享元模式没有什么实质性的关系，代码省略。

4.效果
(1).结构型模式;
(2).节约存储的方法：用共享减少内部状态的消耗，用计算时间换取对外部状态的存储;
(3).缓冲。

本文链接