润物无声

HTTPS 上线记：免费证书、自动续签与三处联动

Fri, 13 Nov 2026 15:36:00 +0800

用 acme.sh 从 Let’s Encrypt 签下免费证书，写成一条命令；强制跳转最难的不是跳转本身，而是三条必须放行的例外，以及它和证书续签之间的联动。附带 Isso 评论与公众号回调改走 https 时踩到的坑。

换服务器手册：一个包搬走整站

Thu, 12 Nov 2026 22:30:00 +0800

整站打成一个 112 MB 的包，新机器一条命令恢复。包里带源码、WordPress 原件、1335 张历史图片、评论库、nginx 配置与证书、公众号后端、退役旧站备份和编译好的 hugo——本地电脑什么也不用留。

写一篇博文：本站的写作与发布流程

Thu, 12 Nov 2026 22:25:00 +0800

全部在服务器终端完成：建骨架、写正文、构建、发布各一条命令，评论去后台点放行。源码本地不留副本，本地流程降级为备用，附三条红线和常见故障对照表。

165 篇文章搬家记：从 WordPress 到 Hugo 静态站

Thu, 12 Nov 2026 22:20:00 +0800

WordPress 4.1.41 跑了十多年，终于搬家：165 篇文章转成 Markdown，Hugo 生成静态页，评论改用 Isso 自托管。这篇记录全过程，以及五个只有真跑一遍才会暴露的坑。

手机安装账户同步服务

Mon, 21 Jul 2014 09:14:14 +0000

【前提】

手机需要root过，不然没有权限拷贝apk到 /system/app 目录下面。

【步骤】

通过手机的【设置】–【关于手机】查看当前系统的Android版本，例如我的手机是4.2.2。

在 http://wiki.rootzwiki.com/Google_Apps 中下载对应的服务包。

里面包含了很多的服务(system\app)app，我们只需要安装服务框架，登录服务，日历同步，通讯录同步，邮件同步即可。

拷贝到 \system\app 系统目录中。

【账户同步】

Ubuntu 制作一键安装盘（四）

Fri, 23 May 2014 10:13:15 +0000

本文测试原生的Kubuntu系统，基于原生Ubuntu系统，安装KDE环境后制作安装盘请参照文章《Ubuntu 制作一键安装盘（三）》。

版本：Kubuntu 12.04 下载地址：http://www.kubuntu.org/getkubuntu/download-lts

【更新源(主要是下载速度的因素)】

deb http://mirrors.163.com/ubuntu/ precise main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ precise-security main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ precise-updates main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ precise-proposed main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ precise-backports main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ precise main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ precise-security main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ precise-updates main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ precise-proposed main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ precise-backports main restricted universe multiverse

# Remastersys Precise
deb http://www.remastersys.com/ubuntu precise main

【添加公钥】

Ubuntu 制作一键安装盘（三）

Fri, 23 May 2014 10:07:06 +0000

Ubuntu gnome主题的安装光盘制作请参照文章《Ubuntu 制作一键安装盘（二）》，本文进行KDE桌面环境的安装测试。

注意：经过测试 remastersys 不能很好的支持GNOME发行版安装的KDE的桌面环境。

【安装KDE桌面环境】

sudo apt-get install kubuntu-desktop kde-standard
简体中文支持：sudo apt-get install language-pack-kde-zh-hans language-pack-kde-zh-hant

【步骤】

制作发布安装盘 sudo remastersys dist
live 模式测试, 版本 Ubuntu 12.04 KDE 32位

结果：进入KDE登录界面，因为custom账户没有密码，无法登录进去系统。

live 模式测试, 版本 Ubuntu 12.04 KDE 64位

结果：可以进入GNOME主题系统，但是因为缺少/var/spool/isc* 工作目录，后台测试程序不完整。

考虑解决方案(isc* 为测试程序，工作目录在/var/spool/isc*)：

修改 /usr/bin/remastersys 脚本文件，加入自己的处理，例如拷贝必要的文件

log_msg “Copying iscxxx files"service iscxxx stop &> /dev/null cp -rf /var/spool/isc* $WORKDIR/dummysys/var/spool/ &> /dev/null

sudo remastersys dist

结果2：可以进入GNOME主题系统，前后台程序运行正常。

install 模式测试，无法进行系统的安装，没有安装过程，直接进入live模式

Ubuntu 制作一键安装盘（二）

Thu, 22 May 2014 10:11:55 +0000

本文采用 Remastersys 制作安装盘，使用relinux制作安装盘，请参照上一篇文章《Ubuntu 制作一键安装盘（一）》。

【步骤】

修改源 /etc/apt/sources.list，加入：

# Remastersys Precise
deb http://www.remastersys.com/ubuntu precise main

安装 RemasterSys：
```
sudo apt-get update; sudo apt-get install remastersys
```
如果出现 GPG 错误，请参照文章最后的「错误解决」。

错误解决的另一种方法，Add repository key：

wget -O - http://www.remastersys.com/ubuntu/remastersys.gpg.key | sudo apt-key add -

进行备份：
```
sudo remastersys dist cdfs
```

sudo remastersys dist iso custom.iso

```

生成 iso 文件，大约 1.2GB。

拷贝出来：

sudo cp /home/remastersys/remastersys/custom.iso /media/sf_vmshare/

新建虚拟机进行测试，运行 live 模式，guest 账户登录，测试程序可以正常运行，测试通过。

系统安装测试，测试通过。

Ubuntu 制作一键安装盘（一）

Thu, 22 May 2014 09:50:19 +0000

基于 Ubuntu系统开发了一套系统，为了方便装机的便利性，制作一键安装盘。

注意：利用如下方法可以正常做出安装盘，但是安装过程中会出现错误，另外运行live cd的时候也会出现如下low graphic的问题，暂时无解，第一次尝试失败。

【步骤】

下载软件 relinux，https://launchpad.net/relinux，例如 relinux_0.4a1-5_i386.deb
安装 sudo dpkg -i relinux_0.4a1-5_i386.deb
依赖错误修复 sudo apt-get install -f
语言环境（简体中文）设定 echo $LANG; export LANG=‘zh_CN.UTF-8’; echo $LANG

制作镜像 sudo relinux, 暂时保留默认设定
查看 iso 文件，大小 2.0GB

zhours@zhours-VirtualBox:/relinux$ ll /home/relinux/总用量 1923372 drwxr-xr-x 4 root root 4096 5月 12 15:09 ./drwxr-xr-x 4 root root 4096 5月 12 14:31 ../-rw-r–r– 1 root root 1969508352 5月 12 15:09 custom.iso-rw-r–r– 1 root root 47 5月 12 15:11 custom.iso.md5 drwxr-xr-x 6 root root 4096 5月 12 15:05 .ISO_STRUCTURE/drwxr-xr-x 12 root root 4096 5月 12 14:31 .TMPSYS/zhours@zhours-VirtualBox:/relinux$

迁移博客图片资源从SAE到七牛

Wed, 21 May 2014 09:57:02 +0000

博客的很多图片资料存放在 SAE 上面，鉴于七牛的静态资源存储不错，计划迁移到七牛云存储上面，进而方便统一管理。

【下载 SAE Storage 中的资料】

所需工具：Cyberduck
配置

服务器：auth.sinas3.com 端口：443 用户名：应用AccessKey 密码：应用SecretKey

【上传到七牛】

所需工具：qiniu-devtools-windows_386 [qrsync.exe]
配置, 新建 conf.json 文件

access_key：应用AccessKey secret_key：应用SecretKey bucket：bucket 名称 sync_dir：本地同步文件夹

执行 qrsync.exe conf.json 即可

【外链切换】

原外链地址：

http://carey-wordpress.stor.sinaapp.com/uploads/2011/06/The-Moon-150x150.jpg

新外链地址：

http://carey.u.qiniudn.com/uploads/2011/06/The-Moon-150x150.jpg

【数据库相关】

查询包含外链的相关文章

SELECT * FROM wp_posts WHERE post_content LIKE ‘%http://carey-wordpress.stor.sinaapp.com/%’

指定文章替换

UPDATE wp_posts SET post_content = replace(post_content, ‘http://carey-wordpress.stor.sinaapp.com/', ‘http://carey.u.qiniudn.com/') WHERE ID=24

全局替换

UPDATE wp_posts SET post_content = replace(post_content, ‘http://carey-wordpress.stor.sinaapp.com/', ‘http://carey.u.qiniudn.com/')

【资料相关】

SAE 地址：http://sae.sina.com.cn/
SAE SVN 地址：https://svn.sinaapp.com/carey
七牛官方：https://portal.qiniu.com/

搭建基于Flask框架的树莓派服务器

Sat, 09 Nov 2013 10:15:57 +0000

本文展示了怎么样来利用Flask框架来搭建树莓派的服务器，然后通过web方式来控制物理硬件的开关~。背后的实现原理是，在树莓派的平台上利用python语言开发包，开发IO通信程序，然后通过Flask框架，以web的方式展现出来，那么，这样就可以通过pc的web浏览器或者手持设备的web浏览器来控制实际的硬件开发，实现了物联网的远程控制。

The following is an adapted excerpt from Getting Started with Raspberry Pi

. I especially like this section of the book because it shows off one of the strengths of the Pi: its ability to combine modern web frameworks with hardware and electronics.

Not only can you use the Raspberry Pi to get data from servers via the internet, but your Pi can also act as a server itself. There are many different web servers that you can install on the Raspberry Pi. Traditional web servers, like Apache or lighttpd, serve the files from your board to clients. Most of the time, servers like these are sending HTML files and images to make web pages, but they can also serve sound, video, executable programs, and much more.

Android云推送之GCM

Sat, 28 Sep 2013 09:39:37 +0000

本文展示了怎样来利用谷歌的云推送系统Google Cloud Messaging (GCM)来推送消息到Android手机，目前支持两大类消息，一类是“send-to-sync”，即发送一个触发指令，格式为一个自定义的字符串，例如 “syncTime"表示同步时间，那么Android客户端收到此消息的话，需要启动一个后台线程，同设定的Server进行交互，获取最新的时间；还有一类是“message with payload”，即发送一条消息，消息中可包含正文内容，比如message.addData(“new_time”, curTime)，则可以通过键值"new_time"获取到具体的时间。

Pushing data has a number of benefits such as increased battery life and decreased server load. GCM is free to use and has no quotas, so it is a perfect candidate to handle the heavy lifting required for data updates.

There are two types of messages you can push with GCM: Send-to-sync and message with payload. A send-to-sync is basically a tickle, telling your app to sync with the server while a message with payload lets you send data in the push message (up to 4kb). Here’s a simple, full stack example that will help highlight how to get each of these types of push messages integrated with your app.

备忘：C与C++之间的互相调用

Fri, 20 Sep 2013 14:03:12 +0000

最新在做Ubuntu上面的C++开发，其中用到了部分C库，那么就涉及到C和C++之间的混合调用，C++调用C语言比较方便，反之则要稍作变通。

1. C++ 调用 C 语言

头文件包含：

extern "C"
{
#include "iec61850_server.h"
#include "iso_server.h"
#include "acse.h"
#include "thread.h"
#include "model.h"
}

函数调用：

IedServer_observeDataAttribute(iedServer, (DataAttribute*)mmsi.dmm, observerCallback);

回调函数observerCallback的声明和实现如下：

extern "C"
{
  void observerCallback(DataAttribute* dataAttribute)
  {
    call_Lib_daObserverCallback(mod, dataAttribute);
  }
}

2. C 调用 C++ 语言

在C语言的函数中是无法直接调用C++代码的，如果要调用，需要做一个wrapper，例如call_Lib_daObserverCallback，它的声明和实现如下：

extern "C" void call_Lib_daObserverCallback(Lib* p, DataAttribute* dataAttribute) // wrapper function
{
   p->daObserverCallback(dataAttribute);
}

daObserverCallback 才是我们C++代码的实现：

void Lib::daObserverCallback(DataAttribute* dataAttribute)
{
  map<string, MMSINFO>::iterator it;
  // ...
}

体验物联网

Mon, 16 Sep 2013 09:47:15 +0000

上个星期初步接触了物联网，正好工作手头有这些基本的器件，可以打造一个最简单的物联网环境，体验一下。本文的目的是展示一个基于温湿度数据采集的报警系统，当温度或者湿度达到一定的临界值，自动打开报警器，并且微信通知系统管理员，系统管理员也可以通过微信查询当前环境的实时温湿度数据。

【系统整体架构】

PC端本地通过OpenScada系统采集温湿度的数据
PC端本地将采集到的温湿度数据定时上报到云端，供PAD查询
PC端本地检测温湿度的阀值，启动或者关闭报警设备
PC端本地检测到报警信息，及时给云端报告告警信息，云端通过微信系统推送到系统管理员账号上
系统管理员通道PAD微信系统，查询当前环境的数据

【硬件环境】

工作PC，ubuntu系统，运行openscada数据采集系统
PAD一台，手机也可以，模拟器也行，能跑微信就行
USB-485 转接器，PC上没有485端口，需要转换成USB通信协议
FT-02RL开关量输入输出模块(MODBUS-RTU协议)，软件控制继电器开关
温湿度传感器，基于485 modbus的数据传输协议

【硬件布线】

注意一下电源的正负极，不要接反了
注意485的A B数据端口，不要接反了
其他的没啥问题了

【软件环境】

本地PC运行Ubuntu 12.04 OS
本地实现OpenScada数据采集系统，可以采集Modbus协议的数据，和基于Modbus协议控制外设
远端的PHP服务器，采用的我博客（http://blog.zhourunsheng.com）的后台，基于wordpress + 插件
微信公众号的接入，像我下面的微信号是专门为博客服务的

【演示数据查询】

加入公众微信号，查询关键字“zhou_runsheng”，或者扫描如下的二维码，添加

发送查询指令，例如“查询温湿度”，返回当前环境温湿度数据

<<< 查询温湿度>>> 温湿度数据：温度：33.5 度湿度：88.7%露点：18.7 度

其他的指令还没有加入，如果输入其他的查询信息，默认会按照该关键词来搜索相关的博文展示

【演示报警】

加热温湿度采集器（O(∩_∩)O，用火烤烤，甭烧毁仪器就行）
加湿温湿度采集器（最简单的办法，对着仪器哈口气，湿度立马上升到99.99%）
当温湿度达到管理员配置的临界阀值（比如温度超过33摄氏度），产生报警
报警产生，报警器响铃，微信推送通知系统管理员
湿度报警, 继电器开关打开，左数第一个亮起来的红灯

【未来】

目前仅仅实现了简单的数据采集+报警应急处理，推广到其他地方，比如智能家居，智能农田灌溉，智能监控系统等等，O(∩_∩)O哈哈~，先想想怎么样打造一套智能的家居吧~~~，把家里联网的东西全控制了。

Android后台服务之IntentService

Sat, 07 Sep 2013 09:07:10 +0000

在Android的开发过程中，经常需要用到后台服务来完成非UI的工作，比如文件的下载，那么本文提到的IntentService便是一个很好的选择，可以利用它的队列机制，放入一系列的任务，然后系统会依次启动单独的Service来执行任务，免去了自己维护队列的麻烦。

In the new category Read the code

I’m going to show the internals of the Android framework. Reading the code of the framework can give you a good impression about what’s going on under the hood. In addition to that knowing how the framework developers solved common problems can help you to find the best solutions when facing problems in your own app code.

What is the IntentService class good for?

JavaScript之变量和函数提升

Sat, 07 Sep 2013 07:54:32 +0000

JS代码有一个特殊的规则，那就是 hoisted提升规则，函数的调用可以放在函数实现的前面，但是仅限于函数是以非表达式的场合声明实现的，那么变量的提升又有什么不同呢，在开发过程中还会出现哪些经常犯的错误，本文对此进行了介绍。

One of the trickier aspects of JavaScript for new JavaScript developers is the fact that variables and functions are “hoisted.” Rather than being available after their declaration, they might actually be available beforehand. How does that work? Let’s take a look at variable hoisting first.

// ReferenceError: noSuchVariable is not defined
console.log(noSuchVariable);

This is more or less what one would expect. An error is thrown when you try to access the value of a variable that doesn’t exist. But what about this case?

Python开发之性能优化

Sat, 31 Aug 2013 10:45:21 +0000

不论什么语言的开发，都会涉及到下面的几个问题，代码的运行时间，性能出现的瓶颈，内存的占用情况，是否有内存的泄露等等，同样Python也不例外，本文介绍了几个优秀的Python工具，可以实现如上所述问题的检测机制，通过动态运行跟踪代码的执行情况，从而发现问题点。

While it’s not always the case that every Python program you write will require a rigorous performance analysis, it is reassuring to know that there are a wide variety of tools in Python’s ecosystem that one can turn to when the time arises.

Analyzing a program’s performance boils down to answering 4 basic questions:

How fast is it running?
Where are the speed bottlenecks?
How much memory is it using?
Where is memory leaking?

Below, we’ll dive into the details of answering these questions using some awesome tools.

解读JavaScript的Scope和Context

Sat, 31 Aug 2013 09:47:22 +0000

本文详细解读了Javascript语言中的作用域Scope和上下文Context。JS是一种特殊的解释型语言，尤其是闭包的概念，使得JS更灵活，还有事件的绑定bind，this指针的用法等，相信本文有所帮助。

JavaScript’s implementation of scope and context is a unique feature of the language, in part because it is so flexible. Functions can be adopted for various contexts and scope can be encapsulated and preserved. These concepts are behind some of the most powerful design patterns JavaScript has to offer. However, this is also a tremendous source of confusion amongst developers, and for good reason. The following is a comprehensive explanation of scope and context in JavaScript, the difference between them, and how various design patterns make use of them.

Ubuntu升级源备忘

Fri, 30 Aug 2013 14:29:10 +0000

ubuntu的版本支持的时间都有限, 如果过了支持的时间，更新源会被停用，那么只能采取old-releases源了。

查看当前系统的版本信息

chs@chs-VirtualBox:~/project/openscada$ sudo lsb_release -a
[sudo] password for chs:
No LSB modules are available.
Distributor ID: Ubuntu
Description: Ubuntu 11.04
Release: 11.04
Codename: natty

可以发现当前的系统版本是11.04，代号为natty。

old-releases源信息如下

deb http://old-releases.ubuntu.com/ubuntu/ natty main restricted universe multiverse
deb http://old-releases.ubuntu.com/ubuntu/ natty-security main restricted universe multiverse
deb http://old-releases.ubuntu.com/ubuntu/ natty-updates main restricted universe multiverse
deb http://old-releases.ubuntu.com/ubuntu/ natty-proposed main restricted universe multiverse
deb http://old-releases.ubuntu.com/ubuntu/ natty-backports main restricted universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ natty main restricted universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ natty-security main restricted universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ natty-updates main restricted universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ natty-proposed main restricted universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ natty-backports main restricted universe multiverse

修改更新源，替换成上面的源信息

网站SEO优化之CSS JS代码合并

Fri, 30 Aug 2013 11:34:48 +0000

在优化网站的过程中，其中一个规则就是尽量减少HTTP的请求数量，比如图片的合并，JS，CSS代码的合并等，本文介绍了一款PHP的自动合并脚本，可以在网站中使用，只要将原来需要引用JS和CSS的地方，换成该脚本的函数调用，那么脚本就会自动将过个请求合并成一个请求，重而提高网站的打开速度。

Combining Assets

One of the basic tenets of making a web-page load quickly is reducing the number of HTTP requests that your page makes. One very common way of doing this, is assuring that all of your CSS files are combined into one request (ideally in the <head> tag), and all of your javscript files are combined into one request (ideally at the bottom of the <body> tag).

The Solution

I’ve worked with several large sites which each had their own solutions, but recently I found myself needing to speed up a fairly simple site:Burndown for Trello.

Ubuntu SVN客户端连接windows VisualSVN SSL证书问题

Fri, 30 Aug 2013 10:29:50 +0000

问题

英文：svn: OPTIONS of ‘https://server.domain.local/svn/repo':SSL handshake failed: SSL error:Key usage violation in certificate has been detected. (https://server.domain.local) 中文：SSL handshake failed: SSL 错误：在证书中检测到违规的密钥用法。

解决方案

Symptoms

Subversion clients receive the following error message when attempting to connect to VisualSVN Server:

svn: OPTIONS of ‘https://server.domain.local/svn/repo': SSL handshake failed: SSL error:

Key usage violation in certificate has been detected. (https://server.domain.local) You may experience the issue if both of the following conditions are met:

VisualSVN Server has a self-signed certificate applied and
Subversion client is built against the GnuTLS library.

NoteGnuTLS library is an alternative to OpenSSL. Most Subversion clients for Windows are built against OpenSSL and are not affected by this issue. While some Subversion packages (available mostly on Linux-based operating systems such as Ubuntu and Debian) are built against GnuTLS and are affected.

搭建基于Python的视频服务器

Sat, 24 Aug 2013 10:57:27 +0000

本文基于Python后台搭建了一个视频服务器，集视频的上传，视频的格式转化，视频的播放于一体，后台基于Django框架和Amazon S3的存储，视频格式的转换基于Encoding.com的在线服务，消息队列基于RabbitMQ，视频上传和转换处理完毕后，采用浏览器的Html5播放，采用了Video.js。

Stickyworld’s consultation web app has supported video for a long time but it’s been hosted via a YouTube embed. When we started building the new version of the web app we wanted to take control of the video content and also free our users from YouTube’s terms of service.

I personally had worked on projects with clients in the past which did video transcoding and it was never something easy to achieve. It takes a lot to accept every video, audio and container format under the sun and output them into various video formats that the web knows and loves.

NODE.JS开发入门

Sat, 24 Aug 2013 10:18:49 +0000

一篇优秀的NODE.JS入门文章，介绍了安装，运行简单的程序，IO程序，NPM安装依赖包，Module开发。

There’s no shortage of Node.js tutorials out there, but most of them cover specific use cases or topics that only apply when you’ve already got Node up and running. I see comments every once and awhile that sound something like, “I’ve downloaded Node, now what?” This tutorial answers that question and explains how to get started from the very beginning.

What is Node.js?

A lot of the confusion for newcomers to Node is misunderstanding exactly what it is. The description on nodejs.org definitely doesn’t help.

Android动画设计之ViewOverlay

Thu, 22 Aug 2013 10:38:06 +0000

什么是ViewOverlay？

ViewOverlay is a class that we can find in Android since its version 4.3 (API version 18) that provides a transparent layer on top of a View

, to which you can add visual content and that does not affect the layout hierarchy.

It always has the same size and position as its host view, allowing you to add content over that view.

运行效果

红色部分：使用了按钮的 parent-parent layout (the main, first-level, layout) ViewGroupOverlay，所以可以穿越整个画面。

Android网络编程之SPDY

Thu, 22 Aug 2013 09:33:06 +0000

Android的网络编程大家基本都熟悉，Http的Get，Post请求与其他语言的开发大同小异，可以采用Android自带的网络开发包，也可以采用Apache的开源网络编程包。本文介绍一个支持SPDY的开发包 OkHttp，关于SPDY的知识，大家可以从维基百科和百度百科上面找到，基本就是增强版的Http。

OkHttp is an HTTP client that’s efficient by default:

SPDY support allows all requests to the same host to share a socket.
Connection pooling reduces request latency (if SPDY isn’t available).
Transparent GZIP shrinks download sizes.
Response caching avoids the network completely for repeat requests.

示例代码

GET A URL

This program downloads a URL and print its contents as a string.

Full source.

    OkHttpClient client = new OkHttpClient();

    String get(URL url) throws IOException {
      HttpURLConnection connection = client.open(url);
      InputStream in = null;
      try {
        // Read the response.
        in = connection.getInputStream();
        byte[] response = readFully(in);
        return new String(response, "UTF-8");
      } finally {
        if (in != null) in.close();
      }
    }

POST TO A SERVER

This program posts data to a service.

深度解读Android关机过程

Wed, 21 Aug 2013 11:59:03 +0000

想知道Android系统的关系过程么？？？本文将会展示一个完整的关机处理流程。

What happened when I long press power button ?

What is shutdown sequence ?

How is it different from desktop linux shutdown sequence?

How to change shutdown menu ?

Many questions pop-up in mind when we think about Android shutdown sequence. Before you read about shutdown sequence I suggest you to read about boot sequence article.

Android is linux based open source operating system, x86 (x86 is a series of computer microprocessor instruction set architectures based on the Intel 8086 CPU.) is most likely system where linux kernel is deployed however all Android devices are running on ARM process (ARM (formerly Advanced RISC Machine, which was formerly Acorn RISC Machine)) except Intel’s Xolo device (http://xolo.in/xolo-x900-features). Xolo comes with Atom 1.6 GHz x86 processor. Android shutdown sequence is different from desktop linux like ubuntu, fedora, etc.

基于Gradle生成Android apklibs

Wed, 21 Aug 2013 10:45:58 +0000

So, you’ve decided to switch your Android library project to the new hotness (Gradle, Android’s new build system)? About to release a new Android library? Read on.

*What is apklib?*apklib is a way to bundle an Android library project.

Many Android developers thought the existing Android build system, based on Ant, was insufficient. Maven is arguably a better build system, so the android-maven-plugin was created, to let Maven users build their Android projects.

创建自定义的SQLite Loader

Wed, 21 Aug 2013 10:30:52 +0000

在开发Android的过程中，我们经常会用到SQLite进行资料的存储，本文给出了一种自定义Loader的方式，直接访问SQLite的API进行交互。

Today we’ll discuss about custom loaders in Android. Loaders have been introduced from Android 3.0 but we can also use loaders in prior versions of Android starting from Android 1.6 with the help of Android compatibility library.

In this tutorial we won’t discuss the basics of loader which is vastly available in the Internet. A very good tutorial on loaders in Android can be found here . Here we’ll discuss about how to create a custom loader in Android which can read data from SQLite Database and return the read data as a collection of POJO.

Aspect Oriented Programming (AOP) 设计导读

Sat, 17 Aug 2013 08:22:00 +0000

AOP通俗来讲，就是在不改变既有代码的基础上增加新功能，比如常用的地方有日志记录，可能我们已经上线了产品，代码也已经进行了发布，如何在此种情况下，增加log记录，打印出后台函数的调用记录，参数传递情况等等。在面向对象的设计过程中，已经有其他的方式可以利用，比如继承，组合，代理等，但是相对于AOP来说，都没有后者灵活。本文基于JavaScript语言进行介绍。

Aspect Oriented Programming (AOP) is a technique for augmenting the behavior of objects, methods, and functions non-invasively. AOP allows you to add new behaviors and to combine and modify existing behaviors “from the outside”.

While there are many techniques for adding and combining behavior, such as inheritance, composition, and delegation, AOP can prove to be more flexible and less invasive in many situations, and it is a worthwhile addition to your toolbox of techniques.

一种更符合自然语意的PHP正则表达式

Thu, 15 Aug 2013 22:07:37 +0000

在编程的过程中，尤其是文本的处理，我们很多时候都需要正则表达式，比如，验证用户输入的Email是否格式正确，电话号码是否符合规范，或者其他的自定义规则。对新手来说，熟记正则表达式的规则比较困难，那么有没有一种更符合自然语义的正则表达式呢，本文会给你答案。

Most newbie (and some seasoned) programmers have difficultly constructing Regular Expressions. Many a times one needs to create a Regexp quickly to test a a particular piece of code. However, not being comfortable withe Regexps can be a problem.

VerbalExpressions

is a PHP library that enables you to construct regular expressions using natural language like constructs. Think of it like a DSL for building Regexps.

verbalexpressions 已经实现了多个语言版本的库，可以从这里得到。

Below is a sample PHP code that constructs a regular expression which tests whether a given string is a valid url.

PHP中Session的使用

Thu, 15 Aug 2013 21:38:34 +0000

php中使用session的场合主要是用户登录信息的记录和页面之间数据的传递，session的有效期为浏览器的生存期，直到用户关闭浏览器，服务器中的session数据才清除。本文介绍了怎么样利用session来存储变量。

In this article I’m going to show you some simple things to work with sessions in php, these are mostly used to store information about your users, like usernames, choices selected by users and similar, these however are stored on the server and deleted once the user closes the browser. To interact with session variables you need to carefully create them and then check them and accordingly do something based on their value. This is actually the main topic of this article, how to check and create php session variables.

libiec61850在OpenSCADA系统中的使用(二)

Thu, 15 Aug 2013 15:36:41 +0000

上一篇文章《libiec61850在OpenSCADA系统中的使用》介绍了libiec61850和OpenSCADA系统的混合编译，编译是没有问题，但是做成模块的话运行起来还是会出现问题，其中最主要的问题就是库的链接，导致运行时函数找不到，原因出在C和C++函数相互调用的关系，libiec61850是C库，OpenSCADA是C++。

本文采用将libiec61850编译成动态库的方式供OpenSCADA系统调用，步骤如下：

动态库的编译安装

修改libiec61850的 “lib61850\make\target_system.mk” 文件，编译选项添加fPIC

CFLAGS += -g
CFLAGS += -fPIC

修改libiec61850 的“lib61850\Makefile”文件，添加生成动态库的参数soname

$(DYN_LIB_NAME): $(LIB_OBJS)
$(CC) $(LDFLAGS) -lpthread -shared -Wl,-soname -Wl,libiec61850.so -o $(DYN_LIB_NAME) $(LIB_OBJS) $(LDLIBS)

编译生成动态库

$ make dynlib

生成 “lib61850\build\libiec61850.so”文件

$ /usr/bin/install -c lib61850/build/libiec61850.so /usr/lib/i386-linux-gnu/libiec61850.so

修改OpenSCADA SP61850 module的 “Makefile.am” 文件，动态链接libiec61850.so

#!!! The module link flags
spec_SP61850_la_LDFLAGS = -module -avoid-version -no-undefined -Llib61850/build -liec61850 $(SP61850_LDLAGS)

############ for lib61850 include header file and lib file ##################
AM_CPPFLAGS = -Ilib61850/inc -Ilib61850/src/common -Ilib61850/src/mms/iso_presentation -Ilib61850/src/mms/iso_session -Ilib61850/src/mms/iso_cotp -Ilib61850/src/mms/iso_acse -Ilib61850/src/mms/iso_mms/common -Ilib61850/src/mms/iso_mms/client -Ilib61850/src/mms/iso_mms/server -Ilib61850/src/mms/iso_client -Ilib61850/src/mms/iso_server -Ilib61850/src/mms/asn1 -Ilib61850/src/iedcommon -Ilib61850/src/iedserver/mms_mapping -Ilib61850/src/iedserver/model -Ilib61850/src/iedserver -Ilib61850/src/iedclient -Ilib61850/src/hal -Ilib61850/src/hal/thread -Ilib61850/src/hal/socket -Ilib61850/src/goose
#############################################################################

测试代码的编写

修改“SP61850\module.h”头文件，添加libiec6180的常用头文件

/////////////////////////////////////////////////////////
extern "C"
{
#include "iec61850_server.h"
#include "iso_server.h"
#include "acse.h"
#include "thread.h"
#include <stdlib.h>
#include <stdio.h>

#include "static_model.h"

/* import IEC 61850 device model created from SCL-File */
extern IedModel iedModel;
}
////////////////////////////////////////////////////////

////C++类（class Lib : public TSpecial）内部添加属性
///////////////////////////////////////////////////////////

int running;
IedServer iedServer;
///////////////////////////////////////////////////////////

修改“SP61850\module.cpp”文件，控制服务器的启动与停止

//////// 启动服务器 void Lib::modStart( )

//61850 server.
if(! running)
{
iedServer = IedServer_create(&iedModel);

/* MMS server will be instructed to start listening to client connections. */
IedServer_start(iedServer, 102);

/* Instruct the server that we will be informed if a clients writes to a
* certain variables we are interested in.
*/
IedServer_observeDataAttribute(iedServer, IEDMODEL_Device1_DSCH1_NamPlt_vendor,
observerCallback);

IedServer_observeDataAttribute(iedServer, IEDMODEL_Device1_DSCH1_NamPlt_swRev,
observerCallback);

if (!IedServer_isRunning(iedServer))
{
mess_err(nodePath().c_str(),_("Start 61850 Server error."));
IedServer_destroy(iedServer);
}
else
{
running = 1;
}
}

////// 停止服务器 void Lib::modStop( )
//
if(running)
{
/* stop MMS server - close TCP server socket and all client sockets */
IedServer_stop(iedServer);

/* Cleanup - free all resources */
IedServer_destroy(iedServer);

running = 0;
}

注册数据监听函数

extern "C"
{
void observerCallback(DataAttribute* dataAttribute)
{
if (dataAttribute == IEDMODEL_Device1_DSCH1_NamPlt_vendor)
{
printf("GGIO.NamPlt.vendor changed to %s\n",
MmsValue_toString(dataAttribute->mmsValue));
}
else if (dataAttribute == IEDMODEL_Device1_DSCH1_NamPlt_swRev)
{
printf("GGIO.NamPlt.swRef changed to %s\n",
MmsValue_toString(dataAttribute->mmsValue));
}
}
}

生成测试数据，修改数据节点

////////////////////for test/////////////////////////////
if(running)
{
MmsValue* td = MmsValue_newIntegerFromInt32 (200);
IedServer_updateAttributeValue(iedServer, IEDMODEL_Device1_DSCH1_SchdSt_stVal, td);
MmsValue_delete(td);

td = MmsValue_newIntegerFromInt32 (202);
IedServer_updateAttributeValue(iedServer, IEDMODEL_Device1_DSCH1_Health_stVal, td);
MmsValue_delete(td);
}
////////////////////////////////////////////////

系统测试

编译SP61850 模块

$cd openscada-0.8.0.5/src/moduls/special/SP61850

$ make clean; make

$ ~/project/openscada-0.8.0.5/src/moduls/special/SP61850$ ldd .libs/spec_SP61850.so
linux-gate.so.1 => (0x00542000)
libiec61850.so => /usr/lib/i386-linux-gnu/libiec61850.so (0x007e7000)
libstdc++.so.6 => /usr/lib/i386-linux-gnu/libstdc++.so.6 (0x00bc0000)
libm.so.6 => /lib/i386-linux-gnu/libm.so.6 (0x00e84000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000)
libgcc_s.so.1 => /lib/i386-linux-gnu/libgcc_s.so.1 (0x00273000)
libpthread.so.0 => /lib/i386-linux-gnu/libpthread.so.0 (0x0028f000)
/lib/ld-linux.so.2 (0x00af2000)

$ sudo make install

运行测试

$ sudo openscada

利用61850客户端软件进行连接确认，例如IEDScout，连接[192.168.1.160:102]

参考资料

http://libiec61850.com/api/2.

怎样写出更有效率的CSS

Thu, 15 Aug 2013 09:18:22 +0000

在页面设计的过程中，总会使用CSS来进行样式设计，样式的选择器也无非常用4种，ID，Class，Tag和Universal，优先级从高到底，那么怎么样设计选择器和样式，可以提高CSS的解析效率，平时的设计中又会出现哪些误区，那么如下的文章值得一看。

Writing good CSS code can speed up page rendering. Essentially, the fewer rules the engine has to evaluate the better.

MDN

groups CSS selectors in four primary categories, and these actually follow the order of how efficient they are:

ID Rules
Class Rules
Tag Rules
Universal Rules

The efficiency is generally quote from Even Faster Websites by Steve Souders which was published in 2009. Souders list is more detailed, though, and you can find the full list referenced here. You can find more details in Google’s best practices for efficient CSS selectors.

Android构建编译系统之Gradle Build

Tue, 13 Aug 2013 11:15:51 +0000

Google I/O 2013 大会推出了一款新的Android开发工具Android Studio IDE，与Eclipse相差不多，实际的开发选择哪一款随个人喜好，像我平时的开发都是以Eclipse为主，ant辅助进行构建，也支持了一种新的构建工具Gradle，Android Studio IDE内置的默认构建工具就是Gradle，关于Gradle的详细资料可以参照官方网站。本系列文章介绍了Android开发过程中的Gradle Build，共有7篇文章，由浅入深。

At Google I/O 2013 Google announced some new developer tools including the new Android Studio IDE, and a new build system based around Gradle. In this series we’ll have a look at the Gradle build system, and look at how to convert existing projects to use the new build system.

Previously on Styling Android we’ve looked at using Maven for automating your builds

Java开发内存优化导读

Tue, 13 Aug 2013 10:32:05 +0000

在开发Java的过程中，怎么样合理的利用 Object，资源的申请与释放，每种类型的 Object 占用的内存大小是多少，有没有可以替换的lib可以使用。鉴于效率的考量和内存占用的考量，我们应该选择什么样的数据结构，那么如下的文章将会找到答案。

This article will give you the general advices on memory consumption optimization in Java.

Memory usage optimization is the most important type of optimization in Java.

Current systems are limited by memory access times rather than by CPU frequency

(otherwise, why CPU producers are implementing all these L1s, L2s and L3s?). It means that by reducing your application memory footprint you will most likely improve your program data processing speed by making your CPU to wait for smaller amount of data. Now let’s get back to Java.

【摘自】人、技术、情怀

Mon, 12 Aug 2013 10:36:18 +0000

这个世界人很多，做技术的人也不少，但是有情怀的技术人不多。

人类发明了各种工具来方便自己、改善生活亦或是达到某种目的，虽然并不只是人类会制造工具，但是不同的是我们懂得如何去思考、沉淀、积累。现在我们有了计算机、有了编程语言、有了网络，也许我们已经不再需要具体的工具形态就能改变世界，一切就在弹指一挥间。

但是我们所造就的工具却正奴役着我们，多少程序员苦逼的吐槽自己是码农？多少人在2米见方的格子里敲着CURD？多少人每天熬到深夜只是因为Deadline逼近？这就像历史中描述的工业革命的那段日子，人们发明了蒸汽机、纺织机，但是却成了这些机器的守护者。我们存在的意义也许只是按照机器的指示做出各种动作，什么梦想、什么情怀，已经烟飘云散。

我们不反对技术的进步，然而这种进步不应该以牺牲自己的生活为代价，二者是可以兼容的。如果你了解运维就应该知道这是一个很苦逼的差事，“没出事不被人想起，一旦有事就要随时待命”。在今年的QCon北京上，来自Github的运维工程师分享了他不同的“生活”，通过工具、脚本、辅助机器人，他可以逍遥在自己的小船上晒着太阳维护着机房。的确我们需要对自己所做的工作负责，但是我们更要对自己负责。如果你还能想起十几二十年的梦想，如果你能在码字的间隙去环顾现在的生活，请问一个问题，这是否是我想要的！

技术人，不要把自己陷在技术的圈子中，世界太大，人生太短。我们习惯了敲错代码就按下ctrl+z，出问题了就debug，但是人生是一段不能回头的单行道，不要迷惘选择是否正确，当你心之所向，那就前往。最后送大家一首叶芝的诗，献给也许已经逝去的“情怀”！：

当你老了，白发苍苍，睡意朦胧，在炉前打盹，请取下这本诗篇，慢慢吟咏，梦见你当年的双眼那柔美的光芒与青幽的晕影；多少人真情假意，爱过你的美丽，爱过你欢乐而迷人的青春，唯独一人爱过你朝圣者的心，爱你日益凋谢的脸上的哀戚；当你佝偻着，在灼热的炉栅边，你将轻轻诉说，带着一丝伤感，逝去的爱，如今以步上高山，在密密星群里埋藏着它的赧颜。

libiec61850在OpenSCADA系统中的使用

Fri, 09 Aug 2013 13:01:22 +0000

libiec61850 是一套开源的C库，它实现了大多数的61850的协议转换，原理同样是基于MMS协议的映射。本文要将libiec61850用在OpenSCADA系统中，使OpenSCADA系统可以提供智能变电站61850协议的接入。

简介

libiec61850 is an open-source (GPLv3) implementation of an IEC 61850 client and server library. It is implemented in C to provide maximum portability. It can be used to implement IEC 61850 compliant client and server applications on embedded systems and PCs running Linux and Windows. Included is a set of simple example applications that can be used as a starting point to implement your own IEC 61850 compliant devices or to communicate with IEC 61850 devices.

基于PHP后台的Android云推送方案

Thu, 08 Aug 2013 22:19:16 +0000

开发过移动APP的同学都知道云推送，比如Google的后台服务，联系人同步，邮件同步，APK的自动升级等都是这个机制，其实利用云推送机制还可以实现消息的发送，本文介绍了一种基于PHP后台的推送机制，实现原理还是通过Google的云端服务(Google Cloud Messaging for Android service)，android客户端采用的是phoneGap的PushPlugin。

Last days I’ve been working within a Phonegap

project for Android devices using Push Notifications. The idea is simple. We need to use the Push Notification Plugin

for Android. First we need to register the Google Cloud Messaging for Android service at Google’s console, and then we can send Push notifications to our Android device.

The Push Notification plugin provides a simple example to send notifications using Ruby

OpenSCADA系统添加自定义模块

Thu, 08 Aug 2013 16:56:24 +0000

前言

OpenSCADA作为一个开源的Scada系统，本文基于此系统来添加一个子模块，例子中准备添加一个支持61850协议的模块（名称为SP61850）。

OpenScada内置支持如下的子系统

“Data Bases”
“Communication Interfaces, Transports”
“Protocols of the communication interfaces”
“Data Sources and Data Acquisition”
“Archives(Histories) (of messages and values)”
“User Interfaces (GUI, TUI, WebGUI, speach, signal …)”
“Additional modules”

我们所要添加的子模块隶属于如上的"Additional modules"，即"special"子系统。

步骤

$ cd openscada-0.8.0.5/src/moduls/special
$ cp -r =Tmpl= SP61850; cd SP61850
$ rm -f configure.in

编辑"module.cpp"文件 2.1 module info 改为如下：

//!!! Module's meta-information. Change for your module.
//*************************************************
//* Modul info! *
#define MOD_ID "SP61850"
#define MOD_NAME _("Special 61850 model")
#define MOD_TYPE SSPC_ID
#define VER_TYPE SSPC_VER
#define SUB_TYPE "LIB"
#define MOD_VER "0.0.1"
#define AUTHORS _("Carey Chow")
#define DESCRIPTION _("Special subsystem 61850 module.")
#define LICENSE "MyLicense"
//*************************************************

2.2 全文搜索替换 Tmpl –> SP61850 2.3 注释掉模板中无效的地方

Java开发内存占用监测

Mon, 05 Aug 2013 21:15:20 +0000

在开发Java的过程中，怎么样来监测一个对象占用的内存大小，对于调试程序，优化程序来说，有很大的帮助，本文介绍了一个开发包，JAMM (Java Agent for Memory Measurements)，可以很方便的在程序的运行过程中动态监测对象的内存占用情况。

This short article shows how to measure java object memory size at runtime with JAMM

, a java agent dedicated to measure actual object memory use including JVM overhead.

JAMM uses the Instrumentation

implementation provided by the JVM to compute memory usage of a given object by calling the getObjectSize(..) method.

It is quite simple to use, as explained by the author:

MemoryMeter meter = new MemoryMeter();
meter.measure(object);
meter.measureDeep(object);
meter.countChildren(object);

The only constraint is to attach JAMM java agent to the JVM before using it to measure memory usage, by starting the JVM with the-javaagent option pointing to the JAMM jar.

Java语言开发之SQL语句改善

Mon, 05 Aug 2013 18:57:15 +0000

在基于Java语言的开发过程中，DB相关的开发相信大家都接触过SQL语句，增删改查作为基本的操作，比较熟悉，那么JOIN，UNION, MERGE, DISTINCT这些高级的操作使用过没有呢？使用的过程中有哪些误用呢？有没有可能改善现在的SQL语句来提高程序的性能。本文介绍了几种常见的SQL误用场合，有语法方面的，改善效率方面的，下次，自己再做开发的时候，想想当前的SQL处理语句有没有可以完善的情况。

Java developers mix object-oriented thinking with imperative thinking, depending on their levels of:

Skill (anyone can code imperatively)
Dogma (some use the “Pattern-Pattern”, i.e. the pattern of applying patterns everywhere and giving them names)
Mood (true OO is more clumsy to write than imperative code. At first)

But when Java developers write SQL, everything changes. SQL is a declarative language that has nothing to do with either object-oriented or imperative thinking. It is very easy to express a query in SQL. It is not so easy to express it optimally or correctly. Not only do developers need to re-think their programming paradigm, they also need to think in terms of set theory.

OpenSCADA系统的安装配置

Mon, 05 Aug 2013 14:36:48 +0000

简介

SCADA(Supervisory Control And Data Acquisition)系统，即数据采集与监视控制系统。SCADA系统是以计算机为基础的DCS与电力自动化监控系统；它应用领域很广，可以应用于电力、冶金、石油、化工等领域的数据采集与监视控制以及过程控制等诸多领域。详细可以从百度百科和维基百科了解。

安装环境

OS: Ubuntu 11
openscada-0.8.0.5

依赖包的安装

####### 文字处理相关
sudo apt-get install gettext
sudo apt-get install zlib1g-dev
sudo apt-get install libgd2-xpm-dev
sudo apt-get install libpcre3 libpcre3-dev
sudo apt-get install bison

####### 数据库相关
sudo apt-get install libmysqlclient15-dev
sudo apt-get install libsqlite3-dev
sudo apt-get install firebird2.5-dev
sudo apt-get install postgresql libpq-dev

####### 网络，声音相关
sudo apt-get install libsnmp-dev
sudo apt-get install portaudio19-dev

####### 图形相关
sudo apt-get install libqt4-dev qt4-dev-tools

编译步骤

Steps of preparation of the source tree to build:

Make directory for project building:

Android开发之布局加载LayoutInflater

Sun, 04 Aug 2013 18:11:45 +0000

在开发Android的过程中，涉及到list view什么的，应该经常会碰到加载layout的状况，那么平时使用inflate函数的时候，经常是怎么传递参数的？在不同的场合，比如list view的adapter中加载layout与在自定义Dialog中加载Layout，它们有没有特殊区别的地方，本文就会介绍inflate函数的正确使用方法，请学习一下。

Layout inflation is the term used within the context of Android to indicate when an XML layout resource is parsed and converted into a hierarchy of View objects.

It’s common practice in the Android SDK, but you may be surprised to find that there is a wrong way to use LayoutInflater

, and your application might be one of the offenders. If you’ve ever written something like the following code using LayoutInflater in your Android application:

Android开发之上下文Context

Sun, 04 Aug 2013 17:46:08 +0000

开发过Android的同学，应该对上下文Context的概念不陌生，启动新的Activity，启动新的Service，加载系统资源文件，加载Layout等等，记得以前还分析过腾讯游戏平台免安装的实现机制，这些都涉及到了上下文Context。同时，如果误用了Context了，还会导致内存的泄露，想了解Android系统中Context使用的场合么？那么本文就会给你回答~~~

Context is probably the most used element in Android applications…it may also be the most misused.

Context

objects are so common, and get passed around so frequently, it can be easy to create a situation you didn’t intend. Loading resources, launching a new Activity, obtaining a system service, getting internal file paths, and creating views all require a Context

(and that’s not even getting started on the full list!) to accomplish the task. What I’d like to do is provide for you some insights on how Context

Python模块发布文件setup.py vs requirements.txt

Sun, 04 Aug 2013 17:06:39 +0000

我们都知道发布Python模块的时候需要准备几份文件，其中就包括了setup.py和requirements.txt，这两份文件中都需要填写待发布模块的依赖关系，那么是不是这样就会出现信息的重复，维护起来也不方便呢？如下的文章解释了这两个文件中重复信息的不同功用，前者为“虚引用”，后者为“具体引用”，那么他们利用的场合和背后的机制是什么样子的，马上就会知晓了。

There’s a lot of misunderstanding between setup.py and requirements.txt

and their roles. A lot of people have felt they are duplicated information and have even created tools to handle this “duplication”.

Python Libraries

A Python library in this context is something that has been developed and released for others to use. You can find a number of them on PyPI

that others have made available. A library has a number of pieces of metadata that need to be provided in order to successfully distribute it. These are things such as the Name, Version, Dependencies, etc. The setup.py file gives you the ability to specify this metadata like:

你需要了解的SQL注入技术

Sat, 03 Aug 2013 10:43:47 +0000

开发WEB的同学都应该听说过SQL注入，如果开发过程中，直接利用parameter中传入的值来进行数据库查询的话就有SQL注入的风险，那么到底有哪些高级的SQL注入手法，相信读过本文，了解的就不是一点点了，看看黑客们是怎样注入的，那么，自己在以后的开发过程中也要适时留意，防范这种风险。

Put on your black hats folks, it’s time to learn some genuinely interesting things about SQL injection. Now remember – y’all play nice with the bits and pieces you’re about to read, ok?

SQL injection is a particularly interesting risk for a few different reasons:

It’s getting increasingly harder to write vulnerable code due to frameworks that automatically parameterise inputs – yet we still write bad code.
You’re not necessarily in the clear just because you use stored procedures or a shiny ORM (you’re aware thatSQLi can still get through these, right?) – we still build vulnerable apps around these mitigations.
It’s easily detected remotely by automated tools which can be orchestrated to crawl the web searching for vulnerable sites – yet we’re still putting them out there.

It remains number one on the OWASP Top 10

Python函数调用的自动化内联机制

Sat, 03 Aug 2013 10:14:02 +0000

相信开发过C++语言的同学都知道，inline内联函数，get和set函数通常都写成内联机制，为的是提高程序的运行效率，缩短函数调用的时间。那么开发过Android的同学，也应该知道，android程序优化中有一条机制就是尽量不用get和set函数，因为Java中不支持C++的内联机制，所以只能舍弃get和set方法，尽管有失面向对象的访问机制，但是对手持设备来说，合理利用有限资源，提高运行效率才是首选。

本文中讲的是怎样在Python语言中利用内联机制，Python是解释性的语言，没有编译过程，那么怎么在Python中实现内联机制呢？相信读完全文，就会有个清晰的认识，目前的实现还仍有很多不足的地方，限制很多，期待以后Python的升级能够自带就好了。

Calling functions in Python can be expensive. Consider this example: there are two statements that are being timed, the first one calls a function that returns an integer while the second one calls a function that returns the result of a second function call which returns an integer.

tom@toms ~$ python -m timeit -n 10000000  -s "def get_n(): return 1" "get_n()"
10000000 loops, best of 3: 0.145 usec per loop
tom@toms ~$ time python -m timeit -n 10000000 -s "get_n = lambda: 1; get_r_n = lambda: get_n()" "get_r_n()"
10000000 loops, best of 3: 0.335 usec per loop

The additional function call doubled the program execution time, despite not effecting the output of the function in any way. This got me thinking, how hard would it be to create a Python module that would inline functions, removing the calling overhead from certain functions you specify?

分享Python模块到PyPI

Sat, 03 Aug 2013 09:40:54 +0000

怎么样打包自己的Python模块，并且分享到PyPI，相信下面的文章会给你一个满意的答案！

A completely incomplete guide to packaging a Python module and sharing it with the world on PyPI.

Abstract

Few things give me caremads like Python modules I want to use that aren’t on PyPI (pronounced “pie pee eye”, or “cheese shop”,not “ pie pie ”!). On the other hand – as pydanny points out – the current situation on packaging is rather confusing.

Therefore I want to help everyone who has some great code but feels lost with getting it on PyPI. I will be using my latest opus “ pem ” as a realistic yet simple example of how to get a pure-Python 2 and

PHP 发送博文到百度空间

Sun, 19 May 2013 11:59:31 +0000

昨天，测试了PHP方式登录百度空间，可以参见博文《PHP 登录百度空间》，今天通过抓包工具的分析，分析了博文的发布过程，实现了博文的自动发布。

参照代码如下：

private function postArticle($baiduzoneurl, $title, $content, $category, $blogpower)
{
$post_data = array();
$post_data["title"] = $title;
$post_data["tags[]"] = $category;
$post_data["content"] = $content;
$post_data["private"] = $blogpower == 0? "" : "1";
$post_data["imgnum"] = "0";
$post_data["bdstoken"] = $this->bdstoken;
$post_data["qbid"] = "";
$post_data["refer"] = "http://hi.baidu.com/home";
$post_data["multimedia[]"] = "";
$post_data["private1"] = $post_data["private"];
$post_data["synflag"] = "";
$post_data["qing_request_source"] = "new_request";

$this->doHttpPost("http://hi.baidu.com/pub/submit/createtext", $post_data, "http://hi.baidu.com/pub/show/createtext");
}

接下来再进行wordpress插件的更新，哈哈，这个就快多了！！！

PHP 登录百度空间

Sat, 18 May 2013 22:00:20 +0000

前几天，先测试了利用Python脚本登录百度空间，问题已解决，可以参照我的博文《python 脚本登录百度空间》，今天完善了php方式的登录过程，原理同python脚本的登录。

代码如下:

登录代码

private function loginBaiduZone($user,$password)
{
//get Cookie
$ret = $this->doHttpPost("https://passport.baidu.com/v2/api/?getapi&class=login&tpl=mn&tangram=false", "", "");

//get token
$ret = $this->doHttpPost("https://passport.baidu.com/v2/api/?getapi&class=login&tpl=mn&tangram=false", "", "");
preg_match_all('/login_token=\'(.+)\'/', $ret, $tokens);
$login_token = $tokens[1][0];

//login
$post_data = array();
$post_data['username'] = $user;
$post_data['password'] = $password;
$post_data['token'] = $login_token;
$post_data['charset'] = "UTF-8";
$post_data['callback'] = "parent.bd12Pass.api.login._postCallback";
$post_data['index'] = "0";
$post_data['isPhone'] = "false";
$post_data['mem_pass'] = "on";
$post_data['loginType'] = "1";
$post_data['safeflg'] = "0";
$post_data['staticpage'] = "https://passport.baidu.com/v2Jump.html";
$post_data['tpl'] = "mn";
$post_data['u'] = "http://www.baidu.com/";
$post_data['verifycode'] = "";

$ret = $this->doHttpPost("http://passport.baidu.com/v2/api/?login", $post_data, "https://passport.baidu.com/v2/?login&tpl=mn&u=http%3A%2F%2Fwww.baidu.com%2F");
}

Http请求的工具函数

python 脚本登录百度空间

Wed, 15 May 2013 21:48:18 +0000

最近半年的时间，百度空间进行了多次变更，自从去年的wordpress百度空间博文同步插件不可用之后，就一直没有维护更新，最近百度空间基本稳定了，通过抓包对比分析，发现和以前的登录过程很不一样，先利用python脚本进行登录过程的模拟，然后再利用php实现，来维护更新同步插件。

大体的登录原理如下

首先获取登录的cookie文件，没有cookie的话，百度空间不能正常登录，访问如下网址获取cookie

https://passport.baidu.com/v2/api/?getapi&class=login&tpl=mn&tangram=false

获取登录过程的token，同样再次请求上面的网址，但是这一次需要携带第1步中server返回的cookie信息

https://passport.baidu.com/v2/api/?getapi&class=login&tpl=mn&tangram=false

发送登录账号信息（用户名，密码等）到如下网址，同样需要携带步骤2中server返回的cookie信息

http://passport.baidu.com/v2/api/?login

至此，登录过程完毕

代码示例

下面的示例代码会登录百度空间，然后把所有的博文自动备份到本地，其中登录的过程就如上面的原理所讲。

#!/usr/bin/python
#coding:utf8
import cookielib, urllib2, urllib
import os,sys,socket,re
#解析有多少页博客
pageStr = """var PagerInfo = {\s*allCount\s*:\s*'(\d+)',\s*pageSize\s*:\s*'(\d+)',\s*curPage\s*:\s*'\d+'\s*};"""
pageObj = re.compile(pageStr, re.DOTALL)
#获取登陆token
login_tokenStr = '''bdPass.api.params.login_token='(.*?)';'''
login_tokenObj = re.compile(login_tokenStr,re.DOTALL)
#获取博客标题和url
blogStr = r'''<div><a href=".*?" target=_blank>.*?</a></div><a href="(.*?)" target=_blank>(.*?)</a></div>'''
blogObj = re.compile(blogStr,re.DOTALL)
class Baidu(object):
    def __init__(self,user = '', psw = '', blog = ''):
        self.user = user
        self.psw  = psw
        self.blog = blog
        if not user or not psw or not blog:
            print "Plz enter enter 3 params:user,psw,blog"
            sys.exit(0)
        if not os.path.exists(self.user):
            os.mkdir(self.user)
        self.cookiename = 'baidu%s.coockie' % (self.user)
        self.token = ''
        self.allCount  = 0
        self.pageSize  = 10
        self.totalpage = 0
        self.logined = False
        self.cj = cookielib.LWPCookieJar()
        try:
            self.cj.revert(self.cookiename)
            self.logined = True
            print "OK"
        except Exception, e:
            print e
        self.opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(self.cj))
        self.opener.addheaders = [('User-agent','Opera/9.23')]
        urllib2.install_opener(self.opener)
        socket.setdefaulttimeout(30)
    #登陆百度
    def login(self):
        #如果没有获取到cookie，就模拟登陆
        if not self.logined:
            print "logon to baidu ..."
            #第一次先访问一下，目的是为了先保存一个cookie下来
            qurl = '''https://passport.baidu.com/v2/api/?getapi&class=login&tpl=mn&tangram=false'''
            r = self.opener.open(qurl)
            self.cj.save(self.cookiename)
            #第二次访问，目的是为了获取token
            qurl = '''https://passport.baidu.com/v2/api/?getapi&class=login&tpl=mn&tangram=false'''
            r = self.opener.open(qurl)
            rsp = r.read()
            #print rsp
            self.cj.save(self.cookiename)
            #通过正则表达式获取token
            matched_objs = login_tokenObj.findall(rsp)
            if matched_objs:
                self.token = matched_objs[0]
                print 'token =', self.token
                #然后用token模拟登陆
                post_data = urllib.urlencode({'username':self.user,
                                              'password':self.psw,
                                              'token':self.token,
                                              'charset':'UTF-8',
                                              'callback':'parent.bd12Pass.api.login._postCallback',
                                              'index':'0',
                                              'isPhone':'false',
                                              'mem_pass':'on',
                                              'loginType':'1',
                                              'safeflg':'0',
                                              'staticpage':'https://passport.baidu.com/v2Jump.html',
                                              'tpl':'mn',
                                              'u':'http://www.baidu.com/',
                                              'verifycode':'',
                                            })
                #path = 'http://passport.baidu.com/?login'
                path = 'http://passport.baidu.com/v2/api/?login'
                self.opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(self.cj))
                self.opener.addheaders = [('User-agent','Opera/9.23')]
                urllib2.install_opener(self.opener)
                headers = {
                  "Accept": "image/gif, */*",
                  "Referer": "https://passport.baidu.com/v2/?login&tpl=mn&u=http%3A%2F%2Fwww.baidu.com%2F",
                  "Accept-Language": "zh-cn",
                  "Content-Type": "application/x-www-form-urlencoded",
                  "Accept-Encoding": "gzip, deflate",
                  "User-Agent": "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)",
                  "Host": "passport.baidu.com",
                  "Connection": "Keep-Alive",
                  "Cache-Control": "no-cache"
                }
                req = urllib2.Request(path,
                                post_data,
                                headers=headers,
                                )
                rsp = self.opener.open(req).read()
                #print rsp
                self.cj.save(self.cookiename)
                #for login test
                #qurl = '''http://hi.baidu.com/pub/show/createtext'''
                #rsp = self.opener.open(qurl).read()
                #file_object = open('login.txt', 'w')
                #file_object.write(rsp)
                #file_object.close()
            else:
                print "Login Fail"
                sys.exit(0)
    #获取博客一共有多少页，如果有私有博文的话，登陆和不登陆获取的是不一样的
    def getTotalPage(self):
        #获取博客的总页数
        req2 = urllib2.Request(self.blog)
        rsp = urllib2.urlopen(req2).read()
        if rsp:
            rsp = rsp.replace('\r','').replace('\n','').replace('\t','')
            matched_objs = pageObj.findall(rsp)
            if matched_objs:
                obj0,obj1 = matched_objs[0]
                self.allCount = int(obj0)
                self.pageSize = int(obj1)
                self.totalpage = (self.allCount / self.pageSize) + 1
                print 'allCount:%d, pageSize:%d, totalpage:%d' % (self.allCount,self.pageSize,self.totalpage)
    #获取每一页里的博客链接
    def fetchPage(self,url):
        req = urllib2.Request(url)
        rsp = urllib2.urlopen(req).read()
        if rsp:
            rsp = rsp.replace('\r','').replace('\n','').replace('\t','')
            matched_objs = blogObj.findall(rsp)
            if matched_objs:
                for obj in matched_objs:
                    #这里可以用多线程改写一下,单线程太慢
                    self.download(obj[0],obj[1])
    def downloadBywinget(self,url,title):
        #比如使用wget之类的第三方工具，自己填参数写
        pass
    #下载博客
    def download(self,url,title):
        path = '%s/%s.html' % (self.user,title.decode('utf-8'))
        url = 'http://hi.baidu.com%s' % (url)
        print "Download url %s" % (url)
        nFail = 0
        while nFail < 5:
            try:
                sock = urllib.urlopen(url)
                htmlSource = sock.read()
                myfile = file(path,'w')
                myfile.write(htmlSource)
                myfile.close()
                sock.close()
                return
            except:
                nFail += 1
        print ('download blog fail:%s' % (url))
    def dlownloadall(self):
        for page in range(1,self.totalpage+1):
            url = "%s?page=%d" % (self.blog,page)
            #这里可以用多线程改写一下,单线程太慢
            self.fetchPage(url)
def main():
    user = 'runsheng2005'       #你的百度登录名
    psw  = 'password'  #你的百度登陆密码,不输入用户名和密码，得不到私有的文章
    blog = "http://hi.baidu.com/zhourunsheng" #你自己的百度博客链接
    baidu = Baidu(user,psw,blog)
    baidu.login()
    baidu.getTotalPage()
    baidu.dlownloadall()
if __name__ == '__main__':
    main()

例如，我的用户名是runsheng2005，则会在工作目录建立一个名为baidurunsheng2005.coockie的文件用来保存cookie信息，其中的内容如下：

生活杂记

Sat, 06 Apr 2013 14:43:54 +0000

距离上一次写博客已经半年多天气了，在这个过程中发生了很多的事情，导致博客的更新中断了，也有读者的mail拖了好久才给回复，插件也没有后续的维护了，这段时间内有开心的事，也有难过的事，上天总是在合适的时间分配给你一个合适的任务，经历过的总是成长的，从现在开始再把博客续集起来~~~为了更好的将文章进行分享出去，特意创建了一个微信公众号！

公共平台二维码使用方式如下：

扫描上面的二维码进行微信好友的添加
发送查询的关键字，例如“android”
返回与“android”相关的博文
阅读搜索到的博客文章

配置wordpress博客阻止部分IP访问

Thu, 02 Aug 2012 17:31:59 +0000

上个月，博客安装了没一个星期，就被莫名的IP攻击了，一个月的流量早早用完了，导致博客整整歇业了将近20天，这个月的第一天，8月1号，估计攻击的ip还在沉睡中，没出现什么异常，到了8月2号，就又开始攻击了。

今天下载分析了一下apache日志文件，找到了这几个攻击的ip，详情如下：

113.108.76.195 - - [02/Aug/2012:00:10:02 -0400] "GET /favicon.ico HTTP/1.0" 301 584 "-" "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1) QQBrowser/6.0"
113.108.76.196 - - [02/Aug/2012:00:10:04 -0400] "GET /favicon.ico HTTP/1.1" 301 584 "-" "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1) QQBrowser/6.0"
114.86.181.181 - - [02/Aug/2012:00:10:05 -0400] "GET /favicon.ico HTTP/1.1" 301 583 "-" "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1) QQBrowser/6.0"
116.237.76.204 - - [02/Aug/2012:03:04:37 -0400] "GET /favicon.ico HTTP/1.1" 301 583 "-" "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1) QQBrowser/6.0"
202.105.139.117 - - [02/Aug/2012:04:02:01 -0400] "GET /favicon.ico HTTP/1.1" 301 584 "-" "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1) ; CIBA; .NET CLR 2.0.50727; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729; InfoPath.2)"
218.17.162.137 - - [02/Aug/2012:04:12:04 -0400] "GET /favicon.ico HTTP/1.1" 301 584 "-" "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1) ; CIBA; .NET CLR 2.0.50727; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729; InfoPath.2)"

主要就是这六个IP，反复请求favicon.ico文件，平均每秒发送几十个数据请求，导致博客一天的最大流量能达到3.5个G，太可怕了。

为Wordpress建立Html格式的Sitemap

Sun, 24 Jun 2012 11:56:39 +0000

熟悉wordpress建站的童鞋都知道sitemap的重要性，尤其是对网站的SEO以及各大重要搜索引擎的索引都有重要的作用，wordpress已经有许多优秀的sitemap生成插件可以使用，不过他们大部分生成的都只是xml格式的数据，可以直接提交到搜索引擎，方便搜索引擎的索引，但是不方便访客的阅读。

本文介绍一下怎样客制化和建立自己的Sitemap Page页面，可以包括或者排除特定的页面，特定的分类，加入自己定制的信息等等。

建立步骤

为了代码的重用，我们需要利用wordpress主题模板的特性（theme partial），在当前的主题文件夹下面新建立一个partials文件夹，然后在里面新建立一个sitemap.php文件，内容如下：

<h2 id="authors">Authors</h2>
<ul>
<?php
wp_list_authors(
array(
'exclude_admin' => false,
)
);
?>
</ul>

<h2 id="pages">Pages</h2>
<ul>
<?php
// Add pages you'd like to exclude in the exclude here
wp_list_pages(
array(
'exclude' => '',
'title_li' => '',
)
);
?>
</ul>

<h2 id="posts">Posts</h2>
<ul>
<?php

// Add categories you'd like to exclude in the exclude here
$cats = get_categories('exclude=');
foreach ($cats as $cat) {
echo "<li><h3>".$cat->cat_name."</h3>";
echo "<ul>";
query_posts('posts_per_page=-1&cat='.$cat->cat_ID);
while(have_posts()) {
the_post();
$category = get_the_category();
// Only display a post link once, even if it's in multiple categories
if ($category[0]->cat_ID == $cat->cat_ID) {
echo '<li><a href="'.get_permalink().'">'.get_the_title().'</a></li>';
}
}
echo "</ul>";
echo "</li>";
}

//Add Custom Post Types to your HTML Sitemap
foreach( get_post_types( array('public' => true) ) as $post_type ) {
if ( in_array( $post_type, array('post','page','attachment') ) )
continue;

$pt = get_post_type_object( $post_type );

echo '<h2>'.$pt->labels->name.'</h2>';
echo '<ul>';

query_posts('post_type='.$post_type.'&posts_per_page=-1');
while( have_posts() ) {
the_post();
echo '<li><a href="'.get_permalink().'">'.get_the_title().'</a></li>';
}

echo '</ul>';
}
?>
</ul>

拷贝一份当前主题下面的page.php，并重新命名为page-sitemap.php,编辑内容如下：

<?php
/*
Template Name: Sitemap Page
*/
?>
<?php get_header(); ?>
<div id="content">
<?php if (have_posts()) : ?><?php while (have_posts()) : the_post(); ?>
<!-- menu -->
<div id="map">
<div class="browse">现在位置 ＞<a title="返回首页" href="<?php echo get_settings('Home'); ?>/">首页</a> ＞<?php the_title(); ?></div>
<div id="feed"><a href="<?php echo get_option('swt_rsssub'); ?>" title="RSS">RSS</a></div>
</div>
<!-- end: menu -->
<!-- entry -->
<div class="clear"></div>
<div class="entry_box_s">
<div class="entry">
<div class="page" id="post-<?php the_ID(); ?>">
<?php the_content('More &raquo;'); ?>
<div class="clear"></div>
</div>
<?php get_template_part('/partials/sitemap'); ?>
</div>
<!-- end: entry -->
<div class="clear"></div>
<i class="lt"></i>
<i class="rt"></i>
</div>
<div class="entry_sb">
<i class="lb"></i>
<i class="rb"></i>
</div>
<?php endwhile; ?>
<?php endif; ?>
</div>
<!-- end: content -->
<?php get_sidebar(); ?>
<?php get_footer(); ?>

主要修改两个地方，一个是在文件的顶部加入

Sitemap

Sun, 24 Jun 2012 11:42:01 +0000

Android ListView 之瀑布流设计

Thu, 21 Jun 2012 17:08:45 +0000

谈论起瀑布流，相信大家不怎么陌生，实际上现在好多的网站都已经按照这种风格设计了，简言之就是按需加载，先加载一屏的内容，当用户向下滚动到页面底部的时候，继续加载一屏的内容，就这样，一直循环往复，用户浏览多少，加载多少！

在Android ListView的设计中，就可以很好的融合这种设计方法，本文就简单介绍一种方法来实现瀑布流的功能，进入程序主界面的时候先加载一部分内容，然后当用户向下滚到到底部的时候继续加载，用户向下继续滚到，则继续加载，一直到内容加载完毕。

本文的程序设计思路来自于 cwac-endless，其功能介绍如下：

Provides the EndlessAdapter, a wrapper for an existing ListAdapter that adds “endless list” capability. When the user scrolls to the bottom of the list, if there is more data for this list to be retrieved, your code gets invoked in a background thread to fetch the new rows, which then get seamlessly attached to the bottom of the list.

代码的实现还依赖于另一个开发包 cwac-adapter,其功能介绍如下:

Provides an AdapterWrapper, a simple wrapper class that, by default, delegates all ListAdapter methods to a wrapped ListAdapter. The idea is that you can extend AdapterWrapper and only override certain ListAdapter methods, with the rest handled via the wrapped adapter.

Android 配置 Ant 脚本之代码混淆和优化

Wed, 20 Jun 2012 17:49:35 +0000

本文的目的是介绍怎么样配置android的ant自动化编译脚本，来实现编译发布版本时代码的混淆和代码的优化，利用的主要工具包括ant和proguard。

编译环境

ant 版本 1.8.4

F:\workspace\eReader>ant -version
Apache Ant(TM) version 1.8.4 compiled on May 22 2012

java 版本 1.7

F:\workspace\eReader>java -version
java version "1.7.0_05"
Java(TM) SE Runtime Environment (build 1.7.0_05-b05)
Java HotSpot(TM) Client VM (build 23.1-b03, mixed mode, sharing)

文件配置

因为 Android 已经内置了 proguard 的支持，所以我们只需要进行配置启用该功能即可。

生成 build.xml 文件

F:\workspace\eReader>android update project -p .

配置 local.properties 文件 sdk.dir会自动指向当前系统android的开发环境路径，key.store和key.alias分别指向签名文件和签名文件的别名，这个需要自己制作，主要是release的时候需要使用

sdk.dir=E:\\PROGRA~1\\android-sdk-windows

key.store=F:\\Android\\android_key\\careychow.keystore
key.alias=Carey

配置 build.xml 文件配置签名算法为 SHA1

 <?xml version="1.0" encoding="UTF-8"?>
 <project name="GAReader" default="help">
     .... 此处省略若干

     <presetdef name="signjar">
         <signjar sigalg="MD5withRSA" digestalg="SHA1" />
     </presetdef>

 </project>

自动化编译

执行编译命令 ant release

   F:\workspace\eReader>ant release

输入签名密钥的密码和签名别名的密码进行签名

   ......
   -release-prompt-for-password:
    [input] Please enter keystore password (store:F:\Android\android_key\careych
ow.keystore):
careychow
    [input] Please enter password for alias 'Carey':
careychow
   ......
-release-sign:
     [echo] Signing final apk...
  [signjar] Signing JAR: F:\workspace\eReader\bin\GAReader-release-unsigned.apk
to F:\workspace\eReader\bin\GAReader-release-unaligned.apk as Carey
  [signjar] 输入密钥库的密码短语:
 [zipalign] Running zip align on final apk...
     [echo] Release Package: F:\workspace\eReader\bin\GAReader-release.apk
[propertyfile] Updating property file: F:\workspace\eReader\bin\build.prop
[propertyfile] Updating property file: F:\workspace\eReader\bin\build.prop
[propertyfile] Updating property file: F:\workspace\eReader\bin\build.prop
[propertyfile] Updating property file: F:\workspace\eReader\bin\build.prop

-post-build:

release:

BUILD SUCCESSFUL
Total time: 1 minute 36 seconds

常见错误

去除 proguard 的警告信息，尤其在自己引用第三方library的时候，代码混淆的过程中，proguard分析当前所有的类库，会警告有些类或者方法无法识别，因为这些都是第三方library自己编译的，我们无法再去找它所依赖的其他包，只需要配置忽略这些警告即可，方法如下：配置 proguard.cfg 文件，在文件的最后加上要忽略的类

  ......
-dontwarn java.awt.**,antlr.**,org.junit.**,jargs.gnu.**

解决签名错误 INSTALL_PARSE_FAILED_NO_CERTIFICATES 目前在JDK7的版本和ant1.8.4会出现这个问题，如果不指明所使用的签名算法，则APK就无法正确签名，在安装的过程中就会出现如上的错误信息，解决办法就是在build.xml中指明签名算法。还有另外的解决方法，可参照如下文章： http://stackoverflow.com/questions/8036422/android-signing-with-ant http://stackoverflow.com/questions/9820769/why-does-adb-fail-with-failure-install-parse-failed-no-certificates

总结

配置和启用的过程倒是不复杂，主要就是出现的一些版本兼容问题比较难解决，好了，内容就讲解这么多！

Wordpress中实用的SQl语句

Tue, 05 Jun 2012 13:40:10 +0000

利用wordpress搭建个人博客比较方便，有时候会涉及到博客内容的批量变更，本文分享几个有效的sql语句来方便的进行内容更新。

数据库备份

在做具体的修改以前，建议先备份数据库，phpMyAdmin备份步骤如下：

Login to your phpMyAdmin.
Select your WordPress database.
Click on Export at the top of the navigation.
Select the tables you want to backup, or select all tables to backup the whole database.
Select SQL to export as .sql extension.
Check the “Save as file” checkbox.
Choose compression type, select gzipped to compress the database to a smaller size.
Finally click Go, and a download window will prompt you to save your backup database file.

实用SQL语句

变更博客网址 Siteurl & Homeurl

FLV格式流媒体的缓存渐进拖放原理

Sat, 02 Jun 2012 20:21:23 +0000

前几天讲解了mp4格式文件的解析，边缓存边播放，拖动处理，faplayer的编译等等，可以查看我的《Android系列专题文章》，本文给大家介绍flv格式文件的缓存渐进拖放原理。

flv是Adobe公司提出来的一种视频存储格式，因为其压缩的效果比较好，容量小，所以很适合网络传播，这也就是国外的youtube，国内的优酷，土豆等等都无一类外的采用flv格式来进行存储，有关flv格式的具体内容可以参照 Flash Video 和 osflash。

flv是采用一种tag的数据结构进行流媒体数据的存储，首先是文件头，接下来是可选的meta信息，再后面就是音频和视频数据的交替存储，比起来mp4文件庞大的文件头，flv的文件头基本可以忽略了，只有9个字节，meta部分存储一些音视频解码和长度等的一些信息，具体的音频和视频的tab部分存储实际的流媒体数据。

mp4文件之所以能边缓存边播放，并且可以支持跳转，原因是文件头存储了视频整体的信息，像视频的总时长，关键帧，对应的时间轴，对应的文件偏移量等等，有了这些信息，就能实现在视频全部下载完毕之前就支持跳转播放，如果mp4的文件头放在了文件末端，那么该文件就不支持缓存跳转播放了，只有等待文件全部下载完毕之后才能进行播放，具体怎么样将文件头重新提取到头部，我博客专题的文章中有写，可以参照。

同理，flv文件的meta信息是可选的，如果这部分数据没有存储关键帧，时间轴和文件偏移量，那么该flv文件在全部缓存完毕之前是不支持跳转播放的，那么，大家可能会很奇怪，优酷，土豆看了这么久，所有的视频都是可以拖动跳转的，那么具体的原因是什么，下面我给大家详细解释。

首先大家先了解下什么是flv meta 注入，意思就是通过解析当前flv文件的音视频tag，然后根据这些流媒体数据来生成关键帧，时间轴和偏移量的信息，然后将这些信息重置到该flv文件的meta部分，这样就能够使不支持拖动播放的flv文件变得支持拖动播放了，实际上优酷的做法就是这样，用户上传的视频动态转码成flv格式，并且通过扫描和解析flv文件，进行meta注入，最后我们在网上播放的视频就是处理过的视频。实现flv注入，有两个工具可以使用，具体可以参照 flvmdi 和 FLVTool2。

接下来我用win版本的flvtool来分析一段优酷的视频（谢霆锋热血微电影），解析到的meta信息如下：

---
C:/Users/Administrator/Desktop/flvtool2.exe -P test.flv
  hasKeyframes: true
  hasVideo: true
  framerate: 15
  audiosamplerate: 22050
  hasAudio: true
  height: 288
  metadatacreator: modified by youku.com in 20111202
  keyframes: 
    times: 
      - 0
      - 0
      - 6
      - 12
      - 18
      - 24
      - 25.6666666666667
      - 26.7333333333333
      - 28.3333333333333
      - 30.2666666666667
      // 省略部分
      - 193.866666666667
      - 199.866666666667
      - 205.866666666667
    filepositions: 
      - 1400
      - 1494
      - 98389
      - 205673
      - 312032
      - 422862
      - 438242
      - 495063
      - 555999
      - 695882
      // 省略部分
      - 7259084
      - 7426324
      - 7538447
  duration: 210.066666666667
  hasMetadata: true
  width: 512
...

通过分析上面的meta信息，我们可以得到该视频的播放尺寸为512*288，视频的总时长约为210s，也就是3分半钟，从keyframes中可以解析得到关键帧对应的时间轴和对应的文件文件偏移量，有了这些信息，就能让该视频支持缓存跳转播放了，还有一句话，大家注意“metadatacreator: modified by youku.com in 20111202”，这是优酷在进行视频处理的时候填入的制作者信息。

Java PHP Json Mysql 中文乱码问题之解决

Fri, 01 Jun 2012 11:15:55 +0000

问题

客户端采用Java语言编写，服务器端采用PHP语言编写，数据库采用Mysql存储，客户端和服务器之间的交互采用Json，在传递英文数据的时候没有问题，当传递中文数据数据的时候，就会出现中文乱码问题，mysql里面的中文全部变成问号了。

解决方案

Mysql数据库，数据表，数据字段采用统一编码UTF-8, 如 utf8_general_ci
客户端Java字符串转成json格式的时候先进行urlencode处理

JSONObject jo = new JSONObject();
//jo.accumulate("note", note);
jo.accumulate("note", URLEncoder.encode(note));

服务器端PHP转换json格式后，插入数据库前先进行urldecode处理

$data = array(
    'meta_key' => 'note',
    //'meta_value' => $params['note'],
    'meta_value' => urldecode($params['note']),
);

经过以上的步骤处理，可完美解决中文乱码问题

三星 S5830i 安装谷歌同步服务

Wed, 30 May 2012 13:58:52 +0000

三星 S5830i 手机的root和安装google市场可以参看系列文章《三星S5830i安装谷歌服务》，本文介绍在此基础上安装谷歌的同步服务，具体包括通讯录同步，邮件同步和日历同步，安装方法如下。

安装顺序

下载 GoogleMobileService(GMS)谷歌移动服务(2.3.4).zip，这是Android版本2.3的GMS服务包，里面包括了基本的google服务APP，不过我们不用那么多，只需要GoogleContactsSyncAdapter.apk, GoogleCalendarSyncAdapter.apk 和 Gmail.apk 就够了。
将解压后得到的3个APK放到系统目录*/system/app*中，然后重启手机进行自动安装
配置账户同步，勾选账户，日历和邮件同步的选项，稍等一会儿，所有的通讯录，日历和邮件就都同步ok了
这样的话，基本所有的google服务就都具备了，以后涉及到google其他的APP都木有问题了
如果还想安装其他的google app，方法同上，有的只能安装到系统目录中，即/system/app下，有的可以按照普通的方法进行安装，视具体情况而定

三星 S5830i 安装谷歌市场 Google Market

Wed, 30 May 2012 09:31:07 +0000

前几天刚把三星S5830i Root过了，现在操作起来顺畅多了，还有一个待解决的问题就是没有google服务，没法安装google market，本文就介绍怎么样在手机没有内置google服务的基础上来自己安装，国内好多的定制行货手机都被裁剪掉了，真搞不懂为什么？？？好了，接下来介绍一下安装顺序，前提是你的手机已经root过了，具体怎么样root可以参照文章《三星 S5830i root》。

安装顺序

下载 google 服务包，里面包括 GoogleServicesFramework.apk 和 Vending.apk，注意我的三星手机目前的android版本是2.3.6，所以该谷歌服务适用于2.3，其他的版本我还没有测试过，不过装了也不会出现什么副作用，可以试试，点我下载。
将上面已经下载的两个APK放置到 /system/app 目录中，然后关机重启进行自动安装，安装以后提示google market应用升级，然后自动升级到google play store，截图如下
接下来打开play store应用绑定Google账户，填写正确的google账户信息，绑定完了就ok了，截图如下：
欧了，现在就可以利用play store进行apk安装和升级了，随心所欲的利用google服务

Android 流媒体播放之缓冲跳转实现

Tue, 29 May 2012 14:06:09 +0000

前几篇文章分析了mp4文件的格式和文件的解析，以及视频边缓冲边播放的原理讲解与代码实现，具体可以参看 Android视频播放专题系列文章的讲解，本文就展示一下缓冲跳转代码的实现原理。

先分享一下4幅图片，分别为播放前的缓存，正常播放中，跳转缓冲和跳转以后的正常播放。

代码解析

视频断点分隔的数据结构定义定义了每一段视频的时间偏移点，文件位移偏移点，文件段的大小和当前的缓存状态

class VideoInfo {
        double timestart;
        long offsetstart;
        long offsetend;
        long downloadsize;
        DownloadStatus status;

        public VideoInfo() {
            status = DownloadStatus.NOTSTART;
        }

        @Override
        public String toString() {
            String s = "beginTime:

缓存状态的定义分别为还未缓存，正在下载中和缓存完毕

    enum DownloadStatus {
        NOTSTART, DOWNLOADING, FINISH,
    }

分段视频的下载利用了Http协议的 Range 属性，下载部分文件

private void downloadbyvideoinfo(VideoInfo vi) throws IOException {
        System.out.println("download -> " + vi.toString());

        URL url = new URL(this.url);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setConnectTimeout(3000);
        conn.setRequestProperty("Range", "bytes=" + vi.offsetstart + "-"
                + vi.offsetend);

        RandomAccessFile raf = new RandomAccessFile(new File(localFilePath),
                "rws");
        raf.seek(vi.offsetstart);

        InputStream in = conn.getInputStream();

        byte[] buf = new byte[1024 * 10];
        int len;
        vi.downloadsize = 0;
        while ((len = in.read(buf)) != -1) {
            raf.write(buf, 0, len);
            vi.downloadsize += len;
            Message msg = handler.obtainMessage();
            msg.what = MSG_DOWNLOADUPDATE;
            msg.obj = vi.offsetstart + vi.downloadsize;
            handler.sendMessage(msg);
        }

        in.close();
        raf.close();
    }

检测指定时间点的视频数据是否已经缓存完毕

VPN设置推荐

Mon, 28 May 2012 19:13:54 +0000

相信有不少童鞋希望找到国外的资源，神马在线代理了，ssh了，vpn了等等，本人也因为喜欢搜索和使用国外的资源，所以经常使用这些东西，使用时间最久的算是goagent，自己在google的gae上面搭建一个代理，利用google的免费服务，查个资料了什么的也足够用了。本文向读者推荐另一个比较稳定的vpn服务，本人也实测了一下，看视频很流畅，截图如下：

申请流程

点击我进入申请页面
在 E-MAIL 一栏中填写自己的邮箱，然后勾选同意注册条款的方框，点击最下面的粉色按钮进入下一步
在这一步中什么也不需要做，只是一些确认条款，直接再点击粉色的按钮进入下一步
在这一步中需要确认邮箱，直接点击粉色的按钮发送确认信即可
稍后在邮箱中会收到一封激活信件，点击链接激活即可
激活后，邮箱会收到一封vpn的账户密码和ip地址信息，账户就是你注册的邮箱地址，密码是一个随机字符串，例如：

    本登録しました。

    接続IDとパスワードは以下の通りです。

    接続ID     xxx@gmail.com
    パスワード  npPPUaYI
    VPNサーバ  49.212.0.54

在电脑中配置新建立vpn链接并激活即可，不想用的时候关闭即可。激活以后的截图如下：
好了，现在可以欣赏外面的世界了

编译 faplayer 播放器

Sat, 26 May 2012 13:17:31 +0000

最近在做一个有关视频播放的项目，涉及到的问题就是视频解码，目前最优秀的两套解码库就是ffmpeg和flv，几乎现在能见到的所有视频格式都能解码，本文编译的faplayer就是基于flv的解码库。

编译成功的程序可以正常播放优酷的flv格式，截图如下：

环境配置

Android SDk 参见 http://developer.android.com/sdk/index.html
Android NDk 参见 http://developer.android.com/sdk/ndk/index.html
环境变量配置如下（~/.bashrc）：

   export ANDROID_SDK=/home/careychow/android/sdk/android-sdk-linux
   # export ANDROID_NDK=/home/careychow/android/ndk/android-ndk-r8
   export ANDROID_NDK=/home/careychow/android/ndk/android-ndk-r5c
   export PATH=$PATH:$ANDROID_SDK/tools:$ANDROID_SDK/platform-toos:$ANDROID_NDK

注：faplayer 利用 android-ndk-r5c 编译，用 android-ndk-r8 编译会出现错误

安装ruby环境，推荐安装ruby1.9.2

sudo apt-get install ruby

手机CPU类型检测

我自己的三星s5830i cpu 信息如下

    C:\Users\Administrator>adb shell cat /proc/cpuinfo
    Processor       : ARMv6-compatible processor rev 5 (v6l)
    BogoMIPS        : 832.90
    Features        : swp half thumb fastmult vfp edsp java
    CPU implementer : 0x41
    CPU architecture: 6TEJ
    CPU variant     : 0x1
    CPU part        : 0xb36
    CPU revision    : 5

    Hardware        : BCM21553 ThunderbirdEDN31 platform
    Revision        : 0000
    Serial          : 0000000000000000

编译 faplayer

下载代码

 git clone https://github.com/tewilove/faplayer.git

配置 local.properties 指向android sdk的安装路径，我的配置是：

 sdk.dir=/home/careychow/android/sdk/android-sdk-linux

配置编译参数并编译代码，具体的配置需要参照上面的cpu信息，如果类型不匹配，编译出来的apk是无法正常安装的，会出现 **Failure [INSTALL_FAILED_CPU_ABI_INCOMPATIBLE]**错误，我的手机不支持neon，所以采用第二个配置参数 ABI=armeabi，可正常安装和执行

Build examples:
./build.sh # <-- this will build for cortex-a8 with neon by default.
./build.sh ABI=armeabi # <-- this will build for arm1136j-s with softfp.
./build.sh ABI=armeabi-v7a FPU=vfpv3-d16 TUNE=cortex-a9 # <-- Xoom

生成 APK

 ant debug

命令后会在bin文件夹下面生成 faplayer-debug.apk  **注**：如果提示build.xml文件过期，则可用如下命令修复

 android update project -p .

三星 S5830i root

Sat, 26 May 2012 11:34:40 +0000

手机不root太不方便了，尤其三星手机内置了太多APP，给自己装APP的空间太小了，不够用，装几个工具软件就满了，木有办法，还是root吧，root以后调试程序也方便。

root 过程

1. 下载root刷机包：update.zip
1. 不要解压直接将update.zip拷贝到SD卡根目录

adb push update.zip /mnt/sdcard/

1. 关机后，同时按音量+键、HOME键（功能键）、开机键，出现三星的logo之后，同时放开，进入Recovery模式
1. 用音量键上下移动选择：apply update from sdcard，按HOME键（功能键）进入SD卡目录，选择update.zip文件，再按HOME键盘确定更新，更新完成后重启
1. 重启后看到已经安装的授权管理程序，说明已经root成功
1. 使用豌豆夹或者SystemAPP卸载系统那些定制的内置APP
1. 自己装几个实用的APP，并将安装路径选择到SD卡上，这样舒服多了

Android 视频播放之流媒体解析

Tue, 22 May 2012 16:04:15 +0000

最近做的一个项目需求是要实现视频的边缓存边播放，还要能实现视频内部的跳转，实际来讲就是视频点播，只不过要通过http协议来实现，也即用户可以拖动seekbar跳转到播放指定时间点的视频，要实现这样的功能，那么就需要提前解析视频的关键信息，得到时间点对应的视频流的内部偏移量，这样当进行实际跳转的时候就能根据跳转的时间点转换到文件内部的偏移量，进而进行视频流内容的缓存下载。

至于如何实现视频的边缓存边播放，可以参照我的博文《Android视频播放之边缓存边播放》和《Android 视频播放之流媒体格式处理》，本文的目的是给大家展示怎么样进行视频数据流的解析.

前期准备

依赖的第三方解析包 mp4parser，Google的项目地址为 http://code.google.com/p/mp4parser/,它主要实现了mp4和其他格式媒体数据的解析，本文的解析代码就是依赖于它底层的数据解析，项目中有一个图形化界面的解析器，下载地址为

http://mp4parser.googlecode.com/files/isoviewer-2.0-RC-7.jar，可以通过它来查看视频文件的整体编码结构。

通过在命令行执行

F:\workspace\mp4parser-read-only>java -jar isoviewer-2.0-RC-7.jar

![](/wp-content/uploads/2012/05/parse_mp4.png)

来启动程序，然后通过菜单的File导入需要解析的视频文件就好了截图如下：本文代码依赖的jar包如下：

关键代码解析

计算视频的总时长

视频的总时间轴 Duration 除以时间轴的比例 Timescale，结果就是当前视频的总秒数

lengthInSeconds = (double) isoFile.getMovieBox().getMovieHeaderBox().getDuration() / isoFile.getMovieBox().getMovieHeaderBox().getTimescale();

获取音频和视频的box数据

一般的流媒体数据有两个TrackBox，第一个为音频，第二个为视频

List<TrackBox> trackBoxes = isoFile.getMovieBox().getBoxes(TrackBox.class);

解析视频的box数据

取得关键帧的信息，因为视频的跳转只能在关键帧之间跳转，所以我们需要重点关注关键帧对应的时间点

Iterator<TrackBox> iterator = trackBoxes.iterator();

SampleTableBox stbl = null;
TrackBox trackBox = null;
while (iterator.hasNext()) {
  trackBox = iterator.next();
  stbl = trackBox.getMediaBox().getMediaInformationBox().getSampleTableBox();
  // 我们只处理视频的关键帧，音频数据略过
  if (stbl.getSyncSampleBox() != null) {
    syncSamples = stbl.getSyncSampleBox().getSampleNumber();
    syncSamplesSize = new long[syncSamples.length];
    syncSamplesOffset = new long[syncSamples.length];
    timeOfSyncSamples = new double[syncSamples.length];
    break;
  }
}

获取视频box中内部的详细参数

包括帧与时间的对应关系，即每一帧对应视频的时间点是第几秒，帧与chunk的对应关系，mp4为了进行视频的压缩，都是把一系列连续的帧放到一个chunk中，每个chunk中帧的数量不等，chunk与数据流文件偏移的关系，即每个chunk对应的视频流数据在文件的具体偏移位置。

谷歌搜索

Sat, 19 May 2012 17:35:23 +0000

谷歌搜索

Android 视频播放之流媒体格式处理

Sat, 19 May 2012 16:13:59 +0000

格式编码

项目的需求要实现流媒体的播放，简言之就是视频可以支持边下载边播放。鉴于MP4/h.264编码的优势，视频采用MP4文件格式存储，因为mp4只是一个存储的规范，像国内的优酷主要采用flv文件格式，其内部也是MP4编码，flv是 Adobe 支持的格式，这样的话，不论是在网站端，通过pc浏览器浏览，借助于 Flash Player，还是手持设备，借助于 ffmpeg 的解码库，都能实现视频的无缝播放，算是一个比较完美的解决方案。

在实际视频的处理中，发现一个问题，利用Android手机自己拍摄录制的视频，可以完美支持边下载边播放，通过Iphone手机录制的视频，然后转码成mp4格式的视频就不能支持边下载边播放了，问题困扰了两三天，没办法，开始研究mp4的存储格式，最后终于找到了问题的所在。

了解mp4格式的应该知道，mp4是采用一种box数据结构来存储视频数据的，理想的情况是，box的顺序为ftyp，moov，free和mdat，通过moov的解析就能获取该视频的关键信息，比如播放时长，关键帧数，sample存储情况，在mdat中对应的编码数据偏移量等等。这样只要视频缓存完头部信息，即moov之后，就能知道当前视频的关键数据了，随着mdat的逐渐下载，就能完美实现视频的边缓存边播放，具体的实例教程请参见我的博文《Android视频播放之边缓存边播放》。

但是通过第三方软件的编码转换，有的就把moov放置到mdat之后了，这样只有把视频全部下载完成之后才能获取该视频的关键信息，才能开始播放，理论上也就没法实现视频的边缓存边播放，找到问题的关键点之后，就开始寻找解决办法，终于找到qt-faststart，它能解析原视频格式，并将moov信息尽可能的提前，这样就能及早解析和播放视频了。

格式转换

下载地址：

我使用的是window的客户端，使用命令如下：

Usage: qt-faststart （转换前的视频文件） (转换后的视频文件)

参考文章

Android视频播放之边缓存边播放

Sun, 13 May 2012 17:23:00 +0000

最近在做Android视频播放的有关项目，其中有一项需求就是要求视频可以边加载缓存边播放，类似于优酷土豆的视频点播。网上找了一些相关的资料，比较了每种视频格式的优缺点之后，结合Android手机自身的优势，默认支持mp4编码和解码，最终采用mp4格式作为视频的存储格式。

其实最真实的流媒体协议传输格式并不是普通的http方式，而是rtsp，那样的话得搭建专门的流媒体服务器，成本比较高，采用普通的http方式，实现的是一种伪流媒体传输，但是对于常用的视频缓存播放也足够了。

要想实现视频的边缓存边播放，原则上就要求视频的存储格式是分段的，而mp4正好满足这个要求，只要将mp4的整体视频信息放在mp4文件的开头，这样只要加载了mp4文件的头部之后，就能解析出该mp4文件的时长，比特率等等，为后续的视频缓存做初始化设置，然后每加载一段mp4文件的数据流，通过解析头部来或得当前视频流的帧信息，并在播放器中播放，这样就能先加载一段进行播放，同时缓存后续的一段，依此原理就能实现。

本文的目的就是给大家介绍一种以此原理而开发一个Android视频边缓存边播放的示例，通过该示例的学习，相信大家能对该原理有更深入的理解。

在介绍具体的demo之前，先放上几张截图，分别为视频播放前的缓存，视频边缓存边播放，缓存完毕的视频播放。

代码解析

VideoViewDemo.java 主要是用来设置启动参数，设定网络视频的url地址和本地缓存的地址，本地缓存的地址可以不设置，程序会自己维护，如果您自己设置了，视频就会缓存到该位置。

public class VideoViewDemo extends Activity {
    @Override
    public void onCreate(Bundle icicle) {
    super.onCreate(icicle);

    //String url = "http://carey-blog-image.googlecode.com/files/vid_20120510_090204.mp4";
    String url = "http://bbfile.b0.upaiyun.com/data/videos/2/vid_20120510_090204.mp4";

    Intent intent = new Intent();
    intent.setClass(VideoViewDemo.this, BBVideoPlayer.class);
    intent.putExtra("url", url);
    intent.putExtra("cache",
            Environment.getExternalStorageDirectory().getAbsolutePath()
                    + "/VideoCache/" + System.currentTimeMillis() + ".mp4");
    startActivity(intent);
}

}

BBVideoPlayer.java 就是视频缓存的核心了，READY BUFF定义了初始缓存区的大小，当视频加载到初始缓存区满的时候，播放器开始播放，CACHE

BUFF则是核心交换缓存区，主要是用来动态调节缓存区，当网络环境较好的时候，该缓存区为初始大小，当网络环境差的时候，该缓存区会动态增加，主要就是为了避免视频播放的时候出现一卡一卡的现象。

public class BBVideoPlayer extends Activity {

private VideoView mVideoView;
private TextView tvcache;
private String remoteUrl;
private String localUrl;
private ProgressDialog progressDialog = null;

private static final int READY_BUFF = 2000 * 1024;
private static final int CACHE_BUFF = 500 * 1024;

private boolean isready = false;
private boolean iserror = false;
private int errorCnt = 0;
private int curPosition = 0;
private long mediaLength = 0;
private long readSize = 0;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.bbvideoplayer);

    findViews();
    init();
    playvideo();
}

private void findViews() {
    this.mVideoView = (VideoView) findViewById(R.id.bbvideoview);
    this.tvcache = (TextView) findViewById(R.id.tvcache);
}

private void init() {
    Intent intent = getIntent();

    this.remoteUrl = intent.getStringExtra("url");
    System.out.println("remoteUrl: " + remoteUrl);

    if (this.remoteUrl == null) {
        finish();
        return;
    }

    this.localUrl = intent.getStringExtra("cache");

    mVideoView.setMediaController(new MediaController(this));

    mVideoView.setOnPreparedListener(new OnPreparedListener() {

        public void onPrepared(MediaPlayer mediaplayer) {
            dismissProgressDialog();
            mVideoView.seekTo(curPosition);
            mediaplayer.start();
        }
    });

    mVideoView.setOnCompletionListener(new OnCompletionListener() {

        public void onCompletion(MediaPlayer mediaplayer) {
            curPosition = 0;
            mVideoView.pause();
        }
    });

    mVideoView.setOnErrorListener(new OnErrorListener() {

        public boolean onError(MediaPlayer mediaplayer, int i, int j) {
            iserror = true;
            errorCnt++;
            mVideoView.pause();
            showProgressDialog();
            return true;
        }
    });
}

private void showProgressDialog() {
    mHandler.post(new Runnable() {

        @Override
        public void run() {
            if (progressDialog == null) {
                progressDialog = ProgressDialog.show(BBVideoPlayer.this,
                        "视频缓存", "正在努力加载中 ...", true, false);
            }
        }
    });
}

private void dismissProgressDialog() {
    mHandler.post(new Runnable() {

        @Override
        public void run() {
            if (progressDialog != null) {
                progressDialog.dismiss();
                progressDialog = null;
            }
        }
    });
}

private void playvideo() {
    if (!URLUtil.isNetworkUrl(this.remoteUrl)) {
        mVideoView.setVideoPath(this.remoteUrl);
        mVideoView.start();
        return;
    }

    showProgressDialog();

    new Thread(new Runnable() {

        @Override
        public void run() {
            FileOutputStream out = null;
            InputStream is = null;

            try {
                URL url = new URL(remoteUrl);
                HttpURLConnection httpConnection = (HttpURLConnection) url
                        .openConnection();

                if (localUrl == null) {
                    localUrl = Environment.getExternalStorageDirectory()
                            .getAbsolutePath()
                            + "/VideoCache/"
                            + System.currentTimeMillis() + ".mp4";
                }

                System.out.println("localUrl: " + localUrl);

                File cacheFile = new File(localUrl);

                if (!cacheFile.exists()) {
                    cacheFile.getParentFile().mkdirs();
                    cacheFile.createNewFile();
                }

                readSize = cacheFile.length();
                out = new FileOutputStream(cacheFile, true);

                httpConnection.setRequestProperty("User-Agent", "NetFox");
                httpConnection.setRequestProperty("RANGE", "bytes="
                        + readSize + "-");

                is = httpConnection.getInputStream();

                mediaLength = httpConnection.getContentLength();
                if (mediaLength == -1) {
                    return;
                }

                mediaLength += readSize;

                byte buf[] = new byte[4 * 1024];
                int size = 0;
                long lastReadSize = 0;

                mHandler.sendEmptyMessage(VIDEO_STATE_UPDATE);

                while ((size = is.read(buf)) != -1) {
                    try {
                        out.write(buf, 0, size);
                        readSize += size;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                    if (!isready) {
                        if ((readSize - lastReadSize) > READY_BUFF) {
                            lastReadSize = readSize;
                            mHandler.sendEmptyMessage(CACHE_VIDEO_READY);
                        }
                    } else {
                        if ((readSize - lastReadSize) > CACHE_BUFF
                                * (errorCnt + 1)) {
                            lastReadSize = readSize;
                            mHandler.sendEmptyMessage(CACHE_VIDEO_UPDATE);
                        }
                    }
                }

                mHandler.sendEmptyMessage(CACHE_VIDEO_END);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (out != null) {
                    try {
                        out.close();
                    } catch (IOException e) {
                        //
                    }
                }

                if (is != null) {
                    try {
                        is.close();
                    } catch (IOException e) {
                        //
                    }
                }
            }

        }
    }).start();

}

private final static int VIDEO_STATE_UPDATE = 0;
private final static int CACHE_VIDEO_READY = 1;
private final static int CACHE_VIDEO_UPDATE = 2;
private final static int CACHE_VIDEO_END = 3;

private final Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
        case VIDEO_STATE_UPDATE:
            double cachepercent = readSize * 100.00 / mediaLength * 1.0;
            String s = String.format("已缓存: [%.2f%%]", cachepercent);

            if (mVideoView.isPlaying()) {
                curPosition = mVideoView.getCurrentPosition();
                int duration = mVideoView.getDuration();
                duration = duration == 0 ? 1 : duration;

                double playpercent = curPosition * 100.00 / duration * 1.0;

                int i = curPosition / 1000;
                int hour = i / (60 * 60);
                int minute = i / 60 % 60;
                int second = i % 60;

                s += String.format(" 播放: %02d:%02d:%02d [%.2f%%]", hour,
                        minute, second, playpercent);
            }

            tvcache.setText(s);

            mHandler.sendEmptyMessageDelayed(VIDEO_STATE_UPDATE, 1000);
            break;

        case CACHE_VIDEO_READY:
            isready = true;
            mVideoView.setVideoPath(localUrl);
            mVideoView.start();
            break;

        case CACHE_VIDEO_UPDATE:
            if (iserror) {
                mVideoView.setVideoPath(localUrl);
                mVideoView.start();
                iserror = false;
            }
            break;

        case CACHE_VIDEO_END:
            if (iserror) {
                mVideoView.setVideoPath(localUrl);
                mVideoView.start();
                iserror = false;
            }
            break;
        }

        super.handleMessage(msg);
    }
};
}

总体来说，原理比较简单，就是把视频加载了一段后，就送到播放器播放，如果出现了错误，则优先缓存一部分文件，然后再继续播放，类似的处理过程循环往复。

服务器端API设计之JSONP

Wed, 18 Apr 2012 15:38:26 +0000

最近设计项目的服务器端API，起初的设想是客户端采用XML的格式发送数据，然后服务器端返回JSON格式的数据，中间的通信过程采用JS的Ajax机制。

项目初步测试也已通过，功能实现上面倒是没有问题，唯一的缺点就是AJax的跨域通信，想了解更多的关于json，jsonp，ajax和跨域通信的知识可以参照下面的网址：

现在准备花一点时间，把基于json通信的代码全部迁移为基于jsonp通信，这样就能彻底解决了跨域通信的问题，也更方便API的编写，做了调查和了解之后，发现其实代码的改动非常小，示例代码如下：服务器端的代码：

客户端传入的xml文件的解析

private function parseInputData()
{
    $params = array();
    if ( $_SERVER['REQUEST_METHOD'] === 'POST' )
    {
        $input = trim(file_get_contents('php://input'));
        import("@.ORG.Util");
        $params = xml_to_array($input);
    } else {
        $input = trim($_REQUEST['params']);
        import("@.ORG.Util");
        $params = xml_to_array($input);
   }
   return $params;
}

给客户端返回json/jsonp格式的处理数据

if(strtoupper($type)=='JSON') {
   if (isset($_REQUEST['callback'])) {
      // 返回JSONP数据格式到客户端
      header('Content-Type:text/javascript; charset=utf-8');
      exit($_REQUEST['callback'] . '(' . json_encode($result) . ');');
   } else {
     // 返回JSON数据格式到客户端
     header('Content-Type: application/x-json; charset=utf-8');
     exit(json_encode($result));
   }
}

客户端的代码：

利用GitHub Pages安装部署Octopress博客

Sun, 15 Apr 2012 19:59:49 +0000

周末闲来无事，学习了一下怎样利用github pages来建立自己的博客，现在比较成熟的博客系统是 Octopress，关于其详细的介绍可以参见官方文档，本文建立的博客页面已经绑定到了 zhourunsheng.com 域名，可以查看博客的效果！

1. github page 的建立

要想在github上面建立自己的博客，首先需要建立page，可以参考官方的文档 http://help.github.com/pages/，简单来说，比如我的github账户名称是careychow，那么需要建立一个 careychow.github.com 的 repository，将博客的静态页面上传到该repository的master分支中，当通过浏览器访问 http://careychow.github.com的时候，github服务器就会将其中博客页面展示出来。

2. 搭建 Octopress 本地环境

linux 环境的搭建可以参见官方文档 http://octopress.org/docs/setup/因为我自己通常都在win7下面办公，所以下面介绍一下win7环境下 Octopress 的搭建和部署 a. 安装 git，下载地址：msysgit，最新版本 Git-1.7.10-preview20120409.exe，详细参见 http://help.github.com/win-set-up-git/b.安装 ruby，下载地址:RubyInstaller，安装版本 rubyinstaller-1.9.2-p290.exe，注意版本是1.9.2 c. 安装gem编译环境，下载地址：DevKit-tdm-32-4.5.2-20111229-1559-sfx.exe，下载完成后，将其解压到如 E:\DevKit，然后在win的cmd窗口中执行如下命令进行安装：

cd E:\DevKit
ruby dk.rb init
ruby dk.rb instal

e. 安装python，下载地址：activepython，安装2.7版，主要是博客代码加亮模块需要python环境的支持，安装完以后，在win的cmd窗口中执行：

 easy_install pygments

3. 更新配置

a. 中文 utf-8 编码的支持，在win7环境变量中配置如下：

LANG=zh_CN.UTF-8
LC_ALL=zh_CN.UTF-8

b. 变更 gem 的更新源，ruby的官方更新源经常被河蟹，木有办法，幸亏国内有淘宝做好事，提供了国内的更新源，这样速度就快多了，变更如下：

gem sources --remove http://rubygems.org/
gem sources -a http://ruby.taobao.org/
gem sources -l
注意 ：请确保只有 http://ruby.taobao.org/ 唯一一个条目

c. 安装 rdoc 和 bundler

资源收集之优秀代码片段分享网站

Fri, 13 Apr 2012 17:16:06 +0000

本文分享一些优秀代码片段的网络资源，不论是设计师，还是开发人员，相信能从这些优秀的代码片段中找到一些灵感，同时使用最少的代码来解决熟悉的问题，这些网址是从国外文章《Awesome sites to find useful code snippets》分享过来的。

CatsWhoCode snippet library

Some of you already know it, but a few weeks ago I’ve created a snippet library with a picky selection of usefull snippets focused on web development:PHP, JavaScript, CSS, htaccess

… Approximately one new snippet is published every day. Users are welcome to submit their own snippets.

Snipplr

Snipplr is probably the largest code snippet repository

available on the internet. Since 5 years, they have published thousand of pieces of code. Some snippets are super useful, some other not so, but there’s a strong chance that you’ll find what you need on a website with so many snippets.

关于PhoneGap视频插件的代码更新

Fri, 13 Apr 2012 14:55:35 +0000

本文主要介绍PhoneGap视频插件的代码更新，具体插件的开发过程请参照我以前的博文《phonegap之android端插件开发》。现在PhoneGap已经把代码移交到apache开源项目cordova里面，本文代码的更新主要涉及到两项，一是把以前phoneGap的引用迁移到cordova的引用中，二是在原来插件代码的基础上增加回调机制。

以前版本的视频插件可以在android设备上面正常工作，但是有一个潜在的问题，因为插件启动视频播放利用的是 “startActivity”方法，无法获取到视频播放结束的消息，本次代码的主要改进就是改变原来启动视频播放的函数，使用“startActivityForResult”方法，这样当视频播放结束的时候，“onActivityResult”方法会被回调，从而该插件就能正确通知插件使用者视频已正常播放结束，可以继续处理其他流程。

Java 端的完整代码如下：

package com.dlgreat.bbhtml.plugins;

import org.apache.cordova.api.Plugin;
import org.apache.cordova.api.PluginResult;
import org.json.JSONArray;
import org.json.JSONException;

import android.content.Intent;
import android.net.Uri;

public class VideoPlayer extends Plugin {

private String callbackId;

@Override
public PluginResult execute(String action, JSONArray args, String callbackId) {
   this.callbackId = callbackId;
   PluginResult.Status status = PluginResult.Status.OK;
   String result = "";

   try {
       if (action.equals("playVideo")) {
           playVideo(args.getString(0));

           PluginResult res = new PluginResult(PluginResult.Status.NO_RESULT);
           res.setKeepCallback(true);
           return res;
       }

       return new PluginResult(status, result);
   } catch (JSONException e) {
       return new PluginResult(PluginResult.Status.JSON_EXCEPTION);
   }
}

private void playVideo(String url) {
    Uri uri = Uri.parse(url);
    Intent intent = new Intent(Intent.ACTION_VIEW);
    intent.setDataAndType(uri, "video/*");

    this.ctx.startActivityForResult(this, intent, 0);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent intent) {
  if (requestCode == 0) {
     success(new PluginResult(PluginResult.Status.OK, ""), callbackId);
  }
}
}

Javascript端的完整代码如下：

文章归档

Tue, 10 Apr 2012 14:09:43 +0000

Sencha Touch 程序设计之 Android 平台 Back 按键处理

Mon, 09 Apr 2012 15:23:40 +0000

利用 Sencha Touch 结合PhoneGap设计本地APP，免不了要分别处理android平台和iphone平台，两个平台的最大区别之一就是back键的处理。iphone平台没有back按键，只有home按键，按下该键的话程序会自动转入后台处理，该按键的效用等同于android平台的home按键，但是，android平台特殊的地方在于，它还有一个back键，熟悉了android平台的开发者或使用者，把该键的作用理解为退回程序的上一个页面，如果程序已经在主页面，此时则退出程序。

因为Sencha Touch对android平台进行了消息封装，默认对back键的处理，同home键的处理一致，这令很多android开发者或使用者使用其功能的话不太友好，我自己在调试程序的过程中就误操作过了N次，每次按下back键期望程序回退到上一个页面，没想到程序直接消失了，转到后台去了。

网上搜索了一些解决方案，各有利弊，汇总贴可参照Sencha Touch官方论坛《Why-can-t-I-control-Android-phone-s-hardware-Back-button-in-Sencha-with-PhoneGap》，下面介绍一下我设计的一个解决方案，在实测环境中工作良好，总结如下：

首先在Sencha 启动代码中捕获android平台的back按键消息，阻止Sencha 框架的默认处理

var App = new Ext.application({
 // ... APP 配置参数

 launch : function () {
  // ... 界面初始化
   BBGlobalData.mainPanel = Ext.create('Ext.Panel', {
       fullscreen: true,
       layout : 'card',
       cardAnimation : 'slide',
       items: [
           Ext.create('BBShow.view.LoginPanel'),
           Ext.create('BBShow.view.HomePanel'),
           Ext.create('BBShow.view.MediaPanel'),
           Ext.create('BBShow.view.PicCarousel'),
           Ext.create('BBShow.view.ReportListPanel'),
           Ext.create('BBShow.view.ReportPanel'),
       ]
   });

   Ext.Viewport.add(BBGlobalData.mainPanel);

   document.addEventListener('deviceready', function () {
     console.log('deviceready');
     document.addEventListener("backbutton", function () {
           console.log('user presses the back button on Android');
           // 获取当前的焦点页面，并发送自定义消息'back'
           BBGlobalData.mainPanel.getActiveItem().fireEvent('back');
    }, false);
  }, false);
}
})

在子页面中注册back消息的监听器

/*定义登录面板*/
Ext.define('BBShow.view.LoginPanel', {
extend: 'Ext.Panel',

    config: {
      items: [
      {
        xtype: 'titlebar',
        docked: 'top',
        title: '用户登录'
      },
      // 其他页面内容
     ],
    listeners: [
     {
      fn: 'onBack',
      event: 'back', //注册监听自定义back按键消息
     }
    ]
  },

  onBack: function() {
    //BBGlobalData.gotoHomePanel(); //如，跳转到其他页面
    BBGlobalData.exitApp(); //或退出程序
  },
});

实现退出程序的处理，借助于PhoneGap

   BBGlobalData.exitApp = function() {
   navigator.app.exitApp();
}

实现页面跳转的处理（主页面采用card view，类似于扑克的翻牌）

BBGlobalData.gotoHomePanel = function() {
   BBGlobalData.mainPanel.setActiveItem(1);
}

总结：其实总的解决方法还是很简单，只要把整体的框架搭建完善了，很容易就能在多平台之间转换了。

php使用ffmpeg-php扩展库进行视频截图

Sun, 08 Apr 2012 16:23:25 +0000

这几天做项目，其中一个需求是用户上传视频文件到服务器，然后服务器自动截取该视频的一帧作为该视频对应的缩略图，服务器端语言采用php编写，找了半天资料，发现ffmpeg-php可以满足该需求，所以下面简单介绍一下该扩展库的配置和使用方法。

测试服务器环境 WampServer Version 2.1，php5.3.5，ffmpeg-php 配置和使用步骤如下：

下载 ffmpeg-php,

ffmpeg-php-5.3-win32-all.zip

将 php_ffmpeg.dll 放到 PHP 扩展目录，（例如 E:\Program Files\wamp\bin\php\php5.3.5\ext）
将其他的dll文件放到系统目录，（例如 C:\Windows\System32）
修改 php.ini，添加 extension=php_ffmpeg.dll 配置项，结果如下：

extension=php_gd2.dll extension=php_gettext.dll extension=php_ffmpeg.dll （注：Wamp 环境下要修改 apache 目录中的 php.ini,(例如E:\Program Files\wamp\bin\apache\Apache2.2.17\bin\php.ini), 同时要启用gd2 和 gettext 模块）

重新启动 apache 服务器

6.打印输出 phpinfo，查看是否有如下输出，若有，则说明 ffmpeg-php 模块配置正确

ffmpeg

ffmpeg-php version	0.6.0-svn
ffmpeg-php built on	Sep 8 2010 12:13:47
ffmpeg-php gd support	enabled
ffmpeg libavcodec version	Lavc52.87.4
ffmpeg libavformat version	Lavf52.78.3
ffmpeg swscaler version	SwS0.11.0

Directive	Local Value	Master Value
ffmpeg.allow_persistent	0	0
ffmpeg.show_warnings	0	0

编写测试代码，示例代码截取视频的第二帧为缩略图

public function testmp4()
{
if(extension_loaded('ffmpeg')){//判断ffmpeg是否载入
$mov = new ffmpeg_movie('E:\\Program Files\\wamp\\www\\BBShow\\test\\guangfa15s.mp4');//视频的路径
dump($mov);
$ff_frame = $mov->getFrame(2);
$gd_image = $ff_frame->toGDImage();
$img=$_SERVER['DOCUMENT_ROOT']."/test.jpg";//要生成图片的绝对路径
imagejpeg($gd_image, $img);//创建jpg图像
imagedestroy($gd_image);//销毁一图像
}else{
echo "ffmpeg没有载入";
}
}

运行测试代码，即可在服务器端生成 jpg 格式的缩略图
有关 ffmpeg-php 的详细使用说明，请参照官方API（

Sencha Touch 程序设计体验之笔记本

Mon, 02 Apr 2012 15:48:17 +0000

这几天进行进行 webmobile App的设计，起初的设计方案采用的是 Jquery Mobile + PhoneGap，原想应该工作的不错，没想到到了最后，进行程序结合测试的时候出现了一个莫名奇妙的问题，那就是，利用Jquery Mobile进行页面切换，反复进行七次以上的连环页面跳转，同时在后台发送 Ajax数据请求，从服务器download数据，就会破坏PhoneGap的本地工作机制，导致后面的PhoneGap本地函数调用无法正常进行，PhoneGap的工作原理也是ajax通信机制，在环境出错的情况下，总是返回status = 0的状态，无奈解决了两天还是没有彻底解决，现在着手试着另一套界面设计框架Sencha Touch。

学习Sencha Touch，改写了别人的一个APP，一个记事本程序，详细的E文请参照《writing a sencha touch application》。

笔记本程序的运行效果图如下(分别是笔记列表和笔记编辑页面)：

当时设计该程序的代码基于Sencha Touch1.1.0，现在Sencha Touch已经发布了2.0版本，所以里面有很多代码已经无法正常工作了，本文还是按照作者当初的设计思路，重新基于Sencha Touch2.0进行了编码工作，程序已经可以正常运行，后面附上本程序的JS源码：

var App = new Ext.application({
name : 'NotesApp',
useLoadMask : true,

launch : function () {
notesListToolbar = Ext.create('Ext.Toolbar', {
id: 'notesListToolbar',
docked: 'top',
title: '记事本',
layout: 'hbox',
items: [
{ xtype: 'spacer' },
{
id: 'newNoteButton',
text: '新建笔记',
ui: 'action',
handler: function () {
var now = new Date();
var noteId = now.getTime();
var note = Ext.ModelMgr.create(
{ id: noteId, date: now, title: '', narrative: '' },
'Note'
);

noteEditor.setRecord(note);
Ext.Viewport.setActiveItem('noteEditor', {type: 'slide', direction: 'left'});
}
}
]
});

Ext.regModel('Note', {
idProperty: 'id',
fields: [
{ name: 'id', type: 'int' },
{ name: 'date', type: 'date', dateFormat: 'c' },
{ name: 'title', type: 'string' },
{ name: 'narrative', type: 'string' }
],
validations: [
{ type: 'presence', field: 'id' },
{ type: 'presence', field: 'title', message: '请输入笔记的标题!' }
]
});

Ext.regStore('NotesStore', {
model: 'Note',
sorters: [{
property: 'date',
direction: 'DESC'
}],
proxy: {
type: 'localstorage',
id: 'notes-app-localstore'
},
getGroupString: function (record) {
if (record && record.data.date) {
return record.get('date').toDateString();
} else {
return '';
}
},
});

notesList = Ext.create('Ext.List', {
id: 'notesList',
store: 'NotesStore',
grouped: true,
emptyText: '<div style="margin: 5px;">目前还没有创建笔记.</div>',
loadingText: '正在读取笔记 ...',
itemTpl: '<div class="list-item-title">{title}</div>' +
'<div class="list-item-narrative">{narrative}</div>',
onItemDisclosure: function (record) {
var selectedNote = record;
noteEditor.setRecord(selectedNote);
Ext.Viewport.setActiveItem('noteEditor', { type: 'slide', direction: 'left' });
},
listeners: {
'render': function (thisComponent) {
thisComponent.getStore().load();
},
}
});

notesListContainer = Ext.create('Ext.Panel', {
id : 'notesListContainer',
layout : 'fit',
items: [notesListToolbar, notesList],
html: 'This is the notes list container'
});

noteEditorTopToolbar = Ext.create('Ext.Toolbar', {
title: '编辑笔记',
docked: 'top',

items: [
{
text: '记事本',
ui: 'back',
handler: function () {
Ext.Viewport.setActiveItem('notesListContainer', { type: 'slide', direction: 'right' });
}
},
{ xtype: 'spacer' },
{
text: '保存',
ui: 'action',
handler: function () {
var currentNote = noteEditor.getRecord();
// Update the note with the values in the form fields.
noteEditor.updateRecord(currentNote);

var errors = currentNote.validate();
if (!errors.isValid()) {
currentNote.reject();
Ext.Msg.alert('请等待...', errors.getByField('title')[0].getMessage(), Ext.emptyFn);
return;
}

var notesStore = notesList.getStore();

if (notesStore.findRecord('id', currentNote.data.id) === null) {
notesStore.add(currentNote);
} else {
currentNote.setDirty();
}

notesStore.sync();
notesStore.sort([{ property: 'date', direction: 'DESC'}]);

notesList.refresh();

Ext.Viewport.setActiveItem('notesListContainer', { type: 'slide', direction: 'right' });
}
}
]
});

noteEditorBottomToolbar = Ext.create('Ext.Toolbar', {
docked: 'bottom',

items: [
{ xtype: 'spacer' },
{
iconCls: 'trash',
iconMask: true,
handler: function () {
var currentNote = noteEditor.getRecord();
var notesStore = notesList.getStore();

if (notesStore.findRecord('id', currentNote.data.id)) {
notesStore.remove(currentNote);
}

notesStore.sync();

notesList.refresh();
Ext.Viewport.setActiveItem('notesListContainer', { type: 'slide', direction: 'right' });
}
}
]
});

noteEditor = Ext.create('Ext.form.FormPanel',{
id: 'noteEditor',
items: [
noteEditorTopToolbar,
{
xtype: 'textfield',
name: 'title',
label: '笔记标题',
required: true
},
{
xtype: 'textareafield',
name: 'narrative',
label: '笔记内容'
},
noteEditorBottomToolbar
]
});

mainPanel = Ext.create('Ext.Panel', {
fullscreen: true,
layout : 'card',
cardAnimation : 'slide',
items: [notesListContainer, noteEditor]
});

Ext.Viewport.add(mainPanel);
}
})

有兴趣学习Sencha Touch的童鞋，该sample还是一个不错的入门选择，接下来再挑选几个不错的sample来update。

CSS 多行文本的垂直居中方法

Fri, 30 Mar 2012 19:46:50 +0000

前一篇文章《CSS 元素垂直居中的 6种方法》中介绍了6种常用的利用CSS来垂直居中元素的方法，本文介绍一种多行文本垂直居中的解决方案。

实现的效果如下：查看 Demo，下载代码文件 Html代码

<div class="area">
<div class="bubble">
<p>To look best, text should really be centered inside this bubble both vertically and horizontally.</p>
</div>
</div>

CSS代码

.area {
  width: 300px;
  height: 300px;
  background: url(../images/abe-bg.png) no-repeat;
  position: relative;
}

.bubble {
  position: absolute;
  left: 93px;
  top: 21px;
  width: 135px;
  height: 84px;
  display: table;
}

.bubble p {
  display: table-cell;
  vertical-align: middle;
  text-align: center;
}

上面的代码利用了table table-cell中的vertical-align: middle 属性。

IE 8 开始支持 CSS tables，那么在IE7及以下，怎么来解决呢？

CSS 元素垂直居中的 6种方法

Fri, 30 Mar 2012 14:24:51 +0000

利用CSS进行元素的水平居中，比较简单，行级元素设置其父元素的text-align center，块级元素设置其本身的left 和 right margins为auto即可。本文收集了六种利用css进行元素的垂直居中的方法，每一种适用于不同的情况，在实际的使用过程中选择某一种方法即可。

Line-Height Method

试用：单行文本垂直居中，demo 代码：html

<div id="parent">
<div id="child">Text here</div>
</div>

css

#child {
line-height: 200px;
}

垂直居中一张图片，代码如下 html

<div id="parent">
<img src="image.png" alt="" />
</div>

css

#parent {
line-height: 200px;
}
#parent img {
vertical-align: middle;
}

CSS Table Method

适用：通用，demo 代码：html

<div id="parent">
<div id="child">Content here</div>
</div>

css

#parent {display: table;}
#child {
display: table-cell;
vertical-align: middle;
}

低版本 IE fix bug：

#child {
display: inline-block;
}

Absolute Positioning and Negative Margin

适用：块级元素，demo 代码：html

编写 PhoneGap 程序调试问题解决方案

Wed, 28 Mar 2012 10:22:15 +0000

这几天做项目，需要设计一个和服务器交互的库，同时也有一个提高效率的需求就是设计缓存机制，无奈PhoneGap提供的API太坑爹了，编写个缓存费了N大的劲才完成，记录一下要注意的地方。

客户端浏览器调试Ajax请求报错“

Origin null is not allowed by Access-Control-Allow-Origin. ”解决办法：谷歌浏览器 chrome.exe –disable-web-security

PhoneGap 远程调试

远程调试架构图如下所示：配置步骤如下：a. 登录网址：http://debug.phonegap.com/填写配置信息 b. 在本地代码中引用远程调试JS代码文件 c. 打开远程调试窗口 http://debug.phonegap.com/client/#bbshow （bbshow为第一步骤配置的名字）在调试窗口中可以修改节点的属性，然后手机上的画面就会自动更新了。

常用的代码总结

a. 设计 Ajax 数据通信（如用户登录）

/*
用户登录模块

params = {};
params.username 登录用户名
params.password 登录用户密码

succcb  登录成功时候的回调函数 function(data);
errcb   登录失败时候的回调函数 function(text);
*/
function bb_login(params, succcb, errcb)
{
   var tmplate = login_req_xml(params);

   doPost(tmplate, function(data, textStatus, jqXHR) {
      if (data.status == 0) {
          errcb(data.info);
      } else {
          GServerData.curToken = data.data;
          succcb(data.data);
      }
   }, function(jqXHR, textStatus, errorThrown) {
         errcb(textStatus);
   });
}

/*用户登录的模板文件*/
function login_req_xml(params)
{
  var tmplate = '<?xml version="1.0" encoding="utf-8"?>'
       + '<request>'
       + '<operation>'
       + '<module>token</module>'
       + '<action>login</action>'
       + '<params>'
       + '<username>' + params.username + '</username>'
       + '<password>' + params.password + '</password>'
       + '</params>'
       + '</operation>'
       + '</request>';
   return  tmplate;
}

/*
向服务器发送 POST 请求.

data: 向服务器发送的数据内容
succcb: 成功时候的回调函数 success(data, textStatus, jqXHR)
errcb:  失败时候的回调函数 error(jqXHR, textStatus, errorThrown)
*/
function doPost(data, succcb, errcb)
{
   $.ajax({
      type: "POST",
      url: Config.serverapi,
      data: data,
      cache: false,
      dataType: "json",
      success: succcb,
      error: errcb
   });
}

b.  数据缓存

/*
dataUrl 请求数据的网络URL地址
如果缓存成功，则会返回本地的File地址

succcb 登录成功时候的回调函数 function(data);
errcb 登录失败时候的回调函数 function(text);
*/
function bb_loadCacheData(dataurl, succcb, errcb)
{
  var errorCB = function (err) {
      console.log("Error processing : " + err.code);
      errcb("Error processing : " + err.code);
  }

var downLoadFile = function(db) {
  console.log("downLoadFile ... [" + dataurl + "]");

   //特别备注：在Phonegap1.5.0中，LocalFileSystem.TEMPORARY 和 LocalFileSystem.PERSISTENT 两者相反了
   window.requestFileSystem(LocalFileSystem.PERSISTENT, 0, function (fileSystem) {
        var datadate = new Date().getTime();
        var filename = datadate + '_' + dataurl.substr(dataurl.lastIndexOf('/')+1);

        var fileTransfer = new FileTransfer();

        fileTransfer.download(
           dataurl,
           fileSystem.root.fullPath.substr("file://".length) + Config.datacachepath + filename,
           function(entry) {
               console.log("download complete: " + entry.fullPath);
               db.transaction(function (tx) {
                   tx.executeSql('INSERT INTO data_cache (dataurl, datapath, datadate) VALUES ("' + dataurl + '","' + entry.fullPath + '","' + datadate + '")');
               succcb(entry.fullPath);
               }, errorCB);
           },
          function(error) {
              console.log("download error source " + error.source);
              console.log("download error target " + error.target);
              console.log("download error code " + error.code);
              errcb("download error code " + error.code);
          }
      ); 
     }, errorCB);
   };

   var db = window.openDatabase("cache.db", "1.0", "BBShow Data Cache DB", 200000);
   db.transaction(function (tx) {
      tx.executeSql('CREATE TABLE IF NOT EXISTS data_cache (id unique, dataurl, datapath, datadate)');
      tx.executeSql('SELECT * FROM data_cache WHERE dataurl=?', [dataurl], function(tx, results) {
      if (results.rows.length > 0) {
         window.resolveLocalFileSystemURI(results.rows.item(0).datapath, function(fileEntry) {
              console.log(fileEntry.fullPath);
              succcb(fileEntry.fullPath);
         }, function(error) {
              console.log("Unable to resolveLocalFileSystemURI: " + error.code);
              db.transaction(function (tx) {
              tx.executeSql('DELETE FROM data_cache WHERE dataurl=?', [dataurl]);
              downLoadFile(db);
         }, errorCB);
        });
      } else {
          downLoadFile(db);
      }
     }, errorCB);
   }, errorCB);
}

总之，这两天才发现 PhoneGap不是一般的难用，真应该再多完善完善！！！

Android 开发之 HttpClient Class can not find 之解决办法

Mon, 26 Mar 2012 14:28:16 +0000

相信大家在开发 Android 的过程中遇到过这么一种情况，那就是 “ Could not find class ‘org.apache.commons.httpclient.HttpClient’”。

尤其是在 eclipse 的插件ADT升级之后，很容易出现该问题，昨天Google放出了ADT的升级包，然后我也就升级了一下开发环境，没想到前天还运行好好的程序，今天突然就不会工作了，检查log发现，HttpClient无法找到，但是在普通的Java运行环境下就可以正常运行。

因为Apache的HttpClient开发包，Google自己也定制了一份，已经内置到开发环境中了，所以我们如果使用纯粹的Apache原生态的HttpClient开发包就可能出现冲突的问题，每当Google升级ADT之后，说不定程序就Over了。

实在没有办法，那就把基于Apache原生态的HttpClient完全替换成Google定制后的类型吧，转换前后的代码对比如下：

基于Apache原生态的HttpClient

package com.shiny.mid.net;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.ByteArrayRequestEntity;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;

public final class HSHttpClient {

private static final int CONNECTION_TIMEOUT = 20000;
private static HSHttpClient mHSHttpClient;

private HSHttpClient() {
}

public static synchronized HSHttpClient getInstance() {
if (mHSHttpClient == null) {
mHSHttpClient = new HSHttpClient();
}
return mHSHttpClient;
}

/**
* Using GET method.
*
* @param url
*            The remote URL.
* @param queryString
*            The query string containing parameters
* @return Response string.
* @throws Exception
*/
public String httpGet(String url, String queryString) throws Exception {
String responseData = null;

if (queryString != null && !queryString.equals("")) {
url += "?" + queryString;
}

HttpClient httpClient = new HttpClient();
GetMethod httpGet = new GetMethod(url);
httpGet.getParams().setParameter("http.socket.timeout",
new Integer(CONNECTION_TIMEOUT));

try {
int statusCode = httpClient.executeMethod(httpGet);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("HttpGet Method failed: "
+ httpGet.getStatusLine());
}
responseData = httpGet.getResponseBodyAsString();
} catch (Exception e) {
throw new Exception(e);
} finally {
httpGet.releaseConnection();
httpClient = null;
}

return responseData;
}

/**
* Using POST method.
*
* @param url
*            The remote URL.
* @param queryString
*            The query string containing parameters
* @return Response string.
* @throws Exception
*/
public String httpPost(String url, String queryString) throws Exception {
String responseData = null;
HttpClient httpClient = new HttpClient();
PostMethod httpPost = new PostMethod(url);
httpPost.addParameter("Content-Type",
"application/x-www-form-urlencoded");
httpPost.getParams().setParameter("http.socket.timeout",
new Integer(CONNECTION_TIMEOUT));
if (queryString != null && !queryString.equals("")) {
httpPost.setRequestEntity(new ByteArrayRequestEntity(queryString
.getBytes()));
}

try {
int statusCode = httpClient.executeMethod(httpPost);
if (statusCode != HttpStatus.SC_OK) {
System.err.println("HttpPost Method failed: "
+ httpPost.getStatusLine());
}
responseData = httpPost.getResponseBodyAsString();
} catch (Exception e) {
throw new Exception(e);
} finally {
httpPost.releaseConnection();
httpClient = null;
}

return responseData;
}
}

基于Google定制的HttpClient

package com.dlgreat.bbshow.net;

import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.util.EntityUtils;

public final class BBHttpClient {

private static final int CONNECTION_TIMEOUT = 20000;
private static BBHttpClient mHSHttpClient;

private BBHttpClient() {
}

public static synchronized BBHttpClient getInstance() {
if (mHSHttpClient == null) {
mHSHttpClient = new BBHttpClient();
}
return mHSHttpClient;
}

/**
* Using GET method.
*
* @param url
*            The remote URL.
* @param queryString
*            The query string containing parameters
* @return Response string.
* @throws Exception
*/
public String httpGet(String url, String queryString) throws Exception {
if (queryString != null && !queryString.equals("")) {
url += "?" + queryString;
}

HttpGet httpGet = new HttpGet(url);

HttpParams params = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);
HttpConnectionParams.setSoTimeout(params, CONNECTION_TIMEOUT);
HttpClient httpClient = new DefaultHttpClient(params);

try {
HttpResponse response = httpClient.execute(httpGet);
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
System.err.println("HttpGet Method failed: "
+ response.getStatusLine().toString());
httpGet.abort();
}
return EntityUtils.toString(response.getEntity());
} catch (Exception e) {
throw new Exception(e);
} finally {
httpClient.getConnectionManager().shutdown();
}
}

/**
* Using POST method.
*
* @param url
*            The remote URL.
* @param queryString
*            The query string containing parameters
* @return Response string.
* @throws Exception
*/
public String httpPost(String url, String queryString) throws Exception {
HttpPost httpPost = new HttpPost(url);

if (queryString != null && !queryString.equals("")) {
StringEntity se = new StringEntity(queryString);
httpPost.setHeader("Content-Type",
"application/x-www-form-urlencoded");
httpPost.setEntity(se);
}

HttpParams params = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);
HttpConnectionParams.setSoTimeout(params, CONNECTION_TIMEOUT);
HttpClient httpClient = new DefaultHttpClient(params);

try {
HttpResponse response = httpClient.execute(httpPost);
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
System.err.println("HttpPost Method failed: "
+ response.getStatusLine().toString());
httpPost.abort();
}
return EntityUtils.toString(response.getEntity());
} catch (Exception e) {
throw new Exception(e);
} finally {
httpClient.getConnectionManager().shutdown();
}
}
}

利用 jQuery Mobile 制作 wordpress 手机主题

Tue, 06 Mar 2012 21:59:46 +0000

jQuery Mobile 作为一款十分优秀的 Javascript 开发框架，可以用来方便的开发面向手持设备的网站和Web APP。

本文就带领大家使用 jQuery Mobile 来制作一款 wordpress 的手机主题。

示例代码演示效果如下

主题制作步骤

我们可以从头开始来制作一款主题，不过为了节省制作主题的时间，示例代码是通过客制化另外一款主题来实现的，首先需要下载一款 BLANK-Theme

的 wordpress 主题，该主题除了样式 style 没有定义以外，其他的功能都基本已经实现了，通过修改文件 style.css，您可以修改该主题的名字，也可以客制化该主题的样式。

修改 Header 和 Footer

既然要制作手机主题，首先需要引用 jQuery 和 jQuery Mobile 开发库，您可以把这些开发库下载到自己的Server上，也可以利用JQuery的CDN Server，推荐利用CDN加速，这些库的加载速度会快很多，同时也可以为您的服务器节省流量。

修改 header.php 文件，在<head> 和</head> 的标签中添加如下代码：

<link rel="stylesheet" href="http://code.jquery.com/mobile/1.0.1/jquery.mobile-1.0.1.min.css" />
<script src="http://code.jquery.com/jquery-1.7.1.min.js"></script>
<script src="http://code.jquery.com/mobile/1.0.1/jquery.mobile-1.0.1.min.js"></script>

因为 jQuery Mobile 使用 HTML5, 我们需要修改 doctype。更新 Header 如下:

<!DOCTYPE html>
<html <?php language_attributes(); ?>>
<head>

接下来，替换从 <body <?php body_class(); ?>> 标签开始的全部内容如下：

<body <?php body_class(); ?>>
<div data-role="page" data-theme="b" id="jqm-home">
<div data-role="header">
<h1><?php bloginfo('name'); ?></h1>
</div>

<div data-role="content">

然后开始修改 footer.php 文件，替换为如下内容：

留言

Wed, 29 Feb 2012 21:35:35 +0000

友情链接

Wed, 29 Feb 2012 21:34:31 +0000

PhoneGap入门之问题解读

Sat, 18 Feb 2012 10:30:39 +0000

很多PhoneGap新手总是需要一些基础问题的解答，Adobe技术布道师Andrew Trice常在其博文中回答诸如” PhoneGap是什么?”、“phonegap应用开发出来是什么样的形态?”、“如何开发phonegap?”等问题。近日他将这些问题回答整理成文以帮助开发者理解和使用PhoneGap。

1. PhoneGap是什么?

PhoneGap是一个基于HTML和JavaScript的应用开发平台，使用它可以构建本地应用。你可以把PhoneGap看作一个正方形的web view container，它使用JavaScript编程接口实现用户在不同操作系统下的访问。你可以利用传统的web开发技术(如HTML、CSS、JavaScript )开发用户接口，利用PhoneGap容器把它们部署到不同的应用环境和设备上。

PhoneGap可以被用来开发跨平台的应用，这些平台包括Apple iOS、Google Android,、Windows Phone、BlackBerry、HP WebOS,、Symbian 和 Bada。你可以通过链接http://phonegap.com/about/features 获取更多关于PhoneGap支持的平台及其特色功能的信息。

PhoneGap是一个开源的框架，用户可以去http://incubator.apache.org/projects/callback.html获取更多信息。

2.开发出的PhoneGap应用是什么样的形态？

由于UI绘制引擎就是移动设备的内置web浏览器，所以PhoneGap应用的形态可能多种多样。你可以使用标准的HTML&CSS使它看起来就像一个简单的网页，也可以使用UI框架使它像jQuery UI, Kendo UI, Sencha, Twitter Bootstrap或Skeleton(或者其它任意基于HTML/CSS/JS的用户框架接口)。另外你也可以采用CSS模式/主题使它看起来就像一个本地应用，如模仿iOS 和 Android的iUI，模仿BlackBerry的bbUI。

PhoneGap应用可以是基于HTML的静态UIs，也可以是利用JavaScript开发具有动态效果和交互体验动态UIs。这取决于特定的应用、用户体验设计、受众目标以及指示PhoneGap应用如何出现的应用实例。

使用PhoneGap应用，你可以通过缩小放大操作放大或者缩小查看的内容，或者利用利用viewport metadata tag锁定浏览内容的大小。你可以利用常规浏览器的操作方式滚动浏览网页也可以像iScroll一样采用基于接触的滑动方式浏览网页。

基于HTML, CSS & JavaScript你有许多方式可以创建用户接口，所以并没有一个典型的外观。如果你没有使用任何的CSS模式，那么用户接口各元素默认和使用的操作系统或者浏览器保持一致，包括按钮、链接、色彩以及亮度。这时PhoneGap应用和操作系统默认的浏览器一样运行。

3. 如何利用PhoneGap开发应用？

利用PhoneGap开发应用非常简单，90%的PhoneGap应用只需要一个文本编辑器即可。PhoneGap也能很容易的与特定的设备整合形成开发环境。具体可以参考以各应用平台上的开发指导链接：•iOS: http://phonegap.com/start#ios-x4 •Android: http://phonegap.com/start#android •BlackBerry: http://phonegap.com/start#blackberry •Windows Phone: http://phonegap.com/start#wp •WebOS: http://phonegap.com/start#webos •Symbian: http://phonegap.com/start#symbian

在开发PhoneGap应用应用时，一定要谨记你是在web浏览器实例中运行代码。你是利用HTML和JavaScript开发应用而不是本地代码，因此不需要其它任何东西。实际上我的大部分开发都是利用HTML编辑器和Chrome浏览器实现的。当我需要在设备上做测试的时候再切换到特定的设备环境。

4. 如何调试PhoneGap应用？

调试PhoneGap应用是PhoneGap开发过程中最棘手部分。只在物理设备上测试，并不能测试出所有的JavaScript异常。下面是一些具体的调式策略：尽可能利用桌面浏览器调试

由于PhoneGap应用是利用HTML, CSS, and JavaScript进行开发的，你可以利用HTML编辑器开发大部分应用然后利用桌面web浏览器调试。最新版本的web浏览器(包括Chrome、IE、Firefox、Opera 和Safari)都提供了丰富的调试功能。利用web浏览器开发工具，你可以检查HTML DOM元素，检查CSS的模式、设置JavaScript断点、检查内存和JavaScript变量。通过下面链接可以获得更多更多关于桌面浏览器开发工具的信息：

•Chrome Developer Tools: http://code.google.com/chrome/devtools/docs/overview.html •Firefox via FireBug: http://getfirebug.com/ •Safari Developer Tools: https://developer.apple.com/technologies/safari/developer-tools.html •IE Developer Tools: http://msdn.microsoft.com/en-us/ie/aa740478 •Opera Developer Tools: http://dev.opera.com/articles/view/opera-developer-tools/ 你一旦利用桌面工具开发了应用的主要功能，便可以切换到特定的设备环境增加特定的设备功能并与PhoneGap APIs整合。

Android 多APK设计专题之为不同的API Level创建不同的应用APK

Tue, 07 Feb 2012 22:00:32 +0000

多APK支持是 Android Market 的一个新特性，它允许您为同一款应用对应不同的设备API Level 创建不同的APK，Android Market 会自动进行管理，通过识别用户设备的系统等级，比如2.2，2.3，4.0等等，然后会选择适合该设备的APK来让用户安装。

为不同的API Level设计的APK，可以进行特别的优化设置，比如GL纹理设置，API级别，屏幕尺寸，或其中的多个组合。

本节课就带领大家熟悉一下多APK的设计思路，您可以从中找到必要的开发工具和开发维护多个版本APK的方法。

确认您需要多个APKs

当您设计一款应用程序，为了满足多版本多设备之间的需求，在不牺牲向后兼容性的情况下，又可以利用最新版本的新特性，似乎多APK支持是个不错的解决方案。但事实并非如此，您可以通过阅读资料《Using Single APK Instead 》和《this article》来学习怎样在单一APK中实现上面提到的功能需求，以及怎样利用我们的支持库，同时也可以了解一下如何来编码实现。

使用单一APK有如下优势：

发布和测试更容易
只需要维护一个代码库
应用程序能够自适应设备配置的变化
应用恢复功能跨设备通用
应用升级容易

本文的余下章节，假定您已经认为您确实需要多APKs的解决方案，而不使用单一 APK 的方法。

图示化需求

可以通过创建一个简单的图表来确定需要几个APK来支持，以及每个APK与之对应的API Level范围。您可以在Android 平台版本的信息页面（Platform Versions ）中找到有用的参考资料，通过这种方法可以快速确定需要的APK个数和每个APK对应的API Level范围，尤其在出现API Level范围有重叠情况的时候更加有效，同时也方便了日后参考。

创建一个水平的列表来表示出当前已经发布的Android 版本号，在列表的最后一个位置放置一个+号来代表未来发布的版本。

| 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | + |

对上面的列表进行着色，每一种颜色对应一个APK，之后您的团队就可以以此来进行讨论还开发。

| 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | + |

设计公共库

无论是修改已有的代码做二次开发，还是从头开发一个新的应用，第一件事情就是提取公共的代码库，这些代码可以被不同的应用使用，并且只需要在一处编写和维护，比如多语言支持（language-localized strings），颜色主题（color themes），bug修复代码等，提供公共代码可以大大提高开发效率和节省开发时间，以及降低更新代码时引入的错误。

关于Java程序自动发布文章到百度空间的程序更新

Sun, 05 Feb 2012 13:21:09 +0000

利用Java程序自动发送博客文章到百度空间，可以参照我的博文《Java程序自动发布文章到百度空间》，通过修改程序的源码，主要是登录账户的信息就可以进行代码测试。

2012年开始，百度空间的博文发布系统进行了一些调整，主要是变更了一些请求的API参数和URL地址，以及增加跨域检测，提高了安全性，所以旧的代码无法正常工作，更新过的可以正常工作的代码在本文的最后有下载链接。

主要变更点如下：

百度空间的登录 params.put(“mem_pass”, “on”);
添加博文类别 params.put(“spIsBlogCatAdd”, “1”);
博文发布参数变更：params.put(“previewImg”, “”); 提交地址变更：private static final String SUBMIT_CREATBLOG_URL = “http://hi.baidu.com/" + Config.USERNAME + “/blog/submit/createblog”;
跨域检测 httpPost.setRequestHeader(“Referer”, refURL);

代码下载

程序源码 BaiduCreateBlog(20120205)

分享考《系统架构设计师》的心得

Wed, 01 Feb 2012 23:12:39 +0000

2011年11月中旬参加了系统架构设计师的考试，考试还算比较顺利，顺利通过了国家分数线，获得了资格证书。除去考试不说，在准备考试的这段时间里了解了一下架构设计的主要工作，和做架构设计的理论知识和一些成熟的架构方案，对自己以后的实际工作有很大的帮助。

算算自己准备了将近两个月的时间，差不多从9月份开始着手准备，基本上也都是工作外的时间，每天抽空看看书，复习复习，除非项目特别吃紧，比如到了项目发布的阶段，平时的时间还算比较充足，前期就是买书，找资料和了解一下考试的背景知识，中期主要就是熟悉考试题型，看看历年的考试题，做做参考书课后的习题，后期基本上就是试着做做模拟题，好好准备一下论文设计方面的知识，基本可以分成下面一些阶段。

【前期准备】

9月份到10月份一个月的时间基本就是补充基础知识，其实好多大学的课程都已经学习过了，无奈毕业以后就基本不怎么看书了，忘了很多，不过比起从头来学还是轻松了很多，这一段时间的准备怎么也像当初考研的总复习，O(∩_∩)O哈哈~。

参考书籍：《系统架构设计师考试全程指导》和《系统架构设计师教程》

这两本书基础知识基本上涵盖齐全了，后一本书可以粗略看一次，了解一下架构设计师需要的主要背景理论知识，前一本书推荐看两次，第一次算是过一下主要的理论知识点，能记住多少算多少，第二次顺便做一下课后的习题，实际上题目也没几道，每个章节也才不到20道题目，便于加深理解，同时重点记忆一些关键的知识点。

【中期准备】 10月份到11月份这一个月基本上就是熟悉考试的题型，了解一下考试题目是什么样子的，主要考什么，哪些是重点，案例分析题目怎么解答等等。

参考书籍：《系统架构设计师考试试题分类精解与题型练习》和《系统分析师考试案例分析与设计试题分类精解》

可以看一下历年的考题，相信大家考试也都不少了，最具有参考价值的题目仍旧是历年的真题，虽说系统架构师自从09年才开始，毕竟和系统分析师还是类似的，所以系统分析师的题目也可以拿来做参考。总得来说，通过本书试着做一些题目，了解一下历年考过的知识，和简答题目的方法，尤其是下午的案例分析题，难度相对比较高，可以重点学习一下回答这类题目的方法。

网络知识：

InfoQ的《架构师》专刊，每月一期，内容比较新，大家可以有空阅读，参考网址：

http://www.infoq.com/cn/architect/

Google Reader，订阅一些IT时事新闻周刊，新闻报道和软件开发技术，follow几个牛人博客，这都是汇集知识的不错方法，参考网址：

https://www.google.com/reader/view

网上找一下最近半年左右的技术分享报告，技术分享文章和IT行业评测报告什么的，紧跟IT潮流

【后期准备】

11月份，考试前夕，这段时间主要是知识总结和准备论文方面的工作。架构知识涉及面太广，不可能面面俱到，所有的知识都非常熟悉，必要的背景知识相信通过前段时间的学习，基本也就OK了，现在重点是论文设计了。一来，论文的字数比较多，2个小时的考试时间，写3000字的论文，还要扣除包括审题，概要什么的时间花费，练习练习动手写作能力还是非常重要的。我自己就因为这段时间没准备好，所以在考场上基本上休息时间没超过5分钟，从头至尾都在写字，直到收卷前4-5分钟也才写完和校验完，可以说是时间刚刚好，如果及早能练练手的话，相信语言的组织了，字迹的工整程度了，都能提高不少。二来，选择自己在近两年时间内做过的印象最深的一个项目，从项目的整体角度考虑，需求分析了，架构设计了，软件测试了，认为能够以宏观角度概括的，都可以整理一下，这都是用来写作的素材，像我今年论文的主题就是论需求分析的获取。三来，就是细化自己在项目中所做的工作，不要泛泛而谈，举实例出来，提出解决方案，这就是论文的论据。

其实论文这块，题目本身比较灵活，结合自己的实际项目经验来写，相对来说容易许多，内容也不会显得太空洞。同时可以网上参考一下历年的优秀论文，了解一下开头怎么写，中间内容怎么写，结尾怎么写，使文章读起来整体有一气呵成的感觉，免得写的不着边际，跑题了。

参考书籍：《系统架构设计师考试考前冲刺预测卷及考点解析》

这个类似于模拟考试，时间不足的话做个一套到二套熟悉一下考试的范围，我也考前仅仅做了一套，主要是练练手，查缺补漏，看看平时有没有漏掉的重要知识点，同时把握一下答题的时间，选择题，案例分析题和论文题的时间安排。

【总结】

总的来说，基础知识还是要花大工夫的，毕竟涉及的知识面比较广泛，操作系统了，网络了，数据库了，信息系统了，软件架构设计了，知识产权了等等。有些是了解的，有些是要重点掌握的，在复习基础知识的时候可以归类记忆。

再着，要多了解一下当前互联网产业的热门技术，毕竟做架构设计工作也是与时俱进的，现在都有好多的成熟架构解决方案，平时多了解和积累一些。

最后，也最重要，在实际的项目中把所积累的知识运用一下，不仅对自己做设计工作有好处，同时对考试来说，案例分析和论文设计也就比较容易上手了，不然的话，那就真是纸上谈兵了。考试的时候无从下手，不容易答题。

这算是自己考架构设计师的一点心得体会，难免有不足之处，相信大家只要认真准备了，考试还是比较容易过的，重要的是自己在工作中做架构设计的时候也能得心应手，灵活做设计，最后也预祝大家都能考个好成绩！！！

Android 相片管理专题之相机操作

Thu, 12 Jan 2012 19:57:14 +0000

本节课主要讲述怎样通过调用系统的framework APIs来控制设备的摄像头操作。

相比调用系统内置的其他相机应用来拍照和摄像，自己编写代码来直接控制相机操作需要更多的工作，然而，如果您要设计一款专业的拍照应用，或者相机功能与您的UI界面进行深度整合，那么您可以从本节课找到所需的知识。

开启相机

自己编写代码控制相机的第一步就是获得一个Camera 实例对象，与Android系统内置的其他相机应用类似，推荐的方法是在onCreate()方法中启动一个新的线程来开启相机，因为这个过程可能比较耗时，新启一个线程来处理可以有效避免UI主线程的停顿，另一种方式是将开启相机的过程推迟到 onResume() 方法中，这样便于代码的重用和简化流程控制。

如果此时有其他应用正在使用相机，那么当您的程序调用方法Camera.open() 的时候会出现异常，需要进行捕获（ try block）。

   private boolean safeCameraOpen(int id) {
     boolean qOpened = false;
  
     try {
       releaseCameraAndPreview();
       mCamera = Camera.open(id);
       qOpened = (mCamera != null);
     } catch (Exception e) {
       Log.e(getString(R.string.app_name), "failed to open Camera");
       e.printStackTrace();
     }
     return qOpened;
   }

   private void releaseCameraAndPreview() {
     mPreview.setCamera(null);
     if (mCamera != null) {
       mCamera.release();
       mCamera = null;
     }
   }

从 API level 9 开始，camera framework 支持用户程序控制多个相机，如果您在调用方法open() 的时候没有传递任何参数，那么系统会默认启动Androd设备的第一个后置摄像头。

Android 相片管理专题之视频捕捉

Wed, 11 Jan 2012 23:11:37 +0000

这节课主要讲述怎样利用设备已安装的相机应用程序来进行视频捕捉。

假如您的应用中有一个功能是视频整合，但是您又不想编写太复杂的代码来自己控制相机的视频捕捉，幸好，大多数Android设备已至少安装有一个相机程序，本课程就教您怎么样利用设备自带的相机应用来拍摄视频。

申请相机权限

如果您的应用的基本功能就是拍照或拍摄视频，需要在Android Market 中进行可见性限制，只有拥有摄像头的设备才能浏览和下载您的应用程序，那么您需要在manifest 文件的< uses-feature > tag中加入权限限制。

   <manifest ... >
     <uses-feature android:name="android.hardware.camera" />
     ...
   </manifest ... >

如果您的应用在设备没有相机的情况下仍能正常工作，那么可以在该tag中加入android:required=“false”。设定以后，所有的设备不管有没有摄像头都可以在Android Market 上面浏览和下载您的应用。但是，您需要自己在运行时检测设备是否有摄像头，调用方法hasSystemFeature(PackageManager.FEATURE_CAMERA)即可，如果相机不可用，那么您就需要禁用应用中与拍照或拍摄视频有关的功能模块。

用相机录制视频

在Andriod系统中，您的应用要委托其他的应用帮忙完成一些工作，可以使用Intent，把期望完成的任务和参数列表设置到Intent中，然后通过系统广播出去，最后当其他应用完成工作的时候，您的应用可以收到一个反馈信息，在回调函数中就可以取得任务处理结果。调用相机程序录制视频的过程与上面描述的类似，有三个关注点，定义拍摄视频的 Intent，启动其他相机应用Activity，处理拍摄后的视频流数据。

示例代码，启动视频录制应用

   private void dispatchTakeVideoIntent() {
    Intent takeVideoIntent = new Intent(MediaStore.ACTION_VIDEO_CAPTURE);
    startActivityForResult(takeVideoIntent, ACTION_TAKE_VIDEO);
  }

一个好的习惯是，在调用上面的代码前首先检查设备中是否有内置相机应用程序可以处理您的请求，示例代码如下：

   public static boolean isIntentAvailable(Context context, String action) {
    final PackageManager packageManager = context.getPackageManager();
    final Intent intent = new Intent(action);
    List<ResolveInfo> list =
        packageManager.queryIntentActivities(intent,
            PackageManager.MATCH_DEFAULT_ONLY);
    return list.size() > 0;
  }

查看视频

捕获的视频流数据会通过回调函数[onactivityresult()](http://developer.android.com/reference/android/app/Activity.html#onActivityResult(int, int, android.content.Intent))返回到您的应用中，您可以从 Intent中获得该视频数据的Uri地址，示例代码展示了如何将捕获到的视频数据显示在VideoView界面中。

Android 相片管理专题之拍照功能

Tue, 10 Jan 2012 23:06:17 +0000

这节课主要讲述怎样利用设备已安装的其他照相应用程序来拍摄照片。

例如您想要实现一个气象服务的APP，用来把全球的天气图片收集在一起，整合这些图片只是您应用程序的一部分工作，但是您又不想编写太复杂的代码来自己控制相机的拍照，幸好，大多数Android设备已至少安装有一个拍照程序，本课程就教您怎么样利用设备自带的拍照应用来拍摄这些图片。

申请相机权限

如果您的应用的基本功能就是拍照，需要在Android Market 中进行可见性限制，只有拥有摄像头的设备才能浏览和下载您的应用程序，那么您需要在manifest 文件的< uses-feature > tag中加入权限限制。

   <manifest ... >
     <uses-feature android:name="android.hardware.camera" />
     ...
   </manifest ... >

用相机程序拍照

在Andriod系统中，如果您的应用要委托其他的应用帮忙完成一些工作，可以使用Intent，把期望完成的任务和参数列表设置到Intent中，然后通过系统广播出去，最后当其他应用完成工作的时候，您的应用可以收到一个反馈信息，在回调函数中就可以取得任务处理结果。调用相机程序进行拍照，过程与上面描述的类似，有三个关注点，定义拍照的 Intent，启动其他相机应用Activity，处理拍照后的照片数据。

示例代码，启动拍照应用

   private void dispatchTakePictureIntent(int actionCode) {
     Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
     startActivityForResult(takePictureIntent, actionCode);
   }

恭喜您，通过如上的代码就可以给您的应用加入使用设备内置应用拍照的功能，当然，如果恰巧设备中没有安装任何的拍照应用，那么您的应用就有可能出错，一个好的解决办法是，在调用上面的代码前首先检查设备中是否有内置拍照应用，示例代码如下：

   public static boolean isIntentAvailable(Context context, String action) {
     final PackageManager packageManager = context.getPackageManager();
     final Intent intent = new Intent(action);
     List<ResolveInfo> list =
          packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
     return list.size() > 0;
   }

查看照片

如果您的应用不仅仅是通过设备内置的拍照应用拍摄照片，还需要对照片进行进一步的变换处理，那么您需要获得原始照片数据，拍照应用会将编码后的相片数据（small Bitmap ）放到Intent的"data"键值中，然后通过回调[onactivityresult()](http://developer.android.com/reference/android/app/Activity.html#onActivityResult(int, int, android.content.Intent))返回，如下示例代码将返回后的照片数据显示到 ImageView中。

WordPress 优化手记

Mon, 09 Jan 2012 21:37:39 +0000

个人主站建立了有一段的时间了，从域名注册，空间神马的东西鼓捣完了，国内的国外的都试过了，有些对建站有效的优化方法和代码更新，做一下记录，以后更新的时候便于查询。

SEO 优化工作

主要改动：header.php 改动原因：加入meta信息（网页描述“ description ”和网页关键词 “keywords “）利于搜索引擎索引

代码更新：

  <?php
  //add by carey zhou on 2011/12/31
  // add meta keywords and description by conditionary
  function the_excerpt_max_charlength($charlength) {
   $excerpt = get_the_excerpt();
   $charlength++;

   if ( mb_strlen( $excerpt ) > $charlength ) {
    $subex = mb_substr( $excerpt, 0, $charlength - 5 );
    $exwords = explode( ' ', $subex );
    $excut = - ( mb_strlen( $exwords[ count( $exwords ) - 1 ] ) );
    if ( $excut < 0 ) {
     return mb_substr( $subex, 0, $excut );
    } else {
     return $subex;
    }
   } else {
    return $excerpt;
   }
  }
  $description = '';
  $keywords = '';

  if ( is_home() || is_front_page() ) {
    $description = '润物无声是周润生的个人博客空间，主要用来分享和记录最新的互联网科技知识，优秀的企业架构解决方案和程序设计开发技术，同时致力于打造一个知识分享的平台。';
    $keywords = 'Technology blog, Internet news, Program development, Architecture design,科技博客,互联网新闻,程序开发,架构设计';
  }
  else if (is_single()) {
    $exerpt = the_excerpt_max_charlength(200);
    if ( $exerpt != '') {
      $description = $exerpt;
    }
    else {
     $description = $post->post_title ;
    }
    $tags = wp_get_post_tags($post->ID);
    foreach ($tags as $tag ) {
      $keywords = $tag->name . ', ' . $keywords;
    }
    $keywords = $keywords . '润物无声';
  }

  if ( $description != '' ): ?>
  <meta name="description" content="<?php echo "$description" ?>" />
  <?php endif;
  if ( $keywords != ''): ?>
  <meta name="keywords" content="<?php echo "$keywords" ?>" />
  <?php endif;
  //add by carey zhou on 2011/12/31
  ?>

优秀分页界面

主要改动：loop.php 改动原因：加入分页界面支持，方便浏览博文其他工作：需要分页插件支持：http://wordpress.org/extend/plugins/wp-pagenavi

Android 信息共享专题之ActionBar添加分享动作

Sun, 08 Jan 2012 16:12:31 +0000

在Android 4.0 (API Level 14)中引入的 ActionProvider 方便了在 ActionBar 中添加share action，一个 ActionProvider 一旦和 ActionBar 中的某个菜单项绑定起来，它就会负责该菜单项的界面绘画更新和事件处理。借助于 ShareActionProvider，您只需要设置一个share intent就可以了，其余的事情都交给 ShareActionProvider 来处理。

注意：ShareActionProvider 要求最低 API Level 14

更新菜单声明

要想使用 ShareActionProviders，您需要在菜单资源文件(menu resource)的Share菜单项<item>中声明 android:actionProviderClass 属性，示例如下

<menu xmlns:android="http://schemas.android.com/apk/res/android">       
<item android:id="@+id/menu_item_share"           
android:showAsAction="ifRoom"           
android:title="Share"           
android:actionProviderClass="android.widget.ShareActionProvider" />       
...   
</menu>

通过如上的定义，就把该菜单项的界面显示和消息事件处理委托给 ShareActionProviders，不过具体要显示的内容还是需要您来指定。

为了使 ShareActionProvider

可以正常工作，您还必须要设置Share Intent。这个Share Intent和第一节课《Android 信息共享专题之内容发布》中讲解的Intent一样，需要设置其Action为 ACTION_SEND，要发送的内容通过键值 EXTRA_TEXT 或者 EXTRA_STREAM 设置到该Intent中。具体步骤如下，您首先需要在 Activity 或者 Fragment 中inflating（加载）菜单资源文件，找到上文中声明的那个菜单项 MenuItem （如 menu_item_share），接着呼叫方法 MenuItem.getActionProvider() 来获得一个 ShareActionProvider 实例，最后调用 setShareIntent() 把Share Intent和该菜单项关联起来。示例代码：

  private ShareActionProvider mShareActionProvider;

  ...
  @Override
  public boolean onCreateOptionsMenu(Menu menu) {
      // Inflate menu resource file.
      getMenuInflater().inflate(R.menu.share_menu, menu);

      // Locate MenuItem with ShareActionProvider
      MenuItem item = menu.findItem(R.id.menu_item_share);

      // Fetch and store ShareActionProvider
      mShareActionProvider = (ShareActionProvider) item.getActionProvider();

      // Return true to display menu
      return true;
  }

  // Call to update the share intent
  private void setShareIntent(Intent shareIntent) {
      if (mShareActionProvider != null) {
          mShareActionProvider.setShareIntent(shareIntent);
      }
  }

您可能会选择只有在第一次创建菜单的时候设置share intent一次，其余菜单界面刷新的时候都不会再改变intent的设置了，或者也会选择每次菜单刷新的时候就重新设置intent一次，随着UI界面的改变会更新不同的intent。例如，您在Gallery app中全屏幕浏览图片的时候和滚动浏览图片的时候可能会设置不同的sharing intent。想了解更多的关于 ShareActionProvider 方面的知识，请参照 Action Bar 指南。

Android 信息共享专题之内容接收

Sat, 07 Jan 2012 20:15:54 +0000

如上节课《Android 信息共享之内容发布》所讲，您的应用可以给其他的APP发送内容，同样地，您的应用也可以接收和处理其他APP发送的内容。设计之初，您就应该考虑，如何让您的APP与用户交互，以及您的APP主要处理哪些类型的数据。例如，一个网络社交类的APP可能对纯文本格式的数据感兴趣，像网页的URL地址。 Google+ Android application 则同时对纯文本格式的数据和单张或多张图片类型的数据感兴趣，因为这样可以方便用户在 Gallery APP 浏览图片的时候发送一条附带图片的 Google+ 信息流（Post）。

更新 Manifest 文件

Intent filters 主要用来告诉系统您的APP关心什么类型的系统消息。如前面章节《Android 信息共享之内容发布》构造发送内容的Intent时需要设置Action为ACTION_SEND，那么接收内容同样要告诉系统您的APP对Action为ACTION_SEND的系统消息感兴趣。您需要在 <intent-filter> tag中定义关注的intent filter，比如，您的APP可以用来处理纯文本格式的数据，通用类型的单张图片，或者混合类型的图片列表，那么您的manifest 可能是这样的：

   <activity android:name=".ui.MyActivity" >
   <intent-filter>
      <action android:name="android.intent.action.SEND" />
      <category android:name="android.intent.category.DEFAULT" />
      <data android:mimeType="image/*" />
   </intent-filter>
   <intent-filter>
      <action android:name="android.intent.action.SEND" />
      <category android:name="android.intent.category.DEFAULT" />
      <data android:mimeType="text/plain" />
   </intent-filter>
   <intent-filter>
     <action android:name="android.intent.action.SEND_MULTIPLE" />
     <category android:name="android.intent.category.DEFAULT" />
     <data android:mimeType="image/*" />
   </intent-filter>
   </activity>

注：想了解更多的有关Intent和Intent Filter的资讯请参照《 Intents and Intent Filters》。

假如其他的APP发送了与上面manifest文件中声明的intent filter匹配的数据（通过声明Intent，设置Action值，填充数据，调用startActivity()方法），那么您的APP就会出现在 intent chooser（选择器）中，当用户选择了您的应用程序，对应的activity （如上文声明的 .ui.MyActivity）就会被启动，具体怎么样处理接收到的数据就取决于您的设计了。

处理接收到的数据

要想得到其他APP发送过来的数据，您首先需要调用方法getIntent() 来获得包含数据的Intent对象，一旦您得到了该对象，就可以读取里面的值来决定下一步的动作。有一点您需要注意，如果您的Activity的启动入口不止这一处，比如用户可以通过主界面launcher启动，那么您就应该小心应对此类问题，主要区别是两者 Intent包含的内容不同。

Android 信息共享专题之内容发布

Fri, 06 Jan 2012 20:03:18 +0000

构造和触发一个Intent，需要先要指定其Action。Android系统已经预定义了很多Action，其中的ACTION_SEND用来做数据分享，可以把数据从一个Activity发送到另一个Activity，甚至跨越进程边界的限制。要想给其他的Activity发送内容，您需要做的是构造一个Intent，设置Action类别为ACTION_SEND，把数据填充到该Intent中，并且设置正确的数据的类型，最后触发该Intent，这样系统就会选择最合适的目标Activity来接收和处理该数据。如果候选的目标Activity多于一个，则系统通常会弹出一个对话框让用户来选择，如果候选的目标Activity只有一个，那么系统就会直接启动该Activity来处理数据。同样地，您自己的应用程序也可以在manifest文件中声明可以处理的数据类型，这样当其他Activity发送此种类型的数据时，系统就会将您的App列入到候选名单中。

数据的共享常应用在社会化分享的APP中，方便用户快速和简单的分享自己的共享信息。

注意：最简单的在ActionBar中添加一个"share action item"的方法是使用ShareActionProvider，其要求API level 14，将在后面的章节讨论。

发送文本数据

数据分享最常用的是Activity之间发送文本内容，例如，系统的内置浏览器可以共享当前正在浏览页面的URL地址，以纯文本的数据格式存储，这非常有助于用户通过Email或者社会化分享APP分享有趣的文章链接和网站链接。

示例代码：

   Intent sendIntent = new Intent();
   sendIntent.setAction(Intent.ACTION_SEND);
   sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
   sendIntent.setType("text/plain");
   startActivity(sendIntent);

如果当前设备里安装的所有应用程序中其中有一个APP的intent filter设置了ACTION_SEND，并且声明的数据类型匹配纯文本（text/plain）格式，那么系统就会启动它，若此时匹配的APP个数多于一个，系统会弹出一个选择对话框(a “chooser”) ，让用户从中选择处理该数据的APP。若您触发该Intent的时候使用了[Intent.createChooser()](http://developer.android.com/reference/android/content/Intent.html#createChooser(android.content.Intent, java.lang.CharSequence)) ，那么系统总是会弹出选择对话框(a “chooser”) 让用户选择，这么做有如下优点。

即使用户以前选择过默认的处理APP，系统还是会弹出选择器让用户可以重新选择
如果没有任何匹配的APP可以处理该数据，那么系统会有提示信息
您可以为选择器对话框设定自定义标题

示例代码：

   Intent sendIntent = new Intent();
   sendIntent.setAction(Intent.ACTION_SEND);
   sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
   sendIntent.setType("text/plain");
   startActivity(Intent.createChooser(sendIntent, getResources().getText(R.string.send_to));

ACTION_SEND Intent　选择器对话框如下面图示

可选地，您也可以在Intent中设置一些标准的附加参数，比如EXTRA_EMAIL, EXTRA_CC, EXTRA_BCC,　EXTRA_SUBJECT，除非目标APP会使用该数据，不然也没有什么副作用。通常如果您设计的应用程序可以用来接收和处理该数据，那么应该使用它们。

注意：某些Email邮件处理程序，比如Gmail，需要的是一个字符串数组类型（String[] for extras like EXTRA_EMAIL and EXTRA_CC），那么您应该使用[putExtra(String, String[])](http://developer.android.com/reference/android/content/Intent.html#putExtra(java.lang.String, java.lang.String[])) 来添加附加参数。

发送二进制数据

与发送文本格式的数据类似，构造一个Intent其Action为ACTION_SEND，设定正确的MIME类型，填充数据的URI 到Intent的键值 EXTRA_STREAM中，最后触发该Intent就可以了。共享二进制数据最常用的是图片数据的分享，其他任何的二进制数据都可以分享，只要设定了正确的MIME类型。

Android 用户管理专题之创建自定义帐户类型

Thu, 05 Jan 2012 20:39:40 +0000

到目前为止，我们学习和讨论的都是利用Google的账户来访问Google的在线服务，假如您有自己的在线服务，却没有Google类型的账户，这个时候该怎么办呢？本节课的目的就是来解决上面提到的问题，为自己的在线服务创建一个自定义的账户类型，并且像设备的内置账户一样的方式工作。

创建自定义账户

要想创建一个新的自定义类型的账户，首先要做的工作是生成用户凭据（credentials），该过程可以很简单，比如要求用户输入账户名和密码，也可以复杂一些，要求用户设置一次性密码或启用生物特征扫描（如视网膜扫描，指纹识别）。不论是哪种方式，这是您必须要做的工作。

具体包括：

收集用户凭据
将用户凭据同在线服务进行身份认证
存储认证过的用户凭据

通常这三个步骤可以在一个 activity 中完成，我们可以将这个activity 称之为认证 activity （authenticator activity）。

因为 authenticator activity 需要访问系统的账户管理器 AccountManager，比普通的 activity 有更多的权限要求，Android framework 为了方便应用程序的开发，特意提供了一个基类 AccountAuthenticatorActivity，您可以通过继承该类来实现自定义的账户验证器。

前两个步骤（收集凭据和服务验证）如何实现完全取决于您应用程序的设计，最后一个步骤（存储凭据）是一个标准的实现，代码如下：

 final Account account = new Account(mUsername, your_account_type);
 mAccountManager.addAccountExplicitly(account, mPassword, null);

智能安全

需要特别注意的是：AccountManager 本身并不对用户凭据（credentials）做任何的加密处理，以纯文本的方式进行存储，在大部分的设备上，这都没有问题，因为 credentials 保存在只有 root 权限才能读取的数据库中，但是对于已经 root 解锁的设备来说，就有可能出现问题，此时任何人可通过 adb 工具来读取系统中存储的 credentials 信息。

考虑到这些因素，您就不应该简单的把用户的实际密码通过 AccountManager.addAccountExplicitly() 来保存，相反，应该存入一个更加安全的加密的安全令牌来抵御安全攻击。如果您的用户凭据用来保护非常有价值的数据，您在设计的时候应该慎重考虑。

Remember

: When it comes to security code, follow the “Mythbusters” rule: don’t try this at home! Consult a security professional before implementing any custom account code.

Android 用户管理专题之基于OAuth2协议的服务认证

Wed, 04 Jan 2012 23:34:56 +0000

为了能安全地访问在线服务，必须要验证用户的身份，即需要用户提供证明自己身份的认证信息。如果一个应用程序要访问第三方服务提供商的数据，那么安全验证问题更加复杂，此时不仅需要验证用户的身份信息，还要验证应用程序的信息，以此来保证应用程序只能访问获得了用户授权的那部分服务和数据。

目前用来解决应用程序和第三方服务提供商授权认证的标准协议是 OAuth2，它本身只提供了一个值，即授权令牌（auth token）。它代表了用户的授权和应用程序按照用户授权的范围能够进行的数据访问与操作。本节课展示了怎样通过 OAuth2 协议来认证和访问 Google 的一个服务（服务方必须支持 OAuth2 协议），虽然本节课的例子只是针对 Google Service，其他的任何第三方服务提供商只要支持 OAuth2 协议，本文中提到的技术解决方案也同样适用。

使用 OAuth2 的优势：

通过获得用户授权的账户来访问在线服务
按照用户的意愿进行授权应用程序的访问控制
处理授权和认证错误

前期准备

开始进行 OAuth2 认证之前，您首先需要获得服务方提供的 API 信息，具体包括：

服务提供方的 API 请求地址
访问类型（认证范围-auth scope），一个字符串类型的数据，用来标志应用程序申请的特定类型的认证。例如，auth scope 是 View your tasks，那么就是 read-only（只读）方式访问 Google Tasks 服务，如果 auth scope 是 Manage Your Tasks，那么就是 read-write（读写）方式访问Google Tasks 服务。
client id 和 **client secret，**同样是字符串类型，用来唯一标志访问在线服务的应用程序，也就是您自己接下来要发开的应用程序，这些信息可以从服务提供商那里直接获得。Google 提供了一个自助服务器来方便用户申请。您可以通过阅读这篇文章《Getting Started with the Tasks API and OAuth 2.0 on Android》来了解怎么样申请Google 的 Tasks 服务。

获得访问令牌（Auth Token）

获得访问令牌的步骤参照下图：

WordPress 使用 Flickr 做图床

Mon, 02 Jan 2012 18:03:07 +0000

今天早上到博客转了一圈，发现博客里面的所有图片都变成XX了，毫无疑问，所有的图片链接都失效了。

一开始没明白是怎么回事，以为是网站挂掉了，想想也不是，文字还是会正常显示出来的，那就只有一个问题了，图床出问题了。

当初一开始博客建立在新浪的 SAE 上面，后来迁移至此，所有以前博文的图片都还放在 SAE 的 storage 上面，我赶快登陆storage的后台进行查看，看看到底图片出什么问题了，一看心都凉了，所有的图片都没了，连 upload 文件夹都木有了，写 wordpress 的孩子你是懂得的，upload 文件夹放神马东西。我又赶快查看了新浪官方的 SAE 博客，发现它的图片也变 XX 了，到此，问题基本也眉目了，估计了过了个新年，什么以数字文件夹命名的出问题了，或者是服务器在维护，先不管那么多了，官方的博客都出问题了，我的出问题也就正常了。

然后在网上找其他的图床平台，毕竟自己的 VPS 放太多图片，流量变大耗费不起啊，想着很久以前就利用 flickr 做过图床，网上找了一个wordpress 的插件 wordpress-flickr-manager，无奈，作者很久都不维护了，放在最新的 wordprss3.3 上面无法工作，还是自立更生吧，动手调试，修改，终于可以正常工作了。

修改过的 wordpress-flickr-manager 可从我的google code里面下载，下载链接：wordpress-flickr-manager.zip 友情提示：插件已正式更名为 wpflickr，官方下载地址为：http://wordpress.org/extend/plugins/wpflickr/

和其他的插件使用类似，下载后解压到 plugins 文件夹下面，并激活。然后到“设置”选项下的 “Flickr” 下面进行自己 Flickr 帐号的绑定，其他的配置选项保留默认就行。

那么在编写博文的时候，上传或插入媒体的控件旁边就会多出一个 “ Add Flickr Photo “ 的图标，点击它进行图片的上传，就可以直接将图片上传到绑定的 flickr 账户中，选择了图片的大小及其他参数后，可以插入到博文中。

示例图片：上面的这张图片就是利用该插件上传到我的 flickr 账户中的，如果您能看到，说明该插件是工作正常的。

好了，希望大家下载使用，如有神马问题，联系我即可！

Android 用户管理专题之记录用户身份

Sun, 01 Jan 2012 10:56:03 +0000

每个人都喜欢自己的名字被他人记住，同样地，如果想让您的应用程序更人性化，为不同的用户提供不同的用户体验，以及自定义配置，那么就需要记录用户的个人信息。当用户从旧的设备更新到新的设备，或者从一台设备切换到另一台设备上面（例如用户拥有一台平板电脑和手机，并且经常在两者之间切换），您的应用应当可以准确识别出用户，那么如何才能区分用户和记录用户信息，并且准确地鉴别用户身份，本文的目的就是要解决上面提到的问题。

对于大多数应用来说，账户管理器 AccountManager 就足够了，利用其提供的API，只要获得用户的权限许可，就可以很容易地取得当前设备上已经存储的用户账户名信息。

集成用户帐号的管理，可以让您的应用程序完成如下的功能：

表格的自动填写（如用户的 Email 地址信息）
记录和获得与用户身份绑定的ID，而不仅仅是设备的ID

账户管理器 AccountManager 是否适合您的应用程序

应用程序通常使用如下的3种技术来进行账户的管理：

要求用户填写账户名称
识别当前应用程序运行的设备信息，记录设备的ID
通过系统提供的 AccountManager来获取当前设备已记录的用户信息

方案（1）的缺点如下：首先，每次启动应用程序之前都需要输入用户名的信息，程序显得不太友好，吸引力不足，其次，没有好的办法来保证用户名的唯一性。

方案（2）较方案（1）来说为用户减轻了一点负担，但是它很难保证用户的准确性。因为您的应用程序仅仅是与具体的设备绑定在了一起，想象一下，用户从一台旧设备升级到了新设备，在新设备上面运行应用的时候，您的应用程序就不再记得该用户了。

方案（3）是首选的解决方案，通过利用系统提供的 AccountManager，您可以获取当前设备上面已经存储的用户身份信息，不论用户拥有多少台设备，只要用户登录了该设备，那么您就可以准确地识别该用户。对于您应用程序的设计来说，也仅仅是加入几个多余的 UI 界面而已。

设计不同的账户类型

Android 设备可以存储不同类型的账户信息，当您通过 AccountManager 来进行账户查询的时候，通常需要利用账户类型来进行过滤，账户类型（account type）是一个字符串，要求唯一性，用来和系统中已存储的其他类型的账户进行区分，例如，Google 的账户类型是 “com.google”,Twitter 的账户类型是 “com.twitter.android.auth.login”，当然可以利用自己的个人域名来进行区分，例如 “com.zhourunsheng.com”。

申请获得用户账户信息的权限 GET_ACCOUNT

如果要读取当前设备上面的账户信息，您的应用需要 GET_ACCOUNTS 权限，在 manifest 文件的<uses-permission>tag 中添加示例代码

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

用户帐号查询

一旦确定了账户的类型，您就可以通过 AccountManager 来进行查询了。首先通过调用 AccountManager.get() 来获得一个 AccountManager 实例对象，然后调用它的成员函数 getAccountsByType()，通过传递账户类型的参数，就能得到该账户类型下面的所有用户的一个用户列表。

示例代码

AccountManager am = AccountManager.get(this); // "this" references the current Context

Account[] accounts = am.getAccountsByType("com.google");

函数调用返回一个包含所有帐号 Account 的数组。

Android 电源管理专题之管理广播接收器 Broadcast Receivers

Sat, 31 Dec 2011 21:14:58 +0000

最简单的监测设备状态变更的做法就是为每一个状态的变化都创建一个对应的 BroadcastReceiver，然后在 BroadcastReceiver 的实现代码中，取得设备当前的状态来调整应用程序的运行任务。

但是这样做有一个缺点就是可能您的应用程序会过于频繁的唤醒设备来处理状态的变更，这往往不是您期待的结果。

一个更好的解决办法就是在程序的运行过程中动态的启用和禁用广播事件接收器，这样您就可以只启用目前最关心的广播事件接听器，而禁用掉现在并不需要的事件接听器。

动态切换和级联事件接器

您可以使用 PackageManager 来管理 manifest 中声明的广播接收器，示例代码展示了如何利用这一技术来启用和禁用相应的广播接收器。

ComponentName receiver = new ComponentName(context, myReceiver.class);

PackageManager pm = context.getPackageManager();

pm.setComponentEnabledSetting(receiver,
PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
PackageManager.DONT_KILL_APP)

通过使用这一技术，如果设备当前处在未联网的状态，那么您的应用程序可以禁用除网络事件接收器以外所有其他的广播事件接听器。相反，一旦您确定设备已经连接到了网络，那么就可以停止监听网络状态变化的监听器，然后简单检查一下是否能连接互联网，如果能的话就可以执行应用程序的数据更新任务了。

同样，您也可以使用该技术来延迟启动一个需要较高带宽的大网络文件的下载，通过简单注册一个网络连接状态切换的事件监听器，只有当设备切换到 wi-fi 状态的时候才启动文件的下载工作。

参考文摘：

http://developer.android.com/training/monitoring-device-state/manifest-receivers.html

Android 电源管理专题之获取和监测网络连接状态

Fri, 30 Dec 2011 21:16:23 +0000

设定周期性的闹铃提醒和后台服务，最常见的用途是定期更新应用程序的数据，从互联网上下载资源，缓存数据或者执行长时间的下载任务。但是如果设备当前没有连接到网络，或者是网络状况不稳定，连接太慢，不能正常完成数据的下载任务，那么此时仍需要唤醒设备来更新数据么？

您可以通过 ConnectivityManager 来检查设备当前是否连接到了网络，如果已连接，具体是连接到哪种类型的网络。

检测网络连接状态

如果设备当前没有连接到任何网络，那么您的应用程序也就没有必要安排定时的数据更新任务。

示例代码展示了如何利用 ConnectivityManager 来查询当前活跃的可连接网络，以及设备目前是否已经联网。

ConnectivityManager cm =
(ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);

NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
boolean isConnected = activeNetwork.isConnectedOrConnecting();

检测网络的类型

目前 Android 设备支持的网络类型有移动网络，WiMAX，Wi-Fi和以太网。

通过查询当前激活的网络类型，可以获得网络带宽等信息，然后据此调整您应用程序的后台数据刷新频率。

示例代码

boolean isWiFi = activeNetwork.getType() == ConnectivityManager.TYPE_WIFI;

移动网络的费用要明显高于无线网络的费用，因此，在大多数情况下，如果当前设备连接的是移动网络，那么您应用程序的后台数据更新频率应尽可能保持比较低的状态，同样地，如果要下载一个较大的网络文件，在移动网络下应该暂停下载工作，等设备重新连接到了无线网络的环境再恢复下载工作。

虽然已经暂停了应用程序的后台更新操作，您的应用程序还是应该时刻监测当前设备网络的变化，一旦设备连接上了合适的网络环境（比如wi-fi），那么暂停的任务就可以重新开始执行了。

监测网络连接的变化

一旦设备连接的网络环境发生变化，系统的 ConnectivityManager 会广播一个类型为 CONNECTIVITY_ACTION (“android.net.conn.CONNECTIVITY_CHANGE “) 的通知消息，您可以在应用程序的 manifest 文件中定义相应的广播接收器receiver，然后根据网络环境的变化来适当调整程序数据的更新频率。

示例代码

<action android:name="android.net.conn.CONNECTIVITY_CHANGE"/>

网络环境的变化可能会非常频繁，只要设备的网络环境在无线网络和移动网络之间来回切换的时候，系统都会广播网络变化的通知，比较好的做法是，只有当您的更新程序此时处于暂停的状态，并且在网络连接上的时候需要恢复暂停工作的执行，那么应当注册和监听网络变化的广播，如果接收到广播通知，只需要检查网络是否已经连接上了，如果网络已经连接，那么应用程序就可以开始数据，否则的话，仍旧保持在暂停的状态，一直等到网络重新连接上了，再恢复任务的执行。

我们需要这样一种解决方法可以使您方便的注册和注销 manifest 中声明的广播接收器 Receivers，在下一节课再继续讨论。

参考文摘：

https://developer.android.com/training/monitoring-device-state/connectivity-monitoring.html

Android 电源管理专题之获取和监测Dock状态和类型

Tue, 27 Dec 2011 21:20:16 +0000

Android 设备可以接在不同类型的 Dock 底座中，其中包括车载的，家用的，以及数字的和模拟的。许多 Dock 基座都能为接在其上面的设备供电，所以，“dock-state”（Dock状态）也通常是接入设备的充电状态。

Dock 状态的变化如何影响您应用程序的服务更新速度取决于您应用程序的设计。假如是一个获取体育赛况的应用程序，那么在 “desktop dock” 状态时，可以提高其数据的更新频率，而当在 “car docked” 状态时，可以完全禁用数据的更新。相反，假如该应用程序是用来获取当前交通路况的，那么就应当在“car docked” 状态时选择最大限度提高数据的更新速度。

系统会广播 “sticky” 类型的 Dock 状态通知 Intent，您可以通过该 Intent 来查询设备当前是否在 Dock 状态，以及具体的 Dock 类型。

获得当前的 Dock 状态

Dock 状态的详细信息可以从 Action 为 ACTION_DOCK_EVENT 中的广播数据中取得，因为广播类型是 “sticky”的，您不需要自己定义 BroadcastReceiver，只需要调用 registerReceiver() 方法，并且传入空的参数 null 就可以了。

该方法的返回值 intent 就包括了当前 Dock 状态的详细信息。

示例代码：

IntentFilter ifilter = new IntentFilter(Intent.ACTION_DOCK_EVENT);
Intent dockStatus = context.registerReceiver(null, ifilter);

您可以通过键值 EXTRA_DOCK_STATE 来取得当前的 Dock 状态。

示例代码：

int dockState = battery.getIntExtra(EXTRA_DOCK_STATE, -1);
boolean isDocked = dockState != Intent.EXTRA_DOCK_STATE_UNDOCKED;

获得当前的Dock 类型

如果设备当前在Dock状态，那么目前支持的Dock类型如下：

Android 电源管理专题之监测电池电量和充电状态

Mon, 26 Dec 2011 21:38:34 +0000

通过检查设备当前的电池电量和充电状态，然后适当改变后台服务的更新频率，可以有效降低电量的消耗。所以您的应用程序的更新频率也应当根据设备当前的电池电量和充电状态来进行动态调整。

通常情况下，当设备在充电的过程中，可以提高应用程序的数据更新频率，因为此时电池电量的消耗相较于充电的过程耗费很小，基本可以忽略。相反，如果电池是在正常的使用过程中，那么应当合理调整应用程序的更新频率，不能更新太频繁，这样有助于延长电池的使用寿命。

同时，应用程序应当一直监视设备电量的状态变化，在设备电量不足时，尽量降低更新频率，或者干脆停止数据更新。

获取当前的电池状态

BatteryManage r 会发送“ sticky ”类型的系统广播，在 Intent 中包括了当前的电池电量状态和充电状态等信息。

因为电池状态的广播类型是 “sticky”类型的，所以我们不需要注册相应的BroadcastReceiver。只需要在调用 registerReceiver 的时候传递空参数 null 就可以，然后函数的返回值 intent 中就包括了当前电池状态的各种信息。

当然您也可以传递一个自定义的 BroadcastReceiver，在后面的章节里面有介绍，不过实际上也是没有什么必要的。

示例代码：

IntentFilter ifilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
Intent batteryStatus = context.registerReceiver(null, ifilter);

从返回的 Intent 中我们可以获得当前的充电状态和充电类型，是通过USB，还是AC充电器?

// Are we charging / charged?
int status = batteryStatus.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
boolean isCharging = status == BatteryManager.BATTERY_STATUS_CHARGING ||
status == BatteryManager.BATTERY_STATUS_FULL;

// How are we charging?
int chargePlug = battery.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
boolean usbCharge = chargePlug == BATTERY_PLUGGED_USB;
boolean acCharge = chargePlug == BATTERY_PLUGGED_AC;

通常情况下，在AC充电器的情况下，您可以最大化应用程序的更新频率，如果是在USB充电的状态下，适当降低更新频率，而如果是在非充电的时候，您应当将更新频率降到最低的情况，以合理利用电量。

Android 音乐编程专题之管理音频硬件

Thu, 22 Dec 2011 21:22:04 +0000

Android 系统通常支持多种音频设备，常见的有手机内置扬声器，插孔式有线耳机，蓝牙 A2DP(蓝牙立体声音频传输规范（A2DP）)设备。

获取当前正在播放音频的硬件信息

使用不同的硬件设备可能会影响您应用程序的设计方式，您可以通过 AudioManager 来查询当前正在播放音频的硬件设备信息，是内置扬声器，还是有线耳机，或者是蓝牙设备。

示例代码如下：

if (isBluetoothA2dpOn()) {
   // Adjust output for Bluetooth. 蓝牙设备
} else if (isSpeakerphoneOn()) {
   // Adjust output for Speakerphone. 内置扬声器(免提)
} else if (isWiredHeadsetOn()) {
   // Adjust output for headsets 有线耳机
} else {
   // If audio plays and noone can hear it, is it still playing? 未知设备
}

处理音频播放硬件的状态变化

当耳机线脱落，蓝牙设备断开，音频输出流会自动切换到内置扬声器。如果此时您正在大声播放音乐，这可能不是您期待的结果。

不过也不用担心，当出现硬件设备切换的时候，Android 会发送系统广播 ACTION_AUDIO_BECOMING_NOISY，您的应用程序中应该注册一个 BroadcastReceiver 来监听这个消息，当出现这种情况的时候，如果正在听音乐，较好的设计方案是暂停当前音乐的播放，如果正在玩游戏，那么尽量降低游戏的音量是个不错的解决方法。

示例代码如下：

private class NoisyAudioStreamReceiver extends BroadcastReceiver {
  @Override
  public void onReceive(Context context, Intent intent) {
    if (AudioManager.ACTION_AUDIO_BECOMING_NOISY.equals(intent.getAction())) {
       // Pause the playback
    }
  }
}

private IntentFilter intentFilter = new IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY);

private void startPlayback() {
   registerReceiver(myNoisyAudioStreamReceiver(), intentFilter);
}

private void stopPlayback() {
   unregisterReceiver(myNoisyAudioStreamReceiver);
}

参考文摘：http://developer.android.com/training/managing-audio/audio-output.html

Android 音乐编程专题之管理音频焦点

Wed, 21 Dec 2011 21:14:58 +0000

因为系统中可能会有多个应用程序会播放音频，所以需要考虑他们之间该如何交互，为了避免多个应用程序同时播放音乐，Android 系统使用音频焦点来进行统一管理，即只有获得了音频焦点的应用程序才可以播放音乐。

您的应用程序在开始播放音频文件前，首先应该请求获得音频焦点，并且应该同时注册监听音频焦点的丢失通知，即如果音频焦点被系统或其他的应用程序抢占时，您的应用程序可以做出合适的响应。

获取音频焦点

您的应用程序在开始播放任何音频之前，首先应该持有流的音频焦点。

可以通过调用 requestAudioFocus() 来实现，如果请求成功，返回 AUDIOFOCUS_REQUEST_GRANTED。

您必须指定流类型（使用的是哪一个流）和音频焦点的类型（短暂的或是持久的）。

瞬态焦点用来播放很短时间的音频（例如，播放导航指令）。

持久焦点用来播放较长一段时间的音频（例如，播放音乐）。

下面的代码片断演示了请求音乐音频流的永久音频焦点。

例如当用户按下播放背景音乐的按键，您应该立即请求音频焦点，当成功获得了焦点后再开始播放音乐。

AudioManager am = mContext.getSystemService(Context.AUDIO_SERVICE);
...

// Request audio focus for playback
int result = am.requestAudioFocus(afChangeListener,
// Use the music stream.
AudioManager.STREAM_MUSIC,
// Request permanent focus.
AudioManager.AUDIOFOCUS_GAIN);

if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
    am.unregisterMediaButtonEventReceiver(RemoteControlReceiver);
    // Start playback.
    // 开始播放音乐文件
}

一旦您的应用程序完成了播放，请记得要调用 abandonAudioFocus() 方法来通知系统释放音频焦点，同时注销相关的 AudioManager.OnAudioFocusChangeListener。这样当您的应用程序释放了音频焦点，则系统会允许其他被中断的应用程序重新获取该焦点来继续播放。

// Abandon audio focus when playback complete
am.abandonAudioFocus(afChangeListener);

当请求瞬态音频焦点时有一个附加参数可供设置，即是否允许 “DUCK”。通常当应用程序失去了音频焦点时应该停止播放。如果获取短暂音频焦点的时候设置了"DUCK" 附加参数，则允许其他的应用程序继续播放，不需要停止，只要降低音量就可以了，然后直到您的应用程序释放了焦点，其他应用程序再重新获得的时候，将音量还原到有一开始的状态。

// Request audio focus for playback
int result = am.requestAudioFocus(afChangeListener,
// Use the music stream.
AudioManager.STREAM_MUSIC,
// Request permanent focus.
AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK);

if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
  // Start playback.
}

“DUCK” 特别适合那种间歇性播放音频流的应用程序，如驾驶导航的声音提示。

Android 音乐编程专题之控制应用程序的音量和播放

Tue, 20 Dec 2011 21:03:17 +0000

识别音频流

创造优秀音频体验的第一步是了解您的应用程序将使用的音频流类型。

Android 系统保持相互独立的音频流通道来播放音乐，报警，通知，来电铃声，系统声音，呼叫（通话）音量，和 DTMF 音调（键盘拨号）。

这样做主要是为了使用户能够独立地控制每个流的音量。

多数的流仅限于系统事件，所以，除非您的应用程序是要更换闹钟，否则几乎可以肯定的是使用 STREAM_MUSIC 音频流。

使用硬件音量按键来控制应用程序的音量

默认情况下，按音量键控制修改当前获得焦点的音频流的音量。假如您的应用程序当前不是正在播放音乐，或者没有运行，那么音量键将会调整振铃的音量。

如果您有一个游戏或音乐应用程序，当用户点击音量键的时候，即使他们目前正在浏览歌曲，或者没有停留在当前的音乐游戏的位置，他们仍然希望控制游戏或音乐的音量。

您可以通过接收音量控制键的按键消息来修改当前的音频流音量。不过不用那么麻烦，Android 已经提供了方便的 setVolumeControlStream() 方法来根据您指定的音频流来自动调节音量。

首先确定您的应用程序将使用的音频流，然后通过 setVolumeControlStream 方法设置其为当前焦点的音频流。

这个方法应该被及早调用，并且在生命周期中只需要调用一次即可，所以通常应在 Activity 或者 Fragment 的 OnCreate() 内调用。

这将确保只要你的应用程序是可见状态的，音量控制功能就是用户所期望的效果(即控制当前应用程序的音量)。

代码示例：

setVolumeControlStream(AudioManager.STREAM_MUSIC);

从现在开始，按设备上的音量键将影响您指定的（示例“音乐”）的音频流。

使用硬件播放控制按键来控制应用程序的音频播放

很多手机和许多无线耳机都附带有媒体播放控制按钮，如播放，暂停，停止，跳过。每当用户按下这些硬件键，系统就会广播 ACTION_MEDIA_BUTTON 动作。

为了响应媒体按钮的点击事件，您需要注册 BroadcastReceiver 来监听广播。

代码示例：

<receiver android:name=".RemoteControlReceiver">
  <intent-filter>
     <action android:name="android.intent.action.MEDIA_BUTTON" />
  </intent-filter>
</receiver>

Receiver 中需要知道到底是按下了哪个键的具体信息，Intent 中包括了 EXTRA_KEY_EVENT 键值，可以通过它来取得 KeyEvent 类型的值，KeyEvent中的 KEYCODE_MEDIA_*静态常量表示了所有的媒体按钮类型，如 KEYCODE_MEDIA_PLAY_PAUSE 和 KEYCODE_MEDIA_NEXT 等等。

代码示例：

public class RemoteControlReceiver extends BroadcastReceiver {
  @Override
  public void onReceive(Context context, Intent intent) {
    if (Intent.ACTION_MEDIA_BUTTON.equals(intent.getAction())) {
      KeyEvent event = (KeyEvent)intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
      if (KeyEvent.KEYCODE_MEDIA_PLAY == event.getKeyCode()) {
        // Handle key press.
        // 处理播放按键的消息
      }
   }
 }
}

因为多个应用程序可能会接听和响应媒体按键消息，您必须以编程方式控制您的应用程序何时应该接受媒体按钮事件。

生活杂记之2011-12-20

Tue, 20 Dec 2011 20:02:58 +0000

今天来博客转了一圈，发现博文内容已经是一个月以前的了，最近项目内容太多，一直无暇顾及。

还好，上周总算是第一阶段平稳过去了，趁着这段时间再回顾点Android的内容吧。

回想起来，已经有半年多的时间没有接触Android的项目开发了。

Google 最近推出了一套Android Training的课程，个人感觉还不错，阅读了几个课题后，发现收获还是蛮大的，在此也向各位喜欢Android开发的人员推荐一下，官方网址请参照：http://developer.android.com/training/index.html.

自己建立博客的初衷也就是要达到内容分享的目的和整理自己的学习笔记和学习心得，那么接下来的几天时间，正好可以把这几个专题翻译一下，既做了笔记，又加深了理解，算是个两全其美的办法吧！

如果各位有发现更好的文章或者博客内容，欢迎推荐给我，联系信息可在“关于我”的页面中找到。

记录一批优秀的学习资料和文章到一处是个不错的想法，现在开始行动！！！

PhoneGap 之 Android 端插件开发

Wed, 02 Nov 2011 21:33:53 +0000

前面一篇文章《移动 APP 之跨平台解决方案》介绍了一种跨平台的解决方案，即用开发web app的方式来编写mobile app。鉴于PhoneGap才刚刚新起，还有许多功能因为平台的差异性无法很好的解决，所以我们在实际的开发中，发现有很多功能还需要完善，一种比较好的方式就是编写平台依赖的插件，进而扩展PhoneGap的功能。

本文介绍一下开发和使用插件的一个流程，以 VideoPlayer 为例。

环境搭建，下载 phonegap-android 的源码，下载地址 https://github.com/phonegap/phonegap-plugins
编写video.js，提供给web开发端的接口定义，定义了一个VideoPlayer类和play函数，参数为要播放的文件视频地址，代码如下：

/**
 * Constructor
 */
function VideoPlayer() {
};

/**
 * Starts the video player intent
 *
 * @param url           The url to play
 */
VideoPlayer.prototype.play = function(url) {
    PhoneGap.exec(null, null, "VideoPlayer", "playVideo", [url]);
};

/**
 * Load VideoPlayer
 */
PhoneGap.addConstructor(function() {
    PhoneGap.addPlugin("videoPlayer", new VideoPlayer());
});

编写 Android VideoPlayer 的具体实现代码，VideoPlayer/src/com/phonegap/plugins/video/VideoPlayer.java

package com.phonegap.plugins.video;

import org.json.JSONArray;
import org.json.JSONException;
import android.content.Intent;
import android.net.Uri;
import com.phonegap.api.Plugin;
import com.phonegap.api.PluginResult;

public class VideoPlayer extends Plugin {
    private static final String YOU_TUBE = "youtube.com";

    @Override
    public PluginResult execute(String action, JSONArray args, String callbackId) {
        PluginResult.Status status = PluginResult.Status.OK;
        String result = "";

        try {
            if (action.equals("playVideo")) {
                playVideo(args.getString(0));
            }
            else {
                status = PluginResult.Status.INVALID_ACTION;
            }
            return new PluginResult(status, result);
        } catch (JSONException e) {
            return new PluginResult(PluginResult.Status.JSON_EXCEPTION);
        }
    }

    private void playVideo(String url) {
        // Create URI
        Uri uri = Uri.parse(url);

        Intent intent = null;
        // Check to see if someone is trying to play a YouTube page.
        if (url.contains(YOU_TUBE)) {
            // If we don't do it this way you don't have the option for youtube
            intent = new Intent(Intent.ACTION_VIEW, uri);
        } else {
            // Display video player
            intent = new Intent(Intent.ACTION_VIEW);
            intent.setDataAndType(uri, "video/*");
        }

        this.ctx.startActivity(intent);
    }
}

配置插件, res/xml/plugins.xml 添加如下代码

<plugin name="VideoPlayer" value="com.phonegap.plugins.video.VideoPlayer"/>

编写代码进行调用，文件开头引入js代码框架，然后进行VideoPlayer类的play函数调用

<script type="text/javascript" charset="utf-8" src="phonegap.js"></script>
<script type="text/javascript" charset="utf-8" src="video.js"></script>

 //Sample use:
 /**
    * Display an intent to play the video.
    *
    * @param url           The url to play
    */
 //play(url)

window.plugins.videoPlayer.play("http://path.to.my/video.mp4");
window.plugins.videoPlayer.play("file:///path/to/my/video.mp4");

到此为止，插件的开发和部署，以及调用就都ok了，是不是很简单( ⊙ o ⊙ )啊！

最后向大家推荐一本书籍《PhoneGap Beginner’s Guide》，相信通过本书的学习，就知道了怎样利用PhoneGap来开发跨平台的mobile app了，同时也可以关注 https://github.com/phonegap 项目的最新进展情况和新特性，如果可以的话，贡献自己的力量来进行完善和扩充，O(∩_∩)O~！

移动 APP 之跨平台解决方案

Sat, 29 Oct 2011 10:29:21 +0000

最近看了一本书《Building Android Apps with HTML CSS and JavaScript》，顾名思义就是用开发web的方式来开发Android的APP，其中倒不是web的开发技术最吸我，而是这样的一种解决方案。像我们现在的手持设备种类这么多，主流的不外乎Android，Iphone，Ipad等等，如果要对每一种平台都开发一个相应的APP版本，代价太大。而基于浏览器的web app就容易解决这个问题，只需开发一次，便可以通用部署。

上面即是使用web技术来开发本地iphone app的一幅运行图，关于web的开发技术，这里就不多说了，这里重点提及 Phonegap,利用它我们就可以把web app转换成各种移动平台的APP。

PhoneGap is an HTML5 app platform that allows you to author native applications with web technologies and get access to APIs and app stores. PhoneGap leverages web technologies developers already know best… HTML and JavaScript

这里简单介绍一下PhoneGap，它对各个移动平台的API进行了一次封装，屏蔽了每种移动平台的具体细节，而设计了一个公共的API层，对开发者来说，只要调用统一的API来进行开发就可以了。

把PhoneGap的源代码下载来通读了一下，了解了一下背后的实现原理，下面以Camera的功能为例来进行说明。

API 开发文档请参照 http://docs.phonegap.com/en/1.1.0/index.html，其中有关Camera的开发API请参照

http://docs.phonegap.com/en/1.1.0/phonegap_camera_camera.md.html#Camera，我们的代码就可以写成

navigator.camera.getPicture(onSuccess, onFail, { quality: 50 });
function onSuccess(imageData) {    
  var image = document.getElementById('myImage');    
  image.src = "data:image/jpeg;base64," + imageData;
}
function onFail(message) {    
  alert('Failed because: ' + message);
}

是不是很简单，具体后台平台的差异我们根本不需要来进行区别，全部由PhoneGap来给处理了，那么它是怎么处理的呢，继续往下看。

You’ve got to find what you love

Thu, 06 Oct 2011 12:58:18 +0000

（斯坦福大学的演讲）纪念一位传奇！

You’ve got to find what you love Today I want to tell you three stories from my life. That’s it. No big deal. Just three stories. 我今天很荣幸能和你们一起参加毕业典礼，斯坦福大学是世界上最好的大学之一。我从来没有从大学中毕业。说实话，今天也许是在我的生命中离大学毕业最近的一天了。今天我想向你们讲述我生活中的三个故事。不是什么大不了的事情，只是三个故事而已。The first story is about connecting the dots. 第一个故事是关于如何把生命中的点点滴滴串连起来。I dropped out of Reed College after the first 6 months, but then stayed around as a drop-in for another 18 months or so before I really quit. So why did I drop out? 我在Reed大学读了六个月之后就退学了，但是在十八个月以后——我真正的作出退学决定之前，我还经常去学校。我为什么要退学呢？It started before I was born. My biological mother was a young, unwed college graduate student, and she decided to put me up for adoption. She felt very strongly that I should be adopted by college graduates, so everything was all set for me to be adopted at birth by a lawyer and his wife. Except that when I popped out they decided at the last minute that they really wanted a girl. So my parents, who were on a waiting list, got a call in the middle of the night asking: “We have an unexpected baby boy; do you want him?” They said: “Of course.” My biological mother later found out that my mother had never graduated from college and that my father had never graduated from high school. She refused to sign the final adoption papers. She only relented a few months later when my parents promised that I would someday go to college. 故事从我出生的时候讲起。我的亲生母亲是一个年轻的，没有结婚的大学毕业生。她决定让别人收养我, 她十分想让我被大学毕业生收养。所以在我出生的时候，她已经做好了一切的准备工作，能使得我被一个律师和他的妻子所收养。但是她没有料到，当我出生之后，律师夫妇突然决定他们想要一个女孩。所以我的生养父母（他们还在我亲生父母的观察名单上）突然在半夜接到了一个电话:“我们现在这儿有一个不小心生出来的男婴，你们想要他吗？”他们回答道:“当然！”但是我亲生母亲随后发现，我的养母从来没有上过大学，我的父亲甚至从没有读过高中。她拒绝签这个收养合同。只是在几个月以后，我的父母答应她一定要让我上大学，那个时候她才同意。And 17 years later I did go to college. But I naively chose a college that was almost as expensive as Stanford, and all of my working-class parents’ savings were being spent on my college tuition. After six months, I couldn’t see the value in it. I had no idea what I wanted to do with my life and no idea how college was going to help me figure it out. And here I was spending all of the money my parents had saved their entire life. So I decided to drop out and trust that it would all work out OK. It was pretty scary at the time, but looking back it was one of the best decisions I ever made. The minute I dropped out I could stop taking the required classes that didn’t interest me, and begin dropping in on the ones that looked interesting. 在十七岁那年，我真的上了大学。但是我很愚蠢的选择了一个几乎和你们斯坦福大学一样贵的学校, 我父母还处于蓝领阶层，他们几乎把所有积蓄都花在了我的学费上面。在六个月后, 我已经看不到其中的价值所在。我不知道我想要在生命中做什么，我也不知道大学能帮助我找到怎样的答案。但是在这里，我几乎花光了我父母这一辈子的所有积蓄。所以我决定要退学，我觉得这是个正确的决定。不能否认，我当时确实非常的害怕, 但是现在回头看看，那的确是我这一生中最棒的一个决定。在我做出退学决定的那一刻, 我终于可以不必去读那些令我提不起丝毫兴趣的课程了。然后我还可以去修那些看起来有点意思的课程。It wasn’t all romantic. I didn’t have a dorm room, so I slept on the floor in friends’ rooms, I returned coke bottles for the 5¢ deposits to buy food with, and I would walk the 7 miles across town every Sunday night to get one good meal a week at the Hare Krishna temple. I loved it. And much of what I stumbled into by following my curiosity and intuition turned out to be priceless later on. Let me give you one example: 但是这并不是那么罗曼蒂克。我失去了我的宿舍，所以我只能在朋友房间的地板上面睡觉，我去捡5美分的可乐瓶子，仅仅为了填饱肚子, 在星期天的晚上，我需要走七英里的路程，穿过这个城市到Hare Krishna寺庙（注：位于纽约Brooklyn下城）,只是为了能吃上饭——这个星期唯一一顿好一点的饭。但是我喜欢这样。我跟着我的直觉和好奇心走, 遇到的很多东西，此后被证明是无价之宝。让我给你们举一个例子吧：Reed College at that time offered perhaps the best calligraphy instruction in the country. Throughout the campus every poster, every label on every drawer, was beautifully hand calligraphed. Because I had dropped out and didn’t have to take the normal classes, I decided to take a calligraphy class to learn how to do this. I learned about serif and san serif typefaces, about varying the amount of space between different letter combinations, about what makes great typography great. It was beautiful, historical, artistically subtle in a way that science can’t capture, and I found it fascinating. Reed大学在那时提供也许是全美最好的美术字课程。在这个大学里面的每个海报, 每个抽屉的标签上面全都是漂亮的美术字。因为我退学了, 没有受到正规的训练, 所以我决定去参加这个课程，去学学怎样写出漂亮的美术字。我学到了san serif 和serif字体, 我学会了怎么样在不同的字母组合之中改变空格的长度, 还有怎么样才能作出最棒的印刷式样。那是一种科学永远不能捕捉到的、美丽的、真实的艺术精妙, 我发现那实在是太美妙了。None of this had even a hope of any practical application in my life. But ten years later, when we were designing the first Macintosh computer, it all came back to me. And we designed it all into the Mac. It was the first computer with beautiful typography. If I had never dropped in on that single course in college, the Mac would have never had multiple typefaces or proportionally spaced fonts. And since Windows just copied the Mac, its likely that no personal computer would have them. If I had never dropped out, I would have never dropped in on this calligraphy class, and personal computers might not have the wonderful typography that they do. Of course it was impossible to connect the dots looking forward when I was in college. But it was very, very clear looking backwards ten years later. 当时看起来这些东西在我的生命中，好像都没有什么实际应用的可能。但是十年之后，当我们在设计第一台Macintosh电脑的时候，就不是那样了。我把当时我学的那些家伙全都设计进了Mac。那是第一台使用了漂亮的印刷字体的电脑。如果我当时没有退学, 就不会有机会去参加这个我感兴趣的美术字课程, Mac就不会有这么多丰富的字体，以及赏心悦目的字体间距。那么现在个人电脑就不会有现在这么美妙的字型了。当然我在大学的时候，还不可能把从前的点点滴滴串连起来，但是当我十年后回顾这一切的时候，真的豁然开朗了。Again, you can’t connect the dots looking forward; you can only connect them looking backwards. So you have to trust that the dots will somehow connect in your future. You have to trust in something – your gut, destiny, life, karma, whatever. This approach has never let me down, and it has made all the difference in my life. 再次说明的是，你在向前展望的时候不可能将这些片断串连起来；你只能在回顾的时候将点点滴滴串连起来。所以你必须相信这些片断会在你未来的某一天串连起来。你必须要相信某些东西：你的勇气、目的、生命、因缘。这个过程从来没有令我失望（let me down）,只是让我的生命更加地与众不同而已。My second story is about love and loss. 我的第二个故事是关于爱和损失的。I was lucky – I found what I loved to do early in life. Woz and I started Apple in my parents garage when I was 20. We worked hard, and in 10 years Apple had grown from just the two of us in a garage into a billion company with over 4000 employees. We had just released our finest creation – the Macintosh – a year earlier, and I had just turned 30. And then I got fired. How can you get fired from a company you started? Well, as Apple grew we hired someone who I thought was very talented to run the company with me, and for the first year or so things went well. But then our visions of the future began to diverge and eventually we had a falling out. When we did, our Board of Directors sided with him. So at 30 I was out. And very publicly out. What had been the focus of my entire adult life was gone, and it was devastating. 我非常幸运, 因为我在很早的时候就找到了我钟爱的东西。Woz和我在二十岁的时候就在父母的车库里面开创了苹果公司。我们工作得很努力, 十年之后, 这个公司从那两个车库中的穷光蛋发展到了超过四千名的雇员、价值超过二十亿的大公司。在公司成立的第九年，我们刚刚发布了最好的产品，那就是Macintosh。我也快要到三十岁了。在那一年, 我被炒了鱿鱼。你怎么可能被你自己创立的公司炒了鱿鱼呢? 嗯，在苹果快速成长的时候，我们雇用了一个很有天分的家伙和我一起管理这个公司, 在最初的几年，公司运转的很好。但是后来我们对未来的看法发生了分歧, 最终我们吵了起来。当争吵不可开交的时候, 董事会站在了他的那一边。所以在三十岁的时候, 我被炒了。在这么多人的眼皮下我被炒了。在而立之年，我生命的全部支柱离自己远去, 这真是毁灭性的打击。I really didn’t know what to do for a few months. I felt that I had let the previous generation of entrepreneurs down – that I had dropped the baton as it was being passed to me. I met with David Packard and Bob Noyce and tried to apologize for screwing up so badly. I was a very public failure, and I even thought about running away from the valley. But something slowly began to dawn on me – I still loved what I did. The turn of events at Apple had not changed that one bit. I had been rejected, but I was still in love. And so I decided to start over. 在最初的几个月里，我真是不知道该做些什么。我把从前的创业激情给丢了, 我觉得自己让与我一同创业的人都很沮丧。我和David Pack和Bob Boyce见面，并试图向他们道歉。我把事情弄得糟糕透顶了。但是我渐渐发现了曙光, 我仍然喜爱我从事的这些东西。苹果公司发生的这些事情丝毫的没有改变这些, 一点也没有。我被驱逐了，但是我仍然钟爱它。所以我决定从头再来。I didn’t see it then, but it turned out that getting fired from Apple was the best thing that could have ever happened to me. The heaviness of being successful was replaced by the lightness of being a beginner again, less sure about everything. It freed me to enter one of the most creative periods of my life. 我当时没有觉察, 但是事后证明, 从苹果公司被炒是我这辈子发生的最棒的事情。因为，作为一个成功者的极乐感觉被作为一个创业者的轻松感觉所重新代替: 对任何事情都不那么特别看重。这让我觉得如此自由, 进入了我生命中最有创造力的一个阶段。During the next five years, I started a company named NeXT, another company named Pixar, and fell in love with an amazing woman who would become my wife. Pixar went on to create the worlds first computer animated feature film, Toy Story, and is now the most successful animation studio in the world. In a remarkable turn of events, Apple bought NeXT, I retuned to Apple, and the technology we developed at NeXT is at the heart of Apple’s current renaissance. And Laurene and I have a wonderful family together. 在接下来的五年里, 我创立了一个名叫NeXT的公司, 还有一个叫Pixar的公司, 然后和一个后来成为我妻子的优雅女人相识。Pixar 制作了世界上第一个用电脑制作的动画电影——“”玩具总动员”,Pixar现在也是世界上最成功的电脑制作工作室。在后来的一系列运转中,Apple收购了NeXT, 然后我又回到了Apple公司。我们在NeXT发展的技术在Apple的复兴之中发挥了关键的作用。我还和Laurence 一起建立了一个幸福的家庭。I’m pretty sure none of this would have happened if I hadn’t been fired from Apple. It was awful tasting medicine, but I guess the patient needed it. Sometimes life hits you in the head with a brick. Don’t lose faith. I’m convinced that the only thing that kept me going was that I loved what I did. You’ve got to find what you love. And that is as true for your work as it is for your lovers. Your work is going to fill a large part of your life, and the only way to be truly satisfied is to do what you believe is great work. And the only way to do great work is to love what you do. If you haven’t found it yet, keep looking. Don’t settle. As with all matters of the heart, you’ll know when you find it. And, like any great relationship, it just gets better and better as the years roll on. So keep looking until you find it. Don’t settle. 我可以非常肯定，如果我不被Apple开除的话, 这其中一件事情也不会发生的。这个良药的味道实在是太苦了，但是我想病人需要这个药。有些时候, 生活会拿起一块砖头向你的脑袋上猛拍一下。不要失去信心。我很清楚唯一使我一直走下去的，就是我做的事情令我无比钟爱。你需要去找到你所爱的东西。对于工作是如此, 对于你的爱人也是如此。你的工作将会占据生活中很大的一部分。你只有相信自己所做的是伟大的工作, 你才能怡然自得。如果你现在还没有找到, 那么继续找、不要停下来、全心全意的去找, 当你找到的时候你就会知道的。就像任何真诚的关系, 随着岁月的流逝只会越来越紧密。所以继续找，直到你找到它，不要停下来！My third story is about death. 我的第三个故事是关于死亡的。When I was 17, I read a quote that went something like: “If you live each day as if it was your last, someday you’ll most certainly be right.” It made an impression on me, and since then, for the past 33 years, I have looked in the mirror every morning and asked myself: “If today were the last day of my life, would I want to do what I am about to do today?” And whenever the answer has been “No” for too many days in a row, I know I need to change something. 当我十七岁的时候, 我读到了一句话:“如果你把每一天都当作生命中最后一天去生活的话，那么有一天你会发现你是正确的。”这句话给我留下了深刻的印象。从那时开始，过了33年，我在每天早晨都会对着镜子问自己:“如果今天是我生命中的最后一天, 你会不会完成你今天想做的事情呢？”当答案连续很多次被给予“不是”的时候, 我知道自己需要改变某些事情了。Remembering that I’ll be dead soon is the most important tool I’ve ever encountered to help me make the big choices in life. Because almost everything – all external expectations, all pride, all fear of embarrassment or failure – these things just fall away in the face of death, leaving only what is truly important. Remembering that you are going to die is the best way I know to avoid the trap of thinking you have something to lose. You are already naked. There is no reason not to follow your heart. “记住你即将死去”是我一生中遇到的最重要箴言。它帮我指明了生命中重要的选择。因为几乎所有的事情, 包括所有的荣誉、所有的骄傲、所有对难堪和失败的恐惧，这些在死亡面前都会消失。我看到的是留下的真正重要的东西。你有时候会思考你将会失去某些东西,“记住你即将死去”是我知道的避免这些想法的最好办法。你已经赤身裸体了, 你没有理由不去跟随自己的心一起跳动。About a year ago I was diagnosed with cancer. I had a scan at 7:30 in the morning, and it clearly showed a tumor on my pancreas. I didn’t even know what a pancreas was. The doctors told me this was almost certainly a type of cancer that is incurable, and that I should expect to live no longer than three to six months. My doctor advised me to go home and get my affairs in order, which is doctor’s code for prepare to die. It means to try to tell your kids everything you thought you’d have the next 10 years to tell them in just a few months. It means to make sure everything is buttoned up so that it will be as easy as possible for your family. It means to say your goodbyes. 大概一年以前, 我被诊断出癌症。我在早晨七点半做了一个检查, 检查清楚的显示在我的胰腺有一个肿瘤。我当时都不知道胰腺是什么东西。医生告诉我那很可能是一种无法治愈的癌症, 我还有三到六个月的时间活在这个世界上。我的医生叫我回家, 然后整理好我的一切, 那就是医生准备死亡的程序。那意味着你将要把未来十年对你小孩说的话在几个月里面说完.；那意味着把每件事情都搞定, 让你的家人会尽可能轻松的生活；那意味着你要说“再见了”。I lived with that diagnosis all day. Later that evening I had a biopsy, where they stuck an endoscope down my throat, through my stomach and into my intestines, put a needle into my pancreas and got a few cells from the tumor. I was sedated, but my wife, who was there, told me that when they viewed the cells under a microscope the doctors started crying because it turned out to be a very rare form of pancreatic cancer that is curable with surgery. I had the surgery and I’m fine now. 我整天和那个诊断书一起生活。后来有一天早上我作了一个活切片检查，医生将一个内窥镜从我的喉咙伸进去，通过我的胃, 然后进入我的肠子, 用一根针在我的胰腺上的肿瘤上取了几个细胞。我当时很镇静，因为我被注射了镇定剂。但是我的妻子在那里, 后来告诉我，当医生在显微镜地下观察这些细胞的时候他们开始尖叫, 因为这些细胞最后竟然是一种非常罕见的可以用手术治愈的胰腺癌症。我做了这个手术, 现在我痊愈了。This was the closest I’ve been to facing death, and I hope its the closest I get for a few more decades. Having lived through it, I can now say this to you with a bit more certainty than when death was a useful but purely intellectual concept: 那是我最接近死亡的时候, 我还希望这也是以后的几十年最接近的一次。从死亡线上又活了过来, 死亡对我来说，只是一个有用但是纯粹是知识上的概念的时候，我可以更肯定一点地对你们说：No one wants to die. Even people who want to go to heaven don’t want to die to get there. And yet death is the destination we all share. No one has ever escaped it. And that is as it should be, because Death is very likely the single best invention of Life. It is Life’s change agent. It clears out the old to make way for the new. Right now the new is you, but someday not too long from now, you will gradually become the old and be cleared away. Sorry to be so dramatic, but it is quite true. 没有人愿意死, 即使人们想上天堂, 人们也不会为了去那里而死。但是死亡是我们每个人共同的终点。从来没有人能够逃脱它。也应该如此。因为死亡就是生命中最好的一个发明。它将旧的清除以便给新的让路。你们现在是新的, 但是从现在开始不久以后, 你们将会逐渐的变成旧的然后被清除。我很抱歉这很戏剧性, 但是这十分的真实。Your time is limited, so don’t waste it living someone else’s life. Don’t be trapped by dogma – which is living with the results of other people’s thinking. Don’t let the noise of other’s opinions drown out your own inner voice. And most important, have the courage to follow your heart and intuition. They somehow already know what you truly want to become. Everything else is secondary. 你们的时间很有限, 所以不要将他们浪费在重复其他人的生活上。不要被教条束缚，那意味着你和其他人思考的结果一起生活。不要被其他人喧嚣的观点掩盖你真正的内心的声音。还有最重要的是, 你要有勇气去听从你直觉和心灵的指示——它们在某种程度上知道你想要成为什么样子，所有其他的事情都是次要的。When I was young, there was an amazing publication called The Whole Earth Catalog, which was one of the bibles of my generation. It was created by a fellow named Stewart Brand not far from here in Menlo Park, and he brought it to life with his poetic touch. This was in the late 1960′s, before personal computers and desktop publishing, so it was all made with typewriters, scissors, and polaroid cameras. It was sort of like Google in paperback form, 35 years before Google came along: it was idealistic, and overflowing with neat tools and great notions. 当我年轻的时候, 有一本叫做“整个地球的目录”振聋发聩的杂志，它是我们那一代人的圣经之一。它是一个叫Stewart Brand的家伙在离这里不远的Menlo Park书写的, 他象诗一般神奇地将这本书带到了这个世界。那是六十年代后期, 在个人电脑出现之前, 所以这本书全部是用打字机,、剪刀还有偏光镜制造的。有点像用软皮包装的google, 在google出现三十五年之前：这是理想主义的，其中有许多灵巧的工具和伟大的想法。Stewart and his team put out several issues of The Whole Earth Catalog, and then when it had run its course, they put out a final issue. It was the mid-1970s, and I was your age. On the back cover of their final issue was a photograph of an early morning country road, the kind you might find yourself hitchhiking on if you were so adventurous. Beneath it were the words: “Stay Hungry. Stay Foolish.” It was their farewell message as they signed off. Stay Hungry. Stay Foolish. And I have always wished that for myself. And now, as you graduate to begin anew, I wish that for you. Stewart和他的伙伴出版了几期的“整个地球的目录”,当它完成了自己使命的时候, 他们做出了最后一期的目录。那是在七十年代的中期, 你们的时代。在最后一期的封底上是清晨乡村公路的照片（如果你有冒险精神的话，你可以自己找到这条路的），在照片之下有这样一段话：“保持饥饿，保持愚蠢。”这是他们停止了发刊的告别语。“保持饥饿，保持愚蠢。”我总是希望自己能够那样，现在, 在你们即将毕业，开始新的旅程的时候, 我也希望你们能这样：Stay Hungry. Stay Foolish. 保持饥饿，保持愚蠢。Thank you all very much. 非常感谢你们！

Heroku 上的 Scala 程序设计

Tue, 04 Oct 2011 20:29:46 +0000

最近 Heroku 官方博客发布声明已经支持Scala语言《Scala now runs on Heroku》，本文就带领大家熟悉一下Scala App的开发流程。

目前有两种开发部署方式可供选择，一种类似《Heroku 上的 Java 程序设计》，采用Maven管理，另一种是利用 sbt

(the Scala Build Tool) 去开发部署，本文以第二种方式来进行介绍。关于Heroku的详细介绍和本地的开发环境安装，请参照博文《Heroku 上的 Java 程序设计》，本文只对不同的地方做具体说明。

Heroku = Polyglot + Platform as a Service (PaaS) + Cloud Components

开发步骤

安装 Scala 开发工具 sbt（win7的环境我已经写好了配置文件，直接下载到工程目录中即可win7_sdt）
登录 Heroku :

heroku auth:login

创建一个新工程目录，例如careyscala，目录中新建文件 careyscala/build.sbt， 内容如下:

scalaVersion := "2.9.1"

{
  val stage = TaskKey[Unit]("stage", "Prepares the project to be run, in environments that deploy source trees rather than packages.")
  stage in Compile := {}
}

为Heroku添加一个新的 “stage” task. 4. 建立编译配置文件 careyscala/project/build.properties ，用来指明sdt的版本，具体内容如下:

探讨 Android 网络编程

Fri, 30 Sep 2011 23:29:32 +0000

前言

谈到 Android 的网络编程，相信大家都不会陌生，我们平时用到的也就是两种 Http Client，分别为 HttpURLConnection 和 Apache HTTP Client，下面就分析一下它们各自的适用场合。

Most network-connected Android apps will use HTTP to send and receive data. Android includes two HTTP clients: HttpURLConnection and Apache HTTP Client. Both support HTTPS, streaming uploads and downloads, configurable timeouts, IPv6 and connection pooling.

Apache HTTP Client

Apache Http Client 的优势是适合于作为web 浏览器的客户端和稳定性较好，并且可灵活配置，缺点是在追求兼容性的情况下难以扩展。

DefaultHttpClient and its sibling AndroidHttpClient

are extensible HTTP clients suitable for web browsers. They have large and flexible APIs. Their implementation is stable and they have few bugs.

Heroku平台的FaceBook APP开发

Sat, 24 Sep 2011 13:17:21 +0000

Facebook 官方博客发表声明开始支持APP自动化部署到 Heroku

平台，这倒是一个好消息，APP的开发者再也不用担心平台的部署问题了，更何况Heroku这后起之秀的优秀云平台提供者，PHP，Ruby，Node.js等等几乎现在流行的开发语言都支持，所以方便多了。详情见 Facebook and Heroku: an even easier way to get started。本文就介绍一下具体的开发和部署方法。

部署

访问FaceBook Dev App开发中心，创建一个新的APP（ Create New App），输入APP的基本信息，包括APP Name 和 APP Namespace
APP 建立以后，进入到APP的配置界面，在这里选择云平台部署，选择 Cloud Services -> Get Started
在云平台中选择Heroku，目前只有该平台，所以直接选择即可
接下来开始配置Heroku的开发环境，选择一个目前最流行的Node.js，然后APP开始自动配置
然后APP会请求账户的权限，允许即可，页面会跳转到部署好的页面上面，比如我建立的CareyBlog已经部署到了https://afternoon-frost-4168.herokuapp.com/，现在可以直接访问了，程序已经实现了一部分功能了，如抓取好友列表，最近照片等等
至此为止，前期工作都已OK，APP的框架已经搭建，并且部署完毕，后续就是丰富APP的内容，进一步开发了

开发

到创建APP时填写的邮箱中收取Heroku的部署信息
登录Heroku获取代码

heroku login
git clone git@heroku.com:afternoon-frost-4168.git -o heroku

3. 修改代码并更新

git commit -am "changed greeting"
git push heroku

总结

一切操作都在云端解决了，只剩下好的创意来开发APP了！

探秘腾讯Android手机游戏平台之不安装游戏APK直接启动法

Sun, 18 Sep 2011 16:36:18 +0000

前言

相信这样一个问题，大家都不会陌生，

“有什么的方法可以使Android的程序APK不用安装，而能够直接启动”。

发现最后的结局都是不能实现这个美好的愿望，而腾讯Android手机游戏平台却又能实现这个功能，下载的连连看，五子棋都没有安装过程，但是都能直接运行，这其中到底有什么“玄机”呢，也有热心童鞋问过我这个问题，本文就为大家来揭开这个谜团。

重要说明在实践的过程中大家都会发现资源引用的问题，这里重点声明两点：1. 资源文件是不能直接inflate的，如果简单的话直接在程序中用代码书写。2. 资源文件是不能用R来引用的，因为上下文已经不同了，腾讯的做法是将资源文件打包(*.pak文件和APK打包在一起)，虽然APK是没有进行安装，但是资源文件是另外解压到指定文件夹下面的，然后将文件夹的地址传给了第三方应用程序，这样第三方应用程序通过File的inputstream流还是可以读取和使用这些资源的。

实践

我实现了一个小小的Demo，麻雀虽小五脏俱全，为了突出原理，我就尽量简化了程序，通过这个实例来让大家明白后台的工作原理。

下载demo的apk程序apks，其中包括了两个apk，分别是A和B
这两个APK可分别安装和运行，A程序界面只显示一个Button，B程序界面会动态显示当前的时间
下面的三幅图片分别为直接启动运行A程序（安装TestA.apk），直接启动运行B程序（安装TestB.apk）和由A程序动态启动B程序（安装TestA.apk，TestB.apk不用安装，而是放在/mnt/sdcard/目录中，即 SD卡上）的截图，细心的同学可以停下来观察一下他们之间的不同
后两幅图片的不同，也即Title的不同，则解释出了我们将要分析的后台实现原理的机制

实现原理

最能讲明白道理的莫过于源码了，下面我们就来分析一下A和B的实现机制，首先来分析TestA.apk的主要代码实现：

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);

		Button btn = (Button) findViewById(R.id.btn);
		btn.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				Bundle paramBundle = new Bundle();
				paramBundle.putBoolean("KEY_START_FROM_OTHER_ACTIVITY", true);
				String dexpath = "/mnt/sdcard/TestB.apk";
				String dexoutputpath = "/mnt/sdcard/";
				LoadAPK(paramBundle, dexpath, dexoutputpath);
			}
		});
	}

代码解析

这就是OnCreate函数要做的事情，装载view界面，绑定button事件，大家都熟悉了，还有就是设置程序B的放置路径，因为我程序中代码是从/mnt/sdcard/TestB.apk中动态加载，这也就是为什么要让大家把TestB.apk放在SD卡上面的原因了。关键的函数就是最后一个了LoadAPK，它来实现动态加载B程序。

	public void LoadAPK(Bundle paramBundle, String dexpath, String dexoutputpath) {
		ClassLoader localClassLoader = ClassLoader.getSystemClassLoader();
		DexClassLoader localDexClassLoader = new DexClassLoader(dexpath,
				dexoutputpath, null, localClassLoader);
		try {
			PackageInfo plocalObject = getPackageManager()
					.getPackageArchiveInfo(dexpath, 1);

			if ((plocalObject.activities != null)
					&& (plocalObject.activities.length > 0)) {
				String activityname = plocalObject.activities[0].name;
				Log.d(TAG, "activityname = " + activityname);

				Class localClass = localDexClassLoader.loadClass(activityname);
				Constructor localConstructor = localClass
						.getConstructor(new Class[] {});
				Object instance = localConstructor.newInstance(new Object[] {});
				Log.d(TAG, "instance = " + instance);

				Method localMethodSetActivity = localClass.getDeclaredMethod(
						"setActivity", new Class[] { Activity.class });
				localMethodSetActivity.setAccessible(true);
				localMethodSetActivity.invoke(instance, new Object[] { this });

				Method methodonCreate = localClass.getDeclaredMethod(
						"onCreate", new Class[] { Bundle.class });
				methodonCreate.setAccessible(true);
				methodonCreate.invoke(instance, new Object[] { paramBundle });
			}
			return;
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}

代码解析

这个函数要做的工作如下：加载B程序的APK文件，通过类加载器DexClassLoader来解析APK文件，这样会在SD卡上面生成一个同名的后缀为dex的文件，例如/mnt/sdcard/TestB.apk==>/mnt/sdcard/TestB.dex,接下来就是通过java反射机制，动态实例化B中的Activity对象，并依次调用了其中的两个函数，分别为setActivity和onCreate.看到这里，大家是不是觉得有点奇怪，Activity的启动函数是onCreate，为什么要先调用setActivity，而更奇怪的是setActivity并不是系统的函数，确实，那是我们自定义的，这也就是核心的地方。

Google Plus API 之程序设计

Sat, 17 Sep 2011 13:25:22 +0000

昨天Google官方发布新闻(Getting started on the Google+ API)，Google Plus开放了一个只读的API，允许抓取用户的公开Profile和公开的Activity信息流，其中 Google+ Platform 的具体开发API介绍详见官网。

今天我就带领大家熟悉一下基于Google+ 开放API的程序设计，本程序基于SAE平台，采用PHP语言开发，基于Java语言和Python语言也都比较好开发，google官方都有开放的lib可以直接使用，不用自己再做底层封装了。

实现步骤

访问 Google API Console 开启Google+ API权限.
访问 Google API Console 生成 developer key, OAuth2 client id, OAuth2 client secret, 和注册 OAuth2 redirect uri.
下载 google api的php开发库，google-api-php-client.
更新google api开发库，因为我的运行环境基于新浪云SAE平台，所以要做一些特别的改动：1. 实现SAE平台的MemCache，在google-api-php-clientsrccache中建立apiSAEMemcacheCache.php文件，具体内容如下

<?php
/**
 * SAE Memcache
 *
 * @author Carey Zhou <zhourunsheng2008@google.com>
 */
class apiSAEMemcacheCache extends apiCache {
  private $connection = false;

  public function __construct() {
	//do nothing
  }

  private function connect() {
    if (! $this->connection = @memcache_init()) {
      throw new apiCacheException("Memcache init failed");
    }
  }

  private function check() {
    if (! $this->connection) {
      $this->connect();
    }
  }

  /**
   * @inheritDoc
   */
  public function get($key, $expiration = false) {
    $this->check();
    if (($ret = @memcache_get($this->connection, $key)) === false) {
      return false;
    }
    if (! $expiration || (time() - $ret['time'] > $expiration)) {
      $this->delete($key);
      return false;
    }
    return $ret['data'];
  }

  /**
   * @inheritDoc
   */
  public function set($key, $value) {
    $this->check();
    // we store it with the cache_time default expiration so objects will at least get cleaned eventually.
    if (@memcache_set($this->connection, $key, array('time' => time(),
        'data' => $value), false) == false) {
      throw new apiCacheException("Couldn't store data in cache");
    }
  }

  /**
   * @inheritDoc
   */
  public function delete($key) {
    $this->check();
    @memcache_delete($this->connection, $key);
  }
}

更新 google-api-php-clientsrccacheapiCache.php文件，将我们新添加的SAEMemcache加进去，代码如下：

require_once "apiSAEMemcacheCache.php";

更新 google-api-php-clientsrcioapiCurlIO.php文件，修正一个bug【当Header中出现"HTTP/1.1 100 Continue"的时候，原程序会出现解析错误，导致程序崩溃，估计也是SAE环境的特殊性导致的】，具体改正如下：原来的代码：

// Parse out the raw response into usable bits
    list($rawResponseHeaders, $responseBody) = explode("rnrn", $data, 2);

现在的代码：

混乱代码分享之 Python 程序设计

Mon, 12 Sep 2011 09:19:07 +0000

Python代码历来是讲究整洁的，但是也不乏高手能写出如此混乱而又有节奏的代码，下面的混乱代码就是用来生成彭罗斯铺砖图案的。

程序源码

_                                 =
                                """if!
                              1:"e,V=100
                            0,(0j-1)**-.2;
                           v,S=.5/  V.real,
                         [(0,0,4      *e,4*e*
                       V)];w=1          -v"def!
                      E(T,A,              B,C):P
                  ,Q,R=B*w+                A*v,B*w+C
            *v,A*w+B*v;retur              n[(1,Q,C,A),(1,P
     ,Q,B),(0,Q,P,A)]*T+[(0,C            ,R,B),(1,R,C,A)]*(1-T)"f
or!i!in!_[:11]:S       =sum([E          (*x)for       !x!in!S],[])"imp
  ort!cair               o!as!O;      s=O.Ima               geSurfac
   e(1,e,e)               ;c=O.Con  text(s);               M,L,G=c.
     move_to                ,c.line_to,c.s                et_sour
       ce_rgb                a"def!z(f,a)                :f(-a.
        imag,a.       real-e-e)"for!T,A,B,C!in[i       !for!i!
          in!S!if!i[""";exec(reduce(lambda x,i:x.replace(chr
           (i),"n "[34-i:]),   range(   35),_+"""0]]:z(M,A
             );z(L,B);z         (L,C);         c.close_pa
             th()"G             (.4,.3             ,1);c.
             paint(             );G(.7             ,.7,1)
             ;c.fil             l()"fo             r!i!in
             !range             (9):"!             g=1-i/
             8;d=i/          4*g;G(d,d,d,          1-g*.8
             )"!def     !y(f,a):z(f,a+(1+2j)*(     1j**(i
             /2.))*g)"!for!T,A,B,C!in!S:y(M,C);y(L,A);y(M
             ,A);y(L,B)"!c.st            roke()"s.write_t
             o_png('pen                        rose.png')
             """                                       ))

执行效果

SL4A 之实现原理解析

Sun, 11 Sep 2011 21:17:08 +0000

关于SL4A的简介和在Android系统的安装及使用，请参考我的上一篇博文《Android 脚本设计之 SL4A》,本篇来分析其内部的实现机制。

深入理解SL4A

SL4A架构实现了本地脚本和原生态Android程序的内部消息通信，所以任何本地脚本语言，只要实现了这套兼容的JSON RPC通信接口，就可以呼叫SL4A的RPC Server端程序。至于为什么要选用JSON，及这种格式的优点和特征，此处就不详细叙述了，大家可以查看 JSON 官网。

“JavaScript Object Notation (JSON) is a lightweight, text-based, language-independent data interchange format. It was derived from the ECMAScript Programming Language Standard. JSON defines a small set of formatting rules for the portable representation of structured data. JSON can represent four primitive types (strings, numbers, booleans, and null) and two structured types (objects and arrays).”

SL4A总体架构

从上图可以看出，SL4A总体包括Client和Server两部分来实现通信和整体架构的独立性，Client端负责解析本地脚本，这样只要本地脚本实现了兼容的接口，就可以方便实现脚本语言的扩展，而Server端则封装了Android原生态程序的设计，即使在android底层API发生API变化的时候，Client端也基本不会受到影响，Client把脚本中解析出来的函数调用通过RPC通信，远程呼叫Server端代理接口，然后由Server调用原生态的Android API（Android Facade架构）来完成具体的功能，在调用结束后，Server端将执行结果反馈给Client端。

整个执行过程如下：

 -‐-‐ Script Interpreter
-‐-‐-‐-‐ Client/Caller/Consumer Script
-‐-‐-‐-‐-‐-‐ "Android" Script Object (locally wraps RPC calls) -‐ Local Proxy
-‐-‐-‐-‐-‐-‐-‐-‐ Remote Procedure Calls (RPC) – Exchanges contain a JSON payload
-‐-‐-‐-‐-‐-‐ Android API Java Facade -‐ Remote Proxy
-‐-‐-‐-‐ API Server/Provider -‐ Android Java application
-‐-‐ The Android Platform itself

Local Proxy 的实现机制

其实每个本地模块都封装实现了一个android实体类，然后开放其调用接口，内部通过RPC与SL4A Server端通信。

Android 脚本设计之 SL4A

Sun, 11 Sep 2011 11:33:27 +0000

什么是SL4A

SL4A的全称为Scripting Layer for Android, 顾名思义就是Android的脚本架构层，它的目的就是可以用熟知的脚本开发语言来开发Android应用程序。其工作原理基于RPC远程调用，通过本地的脚本解析器和远端的原生态Android Server层的APK进行信息交互，即实现一个远程代理，把本地脚本的函数调用通过json格式的封装，传递给远程原生态Server APK进行实际的android系统函数呼叫，最后将操作的执行结果反馈给本地脚本解析器，然后再在终端显示出运行结果。

SL4A适用场景

RAD programming，即 rapid application development，快速原型开发，进行工程项目的可行性分析
编写测试脚本，通常代码量都比较小，可方便实现
开发工具软件包，来实现一些快捷的功能

SL4A环境安装

下载安装 sl4a APK，目前的版本是 sl4a_r4.apk

C:UsersCarey.RS.Zhou>adb install -r C:UsersCarey.RS.ZhouDesktopsl4a_r4.apk
156 KB/s (858471 bytes in 5.355s)
        pkg: /data/local/tmp/sl4a_r4.apk
Success

在APP列表中找到 sl4a 并运行，接受 Usage Tracking，选择 Accept
程序默认只安装了一个shell环境，进入的步骤为【Menu】【View】【Interpreters】【Shell】在shell命令行中执行ps命令后的执行结果如下，说明程序安装正确
安装sl4a的本地脚本解析器，我们以安装python环境为例来说明，其他解析器的安装类似进入的步骤为【Menu】【View】【Interpreters】【Add】
选择Python之后，后台开始下载PythonForAndroid的APK，完成后点击安装
安装PythonForAndroid的APK之后，依次选择【Open】【Install】按钮，此时会进入第二阶段的安装过程，即安装python的附加module
全部安装之后回到该界面，按钮由刚才的Install变成现在的Uninstall，特别提醒，千万别点击Uninstall按钮，不然就把刚才下载的module都卸载了，然后就悲剧啦，退出该界面即可
我们再次进入Interpreters，发现不只是Shell了，还多了一个Python 2.6.2，说明python环境搭建好了，现在就可以在android上面进行python脚本编写了，点击进去看看
到此为止，环境都ok了，我们小小测试一下，显示个Toast出来，看看是多么的简单，剩下的就请大家好好发挥吧，比起Java原生态程序的编写是不是方便了很多啊

参考文献

SL4A Home：http://code.google.com/p/android-scripting/

Heroku 上的 Play Framework（Java）

Sun, 04 Sep 2011 11:06:06 +0000

上周Heroku开始支持Java程序设计，具体的请参见我的上一篇博文《Heroku 上的 Java 程序设计》，本周Heroku开始支持Play框架，本文就带领大家熟悉一下基于play框架的程序开发流程。

Play是什么

Play是一个Java Web框架。针对Web开发，Play采用了“净室”方法，不会强加约束，例如：

兼容Servlet容器、支持JSP、兼容标准Java Web App布局、顺应Java和OO原则。

Play遵循Ruby on Rails的“Built-and-Deploy”模型，而不是更传统的“Package-and-Distribute”模型。

不需要公式化的类或XML配置文件。框架采用了全新的打包惯例，在适当的地方使用了静态代码。举例来说，控制器入口点是无状态的，它面向HTTP而非面向对象，因此可以用静态方法来实现。

Play基于无容器的PaaS模型。Play应用可以运行于本地，也可以无缝地部署到生产环境。这样一来就可以简化部署工作流，消除由环境差异导致的问题。从架构角度来看，Play使用了 Netty，这是一个由 JBoss团队构建的非阻塞I/O协议库，它使用基于Continuation的编程模型，可以支持请求的异步处理。Play还实现了 Share-Nothing 模型，可以很方便地通过添加节点对应于程序进行水平扩展，有状态会话是无法做到这点的。

怎样使用Play

安装 heroku 客户端开发环境，参见 Linux, Mac, Windows.
安装 git 客户端软件和配置 ssh key，参见 Mac，Windows 和 Linux
安装 Play! version 1.2.3
登录 Heroku :

heroku auth:login

创建一个 Play! app:

play new play_hello_carey
cd play_hello_carey

6. 本地运行 app :

play run --%production

7. 建立 git repo:

git init
git add app conf lib public test
git commit -m init

在 Heroku 上建立一个新的 app :

heroku create -s cedar

9. 上传 play_hello_carey app 到 Heroku:

Heroku 上的 Java 程序设计

Sat, 27 Aug 2011 10:07:57 +0000

Heroku简介

Heroku is a Polyglot Cloud Application Platform

. Heroku provides us a way to run Ruby, Node.js, Clojure, and Java applications on a managed, scalable, and multi-tenant system. Heroku also provides numerous add-ons that help us make the shift from monolithic middleware to Cloud Components. Another way to say it is:

Heroku = Polyglot + Platform as a Service (PaaS) + Cloud Components

Heroku是一个支持多语言的云应用平台。它为我们提供了一个支撑的环境来运行Ruby，Node.js，Clojure，和Java应用程序，并且是可扩展，多租户的系统。Heroku还提供了众多的组件，帮助我们从单片中间件转移到云组件。另一种说法是：

Heroku = 多语种 + 平台作为服务（PaaS）+ 云组件

程序设计原则

Thu, 18 Aug 2011 12:47:32 +0000

回想自己的程序设计生涯也有一段时间了，好的编程准则的确能提高工作效率和提高自己的程序设计水平，下面摘录一些优秀的原则，供自己也供其他人来参考和学习，分别为英文原文和对应的中文翻译！

Principles of Good Programming

The principles of good programming are closely related to principles of good design and engineering. The following programming principles have helped me over the years become a better programmer, and I believe can help any developer become more efficient and to produce code which is easier to maintain and that has fewer defects.

DRY - Don’t repeat yourself

This is probably the single most fundamental tenet in programming is to avoid repetition. Many programming constructs exist solely for that purpose (e.g. loops, functions, classes, and more). As soon as you start repeating yourself (e.g. a long expression, a series of statements, same concept) create a new abstraction.

http://en.wikipedia.org/wiki/Don%27t_repeat_yourself Abstraction Principle

电话归属地查询之Android解决方案

Sun, 14 Aug 2011 10:19:06 +0000

最近接触的一个项目中，其中有一个功能需求就是号码归属地的查询，乍一看确实挺简单，反正数据库也都有了，只不过就是查询一下而已嘛！到了实际程序设计的时候才发现，5M的数据库光要加载起来就得1分多钟，放在android手机上跑的太慢了，没办法，只好另辟蹊径了！！！

本文的基本思路如下：

先把数据进行分组，即每一个地区一个组，例如

1898742 1898743 1898744 :云南曲靖 1894380 1894381 1894382 :吉林松原

把电话号码进行排序，目的就是为了找到电话号码的区间，例如

1894815 → 1899819 :广东珠海，找到了一个区段，这样就不用把每个电话号码读存储下来，只要存储一个区间就好，这样可以大大节省存储空间

设计新的存储格式，本文的程序采用如下方式存储

文件开头是两个偏移量，之后依次是数据区：

第一条电话记录在文件中的位置偏移    最后一条电话记录在文件中的位置偏移
电话归属地的字符串（例如：辽宁大连，湖北武汉，广东珠海，广东深圳…，字符串之间以逗号分隔）
第一条电话记录（例如：1894815{代表号码段起始值} 5{代表连续的号码个数} 2{代表该归属地字符串在所有归属地字符串中的偏移量}）
第二条电话记录
...
最后一条电话记录

归属地查询

根据用户输入的电话号码，利用二分查找法可快速定位到该记录在文件中的位置偏移，读出该记录中位置字符串的偏移值，进而查表即可找到归属地程序设计，源码如下：

package com.carey.tel;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;

public class JavaTelArea {
     private static JavaTelArea jta = null;
     private static final String INDEXDATAFILE = "tel.bin";
     private static Hearder cacheHearder = null;
     private static AreaCode cacheAreaCode = null;
     private static String cacheIndexFilePath = null;

     public static void main(String[] args) {
          JavaTelArea ctc = JavaTelArea.getInstance();
          //ctc.genIndexFile("e:\", "e:\telphone.txt");
          String indexPath = "e:\";

          long startTime = new Date().getTime();
          String searchNum = "13889650920";
          String res = ctc.searchTel(indexPath, searchNum);
          System.out.println(searchNum + " : " + res);
          System.out.println(System.currentTimeMillis() - startTime + "ms");

          startTime = new Date().getTime();
          searchNum = "+8613659867583";
          res = ctc.searchTel(indexPath, searchNum);
          System.out.println(searchNum + " : " + res);
          System.out.println(System.currentTimeMillis() - startTime + "ms");

          startTime = new Date().getTime();
          searchNum = "1301815";
          res = ctc.searchTel(indexPath, searchNum);
          System.out.println(searchNum + " : " + res);
          System.out.println(System.currentTimeMillis() - startTime + "ms");

          startTime = new Date().getTime();
          searchNum = "1301816";
          res = ctc.searchTel(indexPath, searchNum);
          System.out.println("没有预测");
          System.out.println(searchNum + " : " + res);
          System.out.println(System.currentTimeMillis() - startTime + "ms");

          startTime = new Date().getTime();
          searchNum = "1301816";
	  res = ctc.searchTel(indexPath, searchNum, true);
	  System.out.println("根据号码连贯性原理预测");
          System.out.println(searchNum + " : " + res);
          System.out.println(System.currentTimeMillis() - startTime + "ms");

          startTime = new Date().getTime();
          searchNum = "1301817";
          res = ctc.searchTel(indexPath, searchNum);
          System.out.println(searchNum + " : " + res);
          System.out.println(System.currentTimeMillis() - startTime + "ms");
    }

    private HashMap<Long, String> generateTestData() {
          HashMap<Long, String>
          telToAreaCode = new HashMap<Long, String>();
          telToAreaCode.put(1310944l, "新疆伊犁州");
          telToAreaCode.put(1301263l, "新疆伊犁州");
          telToAreaCode.put(1301264l, "新疆伊犁州");
          telToAreaCode.put(1301260l, "新疆伊犁州");
          telToAreaCode.put(955L, "海南");
          telToAreaCode.put(1320955l, "海南");
          telToAreaCode.put(1320957l, "海南");
          telToAreaCode.put(1300561L, "陕西商州");
          telToAreaCode.put(1300562L, "陕西商州");
          return telToAreaCode;
    }

    public static synchronized JavaTelArea getInstance() {
         if (jta == null) {
               jta = new JavaTelArea();
         }
         return jta;
    }

   /**	 * Generate Index File (tel.bin)	 * */
   private void genIndexFile(String indexFilePath, String souceFile) {
         ArrayList<String> strs = readFileToList(souceFile);
         HashMap<Long, String>
         telToArea = createTel2AreaHashMap(strs);
         writeDate(indexFilePath + INDEXDATAFILE, telToArea);
   }

   /**	 * read file content to String array list, every line one string.	 * */
   private ArrayList<String> readFileToList(String filePath) {
        final ArrayList<String>
        strLists = new ArrayList<String>();

        BufferedReader bReader = null;
        try {
              bReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));
              String str = bReader.readLine();
              while (str != null) {
                   strLists.add(str);
                   str = bReader.readLine();
              }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
           if (bReader != null) {
               try {
                     bReader.close();
               } catch (IOException e) {
                    e.printStackTrace();
               }
          }
       }
       return strLists;
    }

     /**	 * create telephone number to area hash map.	 * */
     HashMap<Long, String> createTel2AreaHashMap(ArrayList<String> strs) {
           final HashMap<Long, String>
           telToArea = new HashMap<Long, String>();

           String[] tels = null;
           int len = 0;
           String strArea = null;
           for (String string : strs) {
               tels = string.split(" ");
               len = tels.length;
               strArea = tels[len - 1].substring(1);

               for (int i = 0; i < len - 1; i++) {
                    telToArea.put(Long.valueOf(tels[i]), strArea);
               }
           }
         return telToArea;
    }

    /**	 * combined the adjacent Records.	 * */
    private void combinedRecords(ArrayList<Record> records, Record newRecord) {
          int size = records.size();
          if (size > 0&& records.get(size - 1).areacodeIndex == newRecord.areacodeIndex) {
               // combined
              Record lastRecord = records.get(size - 1);
              lastRecord.numCnt = (int) (newRecord.baseTelNum - lastRecord.baseTelNum) + newRecord.numCnt;
         } else {
              records.add(newRecord);
         }
    }

   /**	 * write index info to file.	 * */
   private void writeDate(String filePath, HashMap<Long, String> telToAreaCode) {
       // 1. get all area info
       ArrayList<String> tmpAreaCodes = new ArrayList<String>(telToAreaCode.values());
       ArrayList<String> strAreaCodes = new ArrayList<String>();
       for (String str : tmpAreaCodes) {
            if (!strAreaCodes.contains(str)) {
                    strAreaCodes.add(str);
            }
       }
       tmpAreaCodes.clear();
       tmpAreaCodes = null;

       StringBuffer sb = new StringBuffer();
       for (String str : strAreaCodes) {
                 sb.append(str + ",");
       }
       sb.deleteCharAt(sb.length() - 1);

       AreaCode areaCode = new AreaCode(sb.toString());
       areaCode.print();

       // 2. Sort HashMap and combined the adjacent telephone number
       ArrayList<Long> telNunms = new ArrayList<Long>(telToAreaCode.keySet());
       Collections.sort(telNunms);
       ArrayList<Record> records = new ArrayList<Record>();
       long baseNum = 0;
       String baseArea = null;
       int numCnt = 0;
       for (Long tm : telNunms) {
             if (numCnt == 0) {
                    baseNum = tm;
                    baseArea = telToAreaCode.get(tm);
                    numCnt = 1;
             } else {
                    if (tm == baseNum + numCnt && baseArea.equals(telToAreaCode.get(tm))) {
			  numCnt++;
                    } else {
                         combinedRecords(records, new Record(baseNum, numCnt,	strAreaCodes.indexOf(baseArea)));
                         baseNum = tm;
                         baseArea = telToAreaCode.get(tm);
                         numCnt = 1;
                    }
             }
          }
         combinedRecords(records,	new Record(baseNum, numCnt, strAreaCodes.indexOf(baseArea)));		

         // for (Record record : records) {
               // record.print();
         // }

         // 3. Write data to the file
         RandomAccessFile raf = null;
         try {
                raf = new RandomAccessFile(filePath, "rw");
                raf.seek(0);

                Hearder hearder = new Hearder();
                hearder.firstRecordOffset = hearder.Size() + areaCode.Size();
                hearder.lastRecordOffset = hearder.firstRecordOffset	+ (records.size() - 1) * records.get(0).Size();
                hearder.print();
                hearder.write(raf);

                areaCode.write(raf);

                for (Record record : records) {
                       record.write(raf);
                }
          } catch (Exception e) {
              e.printStackTrace();
          } finally {
              if (raf != null) {
                    try {
                           raf.close();
                     } catch (IOException e) {
                            e.printStackTrace();
                     }
              }
          }
    }

   class Hearder {
         int firstRecordOffset;
         int lastRecordOffset;

         public int Size() {
                 return (Integer.SIZE + Integer.SIZE) / Byte.SIZE;
         }

         public void write(RandomAccessFile raf) throws IOException {
                raf.writeInt(this.firstRecordOffset);
                raf.writeInt(this.lastRecordOffset);
         }

        public void read(RandomAccessFile raf) throws IOException {
               this.firstRecordOffset = raf.readInt();
               this.lastRecordOffset = raf.readInt();
        }

        public void print() {
                System.out.println("===== Hearder ===== ");
                System.out.println("[" + firstRecordOffset + " , "	 + lastRecordOffset + "]");
        }
    }

   class AreaCode {
          private String areacode;
          private String[] codes;

          public AreaCode() {
               this("");
          }

          public AreaCode(String areacode) {
               this.areacode = areacode;
               this.codes = null;
          }

          public int Size() {
                 return areacode.getBytes().length + (Integer.SIZE / Byte.SIZE);
          }

          public void print() {
                System.out.println("===== AreaCode ===== ");
                System.out.println("[" + areacode.getBytes().length + "]" + areacode);
          }

         public void write(RandomAccessFile raf) throws IOException {
		raf.writeInt(areacode.getBytes().length);
                raf.write(this.areacode.getBytes());
         }

         public void read(RandomAccessFile raf) throws IOException {
                byte[] bytes = new byte[raf.readInt()];
                raf.read(bytes);
                this.areacode = new String(bytes);
         }

         public String getCodeByIndex(int index) {
             if (this.codes == null) {
                   this.codes = this.areacode.split(",");
             }
             return (index < 0 || this.codes == null || index >= this.codes.length) ? null	 : this.codes[index];
        }
}

class Record {
       long baseTelNum;
       int numCnt;
       int areacodeIndex;

       public Record() {
            this(0, 0, 0);
       }

       public Record(long baseTelNum, int numCnt, int areacodeIndex) {
             this.baseTelNum = baseTelNum;
             this.numCnt = numCnt;
             this.areacodeIndex = areacodeIndex;
       }

       public void print() {
             System.out.println("===== Record ===== ");
             System.out.println("<" + baseTelNum + "> <" + numCnt + "> <" + areacodeIndex + ">");
       }

      public int Size() {
             return (Long.SIZE + Integer.SIZE) / Byte.SIZE;
      }

      public void write(RandomAccessFile raf) throws IOException {
           raf.writeLong(this.baseTelNum);
           int tmp = this.numCnt << 16;
           tmp += 0xFFFF & this.areacodeIndex;
           raf.writeInt(tmp);
      }

     public void read(RandomAccessFile raf) throws IOException {
          this.baseTelNum = raf.readLong();
          int tmp = raf.readInt();
          this.numCnt = tmp >> 16;
          this.areacodeIndex = 0xFFFF & tmp;
     }

     public int inWhich(long telNum) {
         if (telNum < this.baseTelNum) {
               return -1;
         } else if (telNum >= this.baseTelNum + this.numCnt) {
               return 1;
         } else {
               return 0;
         }
    }
 }

  public String searchTel(String indexFilePath, String telNum) {
          return searchTel(indexFilePath, telNum, false);
  }

  /**	 * search	 * */
  public String searchTel(String indexFilePath, String telNum, boolean forecast) {
	StringBuffer sb = new StringBuffer(telNum);

	// +
	if (sb.charAt(0) == '+') {
		sb.deleteCharAt(0);
	}

	// 86
	if (sb.charAt(0) == '8' && sb.charAt(1) == '6') {
		sb.delete(0, 2);
	}

	// 以0开头，是区号
	if (sb.charAt(0) == '0') {
		sb.deleteCharAt(0);
		// 首先按照4位区号查询，若查询为空，再按3位区号查询
		if (sb.length() >= 3) {
			sb.delete(3, sb.length());
		} 

		String dial = searchTel(indexFilePath, Long.valueOf(sb.toString()),false);

		if (dial != null) {
			return dial;
		}

		if (sb.length() >= 2) {
			sb.delete(2, sb.length());
		}
	}
	// 以1开头，是手机号或者服务行业号码
	else if (sb.charAt(0) == '1') {
		// 首先按照手机号码查询，若查询为空，再按特殊号码查询

		if (sb.length() > 7) {
			String dial = searchTel(indexFilePath, Long.valueOf(sb.substring(0, 8)),false);

			if (dial != null) {
				return dial;
			}

			dial = searchTel(indexFilePath, Long.valueOf(sb.toString()),false);

			if (dial != null) {
				return dial;
			}

			// 只需要保留7位号码就ok了，多余的删掉
			if (sb.length() > 7) {
				sb.delete(7, sb.length());
			}
		} else {
			//小于7位，最有可能是服务号码
			//do nothing.
		}
	}
	// 以其他数字开头，这也不知道是啥号码了
	else {
		//do nothing.
	}

	return searchTel(indexFilePath, Long.valueOf(sb.toString()), forecast);
  }

 private String searchTel(String indexFilePath, long telNum, boolean forecast) {
          RandomAccessFile raf = null;
          try {
             raf = new RandomAccessFile(indexFilePath + INDEXDATAFILE, "r");
             if (cacheIndexFilePath == null || !cacheIndexFilePath.equals(indexFilePath)) {
                cacheIndexFilePath = indexFilePath;
                cacheHearder = new Hearder();
                cacheHearder.read(raf);
                cacheHearder.print();

                cacheAreaCode = new AreaCode();
                cacheAreaCode.read(raf);
                cacheAreaCode.print();
             }

            int index = lookUP(raf, cacheHearder.firstRecordOffset, cacheHearder.lastRecordOffset, telNum, forecast);
            return cacheAreaCode.getCodeByIndex(index);
         } catch (Exception e) {
              e.printStackTrace();
         } finally {
              if (raf != null) {
                  try {
                         raf.close();
                  } catch (IOException e) {
                       e.printStackTrace();
                  }
               }
         }

      return null;
  }

  private int lookUP(RandomAccessFile raf, long startpos, long endpos, long looknum, boolean forecast) throws IOException {
      Record record = new Record();
      long seekpos = 0;

      do {
            seekpos = startpos + (endpos - startpos) / record.Size() / 2 * record.Size();
            raf.seek(seekpos);
            record.read(raf);

           if (record.inWhich(looknum) > 0) {
                 startpos = seekpos + record.Size();
           } else if (record.inWhich(looknum) < 0) {
                 endpos = seekpos - record.Size();
           } else {
                 return record.areacodeIndex;
           }
      } while (startpos <= endpos);

     if (forecast) {
            return record.areacodeIndex;
     } else {
           return -1;
     }
  }
}

程序运行情况如下：

技术导航

Mon, 08 Aug 2011 08:04:59 +0000

前沿技术导航

Html5 设计 Android APP

软件设计

Rebecca Murphey 的《jQuery基础》（jQuery Fundamentals）
infoQ REST
代码之美（精选版）
架构之美（精选版）
构建高性能Web站点（精选版）
Web应用开发者（第一期）

项目管理

Google API

Tue, 02 Aug 2011 17:09:06 +0000

本文收集了一系列的Google开发API，可以有效与自己的web服务相集成，提高开发效率。

1) Lattitude API

2) Earth API

3) Google Map API

4)GeoCoding API

5)Google Direction API

6)Static API

7)Places API

8 ) Buzz API

9)Friend Connect API

10)Social Graph API

11) Wave API

12)YouTube API’s

13)ADwords API

15)Blogger Data API

16)Webmaster Tools API

17) Code Search API

18) Picasa Web Album DATA API

19) Management API

Java深度解析之安全与对象序列化RMI

Tue, 02 Aug 2011 16:32:02 +0000

本系列的文章转载自 infoq专栏合集《Java深度历险》，10篇文章分别由浅到深描述了Java的多个细节，具体包括

Java 字节代码的操纵
Java类的加载、链接和初始化
Java线程：基本概念、可见性与同步
Java垃圾回收机制与引用类型
Java泛型
Java注解
Java反射与动态代理
Java I/O
Java安全
Java对象序列化与RMI

相信通过十个主题的学习，读者能对Java的这几个方面有较深入的理解。enjoy it！

Java 安全

安全性是Java应用程序的非功能性需求的重要组成部分，如同其它的非功能性需求一样，安全性很容易被开发人员所忽略。当然，对于Java EE的开发人员来说，安全性的话题可能没那么陌生，用户认证和授权可能是绝大部分Web应用都有的功能。类似 Spring Security 这样的框架，也使得开发变得更加简单。本文并不会讨论Web应用的安全性，而是介绍Java安全一些底层和基本的内容。

认证用户认证是应用安全性的重要组成部分，其目的是确保应用的使用者具有合法的身份。 Java安全中使用术语主体（Subject）来表示访问请求的来源。一个主体可以是任何的实体。一个主体可以有多个不同的身份标识（Principal）。比如一个应用的用户这类主体，就可以有用户名、身份证号码和手机号码等多种身份标识。除了身份标识之外，一个主体还可以有公开或是私有的安全相关的凭证（Credential），包括密码和密钥等。

典型的用户认证过程是通过登录操作来完成的。在登录成功之后，一个主体中就具备了相应的身份标识。Java提供了一个可扩展的登录框架，使得应用开发人员可以很容易的定制和扩展与登录相关的逻辑。登录的过程由 LoginContext 启动。在创建LoginContext的时候需要指定一个登录配置（Configuration）的名称。该登录配置中包含了登录所需的多个 LoginModule 的信息。每个LoginModule实现了一种登录方式。当调用LoginContext的 login 方法的时候，所配置的每个LoginModule会被调用来执行登录操作。如果整个登录过程成功，则通过 getSubject 方法就可以获取到包含了身份标识信息的主体。开发人员可以实现自己的LoginModule来定制不同的登录逻辑。

每个LoginModule的登录方式由两个阶段组成。第一个阶段是在 login

方法的实现中。这个阶段用来进行必要的身份认证，可能需要获取用户的输入，以及通过数据库、网络操作或其它方式来完成认证。当认证成功之后，把必要的信息保存起来。如果认证失败，则抛出相关的异常。第二阶段是在 commit 或 abort

方法中。由于一个登录过程可能涉及到多个LoginModule。LoginContext会根据每个LoginModule的认证结果以及相关的配置信息来确定本次登录是否成功。LoginContext用来判断的依据是每个LoginModule对整个登录过程的必要性，分成必需、必要、充分和可选这四种情况。如果登录成功，则每个LoginModule的commit方法会被调用，用来把身份标识关联到主体上。如果登录失败，则LoginModule 的abort方法会被调用，用来清除之前保存的认证相关信息。

在LoginModule进行认证的过程中，如果需要获取用户的输入，可以通过 CallbackHandler 和对应的Callback来完成。每个 Callback 可以用来进行必要的数据传递。典型的启动登录的过程如下：

public Subject login() throws LoginException {    
    TextInputCallbackHandler callbackHandler = new TextInputCallbackHandler();    
    LoginContext lc = new LoginContext("SmsApp", callbackHandler);    
    lc.login();    
    return lc.getSubject();
}

这里的SmsApp是登录配置的名称，可以在配置文件中找到。该配置文件的内容也很简单。

SmsApp {    
    security.login.SmsLoginModule required;
};

这里声明了使用security.login.SmsLoginModule这个登录模块，而且该模块是必需的。配置文件可以通过启动程序时的参数java.security.auth.login.config来指定，或修改JVM的默认设置。下面看看SmsLoginModule的核心方法login和commit。

Java深度解析之反射机制动态代理与I/O

Tue, 02 Aug 2011 16:18:47 +0000

本系列的文章转载自 infoq专栏合集《Java深度历险》，10篇文章分别由浅到深描述了Java的多个细节，具体包括

Java 字节代码的操纵
Java类的加载、链接和初始化
Java线程：基本概念、可见性与同步
Java垃圾回收机制与引用类型
Java泛型
Java注解
Java反射与动态代理
Java I/O
Java安全
Java对象序列化与RMI

相信通过十个主题的学习，读者能对Java的这几个方面有较深入的理解。enjoy it！

Java反射与动态代理

以前文章中介绍Java注解的时候，多次提到了Java的反射API。与 javax.lang.model 不同的是，通过反射API可以获取程序在运行时刻的内部结构。反射API中提供的动态代理也是非常强大的功能，可以原生实现 AOP

中的方法拦截功能。正如英文单词reflection的含义一样，使用反射API的时候就好像在看一个Java类在水中的倒影一样。知道了Java类的内部结构之后，就可以与它进行交互，包括创建新的对象和调用对象中的方法等。这种交互方式与直接在源代码中使用的效果是相同的，但是又额外提供了运行时刻的灵活性。使用反射的一个最大的弊端是性能比较差。相同的操作，用反射API所需的时间大概比直接的使用要慢一两个数量级。不过现在的JVM实现中，反射操作的性能已经有了很大的提升。在灵活性与性能之间，总是需要进行权衡的。应用可以在适当的时机来使用反射API。

基本用法

Java 反射API的第一个主要作用是获取程序在运行时刻的内部结构。这对于程序的检查工具和调试器来说，是非常实用的功能。只需要短短的十几行代码，就可以遍历出来一个Java类的内部结构，包括其中的构造方法、声明的域和定义的方法等。这不得不说是一个很强大的能力。只要有了java.lang.Class类的对象，就可以通过其中的方法来获取到该类中的构造方法、域和方法。对应的方法分别是 getConstructor、getField 和 getMethod。这三个方法还有相应的getDeclaredXXX版本，区别在于getDeclaredXXX版本的方法只会获取该类自身所声明的元素，而不会考虑继承下来的。

Constructor、Field 和 Method 这三个类分别表示类中的构造方法、域和方法。这些类中的方法可以获取到所对应结构的元数据。

反射API的另外一个作用是在运行时刻对一个Java对象进行操作。这些操作包括动态创建一个Java类的对象，获取某个域的值以及调用某个方法。在Java源代码中编写的对类和对象的操作，都可以在运行时刻通过反射API来实现。考虑下面一个简单的Java类。

class MyClass {
    public int count;
    public MyClass(int start) {
        count = start;
    }
    public void increase(int step) {
        count = count + step;
    }
}

使用一般做法和反射API都非常简单。

MyClass myClass = new MyClass(0); //一般做法
myClass.increase(2);
System.out.println("Normal -> " + myClass.count);
try {
    Constructor constructor = MyClass.class.getConstructor(int.class); //获取构造方法
    MyClass myClassReflect = constructor.newInstance(10); //创建对象
    Method method = MyClass.class.getMethod("increase", int.class);  //获取方法
    method.invoke(myClassReflect, 5); //调用方法
    Field field = MyClass.class.getField("count"); //获取域
    System.out.println("Reflect -> " + field.getInt(myClassReflect)); //获取域的值
} catch (Exception e) {
    e.printStackTrace();
}

由于数组的特殊性，Array 类提供了一系列的静态方法用来创建数组和对数组中的元素进行访问和操作。

Java深度解析之泛型与注解

Tue, 02 Aug 2011 16:07:01 +0000

本系列的文章转载自 infoq专栏合集《Java深度历险》，10篇文章分别由浅到深描述了Java的多个细节，具体包括

Java 字节代码的操纵
Java类的加载、链接和初始化
Java线程：基本概念、可见性与同步
Java垃圾回收机制与引用类型
Java泛型
Java注解
Java反射与动态代理
Java I/O
Java安全
Java对象序列化与RMI

相信通过十个主题的学习，读者能对Java的这几个方面有较深入的理解。enjoy it！

Java泛型

（generics）是JDK 5中引入的一个新特性，允许在定义类和接口的时候使用类型参数（type parameter）。声明的类型参数在使用时用具体的类型来替换。泛型最主要的应用是在JDK 5中的新集合类框架中。对于泛型概念的引入，开发社区的观点是褒贬不一。从好的方面来说，泛型的引入可以解决之前的集合类框架在使用过程中通常会出现的运行时刻类型错误，因为编译器可以在编译时刻就发现很多明显的错误。而从不好的地方来说，为了保证与旧有版本的兼容性，Java泛型的实现上存在着一些不够优雅的地方。当然这也是任何有历史的编程语言所需要承担的历史包袱。后续的版本更新会为早期的设计缺陷所累。

开发人员在使用泛型的时候，很容易根据自己的直觉而犯一些错误。比如一个方法如果接收List<Object>作为形式参数，那么如果尝试将一个List<String>的对象作为实际参数传进去，却发现无法通过编译。虽然从直觉上来说，Object是String的父类，这种类型转换应该是合理的。但是实际上这会产生隐含的类型转换问题，因此编译器直接就禁止这样的行为。本文试图对Java泛型做一个概括性的说明。

类型擦除

正确理解泛型概念的首要前提是理解类型擦除（type erasure）。Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉。这个过程就称为类型擦除。如在代码中定义的List<Object>和List<String>等类型，在编译之后都会变成List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。类型擦除也是Java的泛型实现方式与 C++模板机制实现方式之间的重要区别。

很多泛型的奇怪特性都与这个类型擦除的存在有关，包括：

泛型类并没有自己独有的Class类对象。比如并不存在List<String>.class或是List<Integer>.class，而只有List.class。
静态变量是被泛型类的所有实例所共享的。对于声明为MyClass<T>的类，访问其中的静态变量的方法仍然是 MyClass.myStaticVar。不管是通过new MyClass<String>还是new MyClass<Integer>创建的对象，都是共享一个静态变量。
泛型的类型参数不能用在Java异常处理的catch语句中。因为异常处理是由JVM在运行时刻来进行的。由于类型信息被擦除，JVM是无法区分两个异常类型MyException<String>和MyException<Integer>的。对于JVM来说，它们都是 MyException类型的。也就无法执行与异常对应的catch语句。

类型擦除的基本过程也比较简单，首先是找到用来替换类型参数的具体类。这个具体类一般是Object。如果指定了类型参数的上界的话，则使用这个上界。把代码中的类型参数都替换成具体的类。同时去掉出现的类型声明，即去掉<>的内容。比如T get()方法声明就变成了Object get()；List<String>就变成了List。接下来就可能需要生成一些桥接方法（bridge method）。这是由于擦除了类型之后的类可能缺少某些必须的方法。比如考虑下面的代码：

class MyString implements Comparable<String> {
    public int compareTo(String str) {        
        return 0;    
    }
}

当类型信息被擦除之后，上述类的声明变成了class MyString implements Comparable。但是这样的话，类MyString就会有编译错误，因为没有实现接口Comparable声明的int compareTo(Object)方法。这个时候就由编译器来动态生成这个方法。

实例分析

了解了类型擦除机制之后，就会明白编译器承担了全部的类型检查工作。编译器禁止某些泛型的使用方式，正是为了确保类型的安全性。以上面提到的List<Object>和List<String>为例来具体分析：

public void inspect(List<Object> list) {    
    for (Object obj : list) {        
        System.out.println(obj);    
    }    
    list.add(1); //这个操作在当前方法的上下文是合法的。 
}
public void test() {    
    List<String> strs = new ArrayList<String>();    
    inspect(strs); //编译错误 
}

这段代码中，inspect方法接受List<Object>作为参数，当在test方法中试图传入List<String>的时候，会出现编译错误。假设这样的做法是允许的，那么在inspect方法就可以通过list.add(1)来向集合中添加一个数字。这样在test方法看来，其声明为List<String>的集合中却被添加了一个Integer类型的对象。这显然是违反类型安全的原则的，在某个时候肯定会抛出 ClassCastException。因此，编译器禁止这样的行为。编译器会尽可能的检查可能存在的类型安全问题。对于确定是违反相关原则的地方，会给出编译错误。当编译器无法判断类型的使用是否正确的时候，会给出警告信息。

Java深度解析之线程控制与垃圾回收

Tue, 02 Aug 2011 15:46:40 +0000

本系列的文章转载自 infoq专栏合集《Java深度历险》，10篇文章分别由浅到深描述了Java的多个细节，具体包括

Java 字节代码的操纵
Java类的加载、链接和初始化
Java线程：基本概念、可见性与同步
Java垃圾回收机制与引用类型
Java泛型
Java注解
Java反射与动态代理
Java I/O
Java安全
Java对象序列化与RMI

相信通过十个主题的学习，读者能对Java的这几个方面有较深入的理解。enjoy it！

Java线程：基本概念、可见性与同步

开发高性能并发应用不是一件容易的事情。这类应用的例子包括高性能Web服务器、游戏服务器和搜索引擎爬虫等。这样的应用可能需要同时处理成千上万个请求。对于这样的应用，一般采用多线程或事件驱动的架构。对于Java来说，在语言内部提供了线程的支持。但是Java的多线程应用开发会遇到很多问题。首先是很难编写正确，其次是很难测试是否正确，最后是出现问题时很难调试。一个多线程应用可能运行了好几天都没问题，然后突然就出现了问题，之后却又无法再次重现出来。如果在正确性之外，还需要考虑应用的吞吐量和性能优化的话，就会更加复杂。本文主要介绍Java中的线程的基本概念、可见性和线程同步相关的内容。

Java线程基本概念在操作系统中两个比较容易混淆的概念是进程（process）和线程

（thread）。操作系统中的进程是资源的组织单位。进程有一个包含了程序内容和数据的地址空间，以及其它的资源，包括打开的文件、子进程和信号处理器等。不同进程的地址空间是互相隔离的。而线程表示的是程序的执行流程，是CPU调度的基本单位。线程有自己的程序计数器、寄存器、栈和帧等。引入线程的动机在于操作系统中阻塞式I/O的存在。当一个线程所执行的I/O被阻塞的时候，同一进程中的其它线程可以使用CPU来进行计算。这样的话，就提高了应用的执行效率。线程的概念在主流的操作系统和编程语言中都得到了支持。

一部分的Java程序是单线程的。程序的机器指令按照程序中给定的顺序依次执行。Java语言提供了 java.lang.Thread 类来为线程提供抽象。有两种方式创建一个新的线程：一种是继承java.lang.Thread类并覆写其中的 run() 方法，另外一种则是在创建java.lang.Thread类的对象的时候，在构造函数中提供一个实现了 java.lang.Runnable 接口的类的对象。在得到了java.lang.Thread类的对象之后，通过调用其 start() 方法就可以启动这个线程的执行。

一个线程被创建成功并启动之后，可以处在不同的状态中。这个线程可能正在占用CPU时间运行；也可能处在就绪状态，等待被调度执行；还可能阻塞在某个资源或是事件上。多个就绪状态的线程会竞争CPU时间以获得被执行的机会，而CPU则采用某种算法来调度线程的执行。不同线程的运行顺序是不确定的，多线程程序中的逻辑不能依赖于CPU的调度算法。

可见性

可见性（visibility）的问题是Java多线程应用中的错误的根源。在一个单线程程序中，如果首先改变一个变量的值，再读取该变量的值的时候，所读取到的值就是上次写操作写入的值。也就是说前面操作的结果对后面的操作是肯定可见的。但是在多线程程序中，如果不使用一定的同步机制，就不能保证一个线程所写入的值对另外一个线程是可见的。造成这种情况的原因可能有下面几个：

CPU 内部的缓存：现在的CPU一般都拥有层次结构的几级缓存。CPU直接操作的是缓存中的数据，并在需要的时候把缓存中的数据与主存进行同步。因此在某些时刻，缓存中的数据与主存内的数据可能是不一致的。某个线程所执行的写入操作的新值可能当前还保存在CPU的缓存中，还没有被写回到主存中。这个时候，另外一个线程的读取操作读取的就还是主存中的旧值。
CPU的指令执行顺序：在某些时候，CPU可能改变指令的执行顺序。这有可能导致一个线程过早的看到另外一个线程的写入操作完成之后的新值。
编译器代码重排：出于性能优化的目的，编译器可能在编译的时候对生成的目标代码进行重新排列。

现实的情况是：不同的CPU可能采用不同的架构，而这样的问题在多核处理器和多处理器系统中变得尤其复杂。而Java的目标是要实现“编写一次，到处运行”，因此就有必要对Java程序访问和操作主存的方式做出规范，以保证同样的程序在不同的CPU架构上的运行结果是一致的。Java内存模型（Java Memory Model）就是为了这个目的而引入的。

JSR 133 则进一步修正了之前的内存模型中存在的问题。总得来说，Java内存模型描述了程序中共享变量的关系以及在主存中写入和读取这些变量值的底层细节。

Java内存模型定义了Java语言中的 synchronized、volatile 和 final

等关键词对主存中变量读写操作的意义。Java开发人员使用这些关键词来描述程序所期望的行为，而编译器和JVM负责保证生成的代码在运行时刻的行为符合内存模型的描述。比如对声明为volatile的变量来说，在读取之前，JVM会确保CPU中缓存的值首先会失效，重新从主存中进行读取；而写入之后，新的值会被马上写入到主存中。而synchronized和volatile关键词也会对编译器优化时候的代码重排带来额外的限制。比如编译器不能把 synchronized块中的代码移出来。对volatile变量的读写操作是不能与其它读写操作一块重新排列的。

Java 内存模型中一个重要的概念是定义了“在之前发生（happens-before）”的顺序。如果一个动作按照“在之前发生”的顺序发生在另外一个动作之前，那么前一个动作的结果在多线程的情况下对于后一个动作就是肯定可见的。最常见的“在之前发生”的顺序包括：对一个对象上的监视器的解锁操作肯定发生在下一个对同一个监视器的加锁操作之前；对声明为volatile的变量的写操作肯定发生在后续的读操作之前。有了“在之前发生”顺序，多线程程序在运行时刻的行为在关键部分上就是可预测的了。编译器和JVM会确保“在之前发生”顺序可以得到保证。比如下面的一个简单的方法：

public void increase() {
    this.count++;
}

这是一个常见的计数器递增方法，this.count++实际是this.count = this.count + 1，由一个对变量this.count的读取操作和写入操作组成。如果在多线程情况下，两个线程执行这两个操作的顺序是不可预期的。如果 this.count的初始值是1，两个线程可能都读到了为1的值，然后先后把this.count的值设为2，从而产生错误。错误的原因在于其中一个线程对this.count的写入操作对另外一个线程是不可见的，另外一个线程不知道this.count的值已经发生了变化。如果在increase() 方法声明中加上synchronized关键词，那就在两个线程的操作之间强制定义了一个“在之前发生”顺序。一个线程需要首先获得当前对象上的锁才能执行，在它拥有锁的这段时间完成对this.count的写入操作。而另一个线程只有在当前线程释放了锁之后才能执行。这样的话，就保证了两个线程对 increase()方法的调用只能依次完成，保证了线程之间操作上的可见性。

如果一个变量的值可能被多个线程读取，又能被最少一个线程锁写入，同时这些读写操作之间并没有定义好的“在之前发生”的顺序的话，那么在这个变量上就存在数据竞争（data race）。数据竞争的存在是Java多线程应用中要解决的首要问题。解决的办法就是通过synchronized和volatile关键词来定义好“在之前发生”顺序。

Java中的锁

当数据竞争存在的时候，最简单的解决办法就是加锁。锁机制限制在同一时间只允许一个线程访问产生竞争的数据的临界区。Java语言中的 synchronized关键字可以为一个代码块或是方法进行加锁。任何Java对象都有一个自己的监视器，可以进行加锁和解锁操作。当受到 synchronized关键字保护的代码块或方法被执行的时候，就说明当前线程已经成功的获取了对象的监视器上的锁。当代码块或是方法正常执行完成或是发生异常退出的时候，当前线程所获取的锁会被自动释放。一个线程可以在一个Java对象上加多次锁。同时JVM保证了在获取锁之前和释放锁之后，变量的值是与主存中的内容同步的。

Java线程的同步

在有些情况下，仅依靠线程之间对数据的互斥访问是不够的。有些线程之间存在协作关系，需要按照一定的协议来协同完成某项任务，比如典型的生产者-消费者模式。这种情况下就需要用到Java提供的线程之间的等待-通知机制。当线程所要求的条件不满足时，就进入等待状态；而另外的线程则负责在合适的时机发出通知来唤醒等待中的线程。Java中的java.lang.Object类中的 wait/notify/notifyAll 方法组就是完成线程之间的同步的。

Java深度解析之字节代码操控与类的加载链接初始化

Tue, 02 Aug 2011 15:28:00 +0000

本系列的文章转载自 infoq专栏合集《Java深度历险》，10篇文章分别由浅到深描述了Java的多个细节，具体包括

Java 字节代码的操纵
Java类的加载、链接和初始化
Java线程：基本概念、可见性与同步
Java垃圾回收机制与引用类型
Java泛型
Java注解
Java反射与动态代理
Java I/O
Java安全
Java对象序列化与RMI

相信通过十个主题的学习，读者能对Java的这几个方面有较深入的理解。enjoy it！

Java 字节代码的操纵

在一般的Java应用开发过程中，开发人员使用Java的方式比较简单。打开惯用的IDE，编写Java源代码，再利用IDE提供的功能直接运行Java 程序就可以了。这种开发模式背后的过程是：开发人员编写的是Java源代码文件（.java），IDE会负责调用Java的编译器把Java源代码编译成平台无关的字节代码（byte code），以类文件的形式保存在磁盘上（.class）。Java虚拟机（JVM）会负责把Java字节代码加载并执行。Java通过这种方式来实现其 “编写一次，到处运行（Write once, run anywhere）”的目标。Java类文件中包含的字节代码可以被不同平台上的JVM所使用。Java字节代码不仅可以以文件形式存在于磁盘上，也可以通过网络方式来下载，还可以只存在于内存中。JVM中的类加载器会负责从包含字节代码的字节数组（byte[]）中定义出Java类。在某些情况下，可能会需要动态的生成 Java字节代码，或是对已有的Java字节代码进行修改。这个时候就需要用到本文中将要介绍的相关技术。首先介绍一下如何动态编译Java源文件。

动态编译 Java 源文件

在一般情况下，开发人员都是在程序运行之前就编写完成了全部的Java源代码并且成功编译。对有些应用来说，Java源代码的内容在运行时刻才能确定。这个时候就需要动态编译源代码来生成Java字节代码，再由JVM来加载执行。典型的场景是很多算法竞赛的在线评测系统（如 PKU JudgeOnline），允许用户上传Java代码，由系统在后台编译、运行并进行判定。在动态编译Java源文件时，使用的做法是直接在程序中调用Java编译器。

JSR 199

引入了Java编译器API。如果使用JDK 6 的话，可以通过此API来动态编译Java代码。比如下面的代码用来动态编译最简单的Hello World类。该Java类的代码是保存在一个字符串中的。

public class CompilerTest {
  public static void main(String[] args) throws Exception {
    String source = "public class Main { public static void main(String[] args){System.out.println("Hello World!");}}";
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler()
    StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);     
    StringSourceJavaObject sourceObject = new CompilerTest.StringSourceJavaObject("Main", source);     
    Iterable< extends JavaFileObject> fileObjects = Arrays.asList(sourceObject);
    CompilationTask task = compiler.getTask(null, fileManager, null, null, null, fileObjects);
    boolean result = task.call();
    if (result) {
      System.out.println("编译成功。");
    }
}

static class StringSourceJavaObject extends SimpleJavaFileObject {
  private String content = null;
  public StringSourceJavaObject(String name, String content) throws URISyntaxException {
    super(URI.create("string:///" + name.replace('.','/') + Kind.SOURCE.extension), Kind.SOURCE);
    this.content = content;
  }
  public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
     return content;
  }
 }
}

如果不能使用 JDK 6 提供的 Java 编译器 API 的话，可以使用 JDK 中的工具类 com.sun.tools.javac.Main，不过该工具类只能编译存放在磁盘上的文件，类似于直接使用javac命令。

阿里云应用托管（ACE）搭建 wordpress 博客

Sat, 30 Jul 2011 09:58:15 +0000

成功搭建ACE应用：http://carey.aliapp.com, 步骤总结如下：

访问 http://ace.aliyun.com/，申请ACE的CloudID，并且启动域名解析，目前在内测阶段，需要邀请码才可以
下载中文版 wordpress，下载地址：http://cn.wordpress.org/
解压 wordpress压缩包，并且修改部分文件，具体如下：
用Ftp软件将wordpress文件夹中的全部文件上传到ACE的FTP服务器，我用的是Flashfxp
访问http://carey(ACE域名).aliapp.com/wp-admin/install.php 完成后续的安装过程

全文信息检索之 Lucene 简介

Fri, 29 Jul 2011 16:24:12 +0000

Lucene 简介

Lucene 是一个基于 Java 的全文信息检索工具包，它不是一个完整的搜索应用程序，而是为你的应用程序提供索引和搜索功能。Lucene 目前是 Apache Jakarta 家族中的一个开源项目。也是目前最为流行的基于 Java 开源全文检索工具包。

目前已经有很多应用程序的搜索功能是基于 Lucene 的，比如 Eclipse 的帮助系统的搜索功能。Lucene 能够为文本类型的数据建立索引，所以你只要能把你要索引的数据格式转化的文本的，Lucene 就能对你的文档进行索引和搜索。比如你要对一些 HTML 文档，PDF 文档进行索引的话你就首先需要把 HTML 文档和 PDF 文档转化成文本格式的，然后将转化后的内容交给 Lucene 进行索引，然后把创建好的索引文件保存到磁盘或者内存中，最后根据用户输入的查询条件在索引文件上进行查询。不指定要索引的文档的格式也使 Lucene 能够几乎适用于所有的搜索应用程序。

下图表示了搜索应用程序和 Lucene 之间的关系，也反映了利用 Lucene 构建搜索应用程序的流程：

索引和搜索

索引是现代搜索引擎的核心，建立索引的过程就是把源数据处理成非常方便查询的索引文件的过程。为什么索引这么重要呢，试想你现在要在大量的文档中搜索含有某个关键词的文档，那么如果不建立索引的话你就需要把这些文档顺序的读入内存，然后检查这个文章中是不是含有要查找的关键词，这样的话就会耗费非常多的时间，想想搜索引擎可是在毫秒级的时间内查找出要搜索的结果的。这就是由于建立了索引的原因，你可以把索引想象成这样一种数据结构，他能够使你快速的随机访问存储在索引中的关键词，进而找到该关键词所关联的文档。Lucene 采用的是一种称为反向索引（inverted index）的机制。反向索引就是说我们维护了一个词 / 短语表，对于这个表中的每个词 / 短语，都有一个链表描述了有哪些文档包含了这个词 / 短语。这样在用户输入查询条件的时候，就能非常快的得到搜索结果。我们将在本系列文章的第二部分详细介绍 Lucene 的索引机制，由于 Lucene 提供了简单易用的 API，所以即使读者刚开始对全文本进行索引的机制并不太了解，也可以非常容易的使用 Lucene 对你的文档实现索引。

对文档建立好索引后，就可以在这些索引上面进行搜索了。搜索引擎首先会对搜索的关键词进行解析，然后再在建立好的索引上面进行查找，最终返回和用户输入的关键词相关联的文档。

Lucene 软件包分析

Lucene 软件包的发布形式是一个 JAR 文件，下面我们分析一下这个 JAR 文件里面的主要的 JAVA 包，使读者对之有个初步的了解。

Package: org.apache.lucene.document 这个包提供了一些为封装要索引的文档所需要的类，比如 Document, Field。这样，每一个文档最终被封装成了一个 Document 对象。

个人项目

Thu, 28 Jul 2011 09:20:28 +0000

项目代码管理平台：

电子书共享平台

电子书籍

MySQL在线资源与手册

Wed, 27 Jul 2011 11:58:06 +0000

MySQL作为现在比较流行的开源数据库系统，在中小型项目的开发中使用的比较多，本文收集了一些实用的在线资源可以方便MySQL数据库的学习和在线手册的参考。

1)Official Home Of MySql

2) W3Schools.com

3)MySql Basics

4) Tutorialized.com

5) Tizag MySql Tutorials

6)Tutorialspoint.com

7)MySql Forge

8)Official MySql Forum

9)Devshed.com

10)Sitepoint.com

11)Planet MySql

12)MySql Performance Blog

13)Sql.org

14)RoseIndia

15)WebDevelopersNotes

实用的PHP正则表达式函数库

Wed, 27 Jul 2011 10:36:40 +0000

在平常的web开发中，经常需要处理文本的匹配和替换，以及表单的验证，下面这些实用的经过验证的代码相信会给开发带来很多便利！

1) String Mtach

2) Password Match Validation

3) Email Address Validation

4) Date Format Validation

5)Validate URL

6)Validate URL using Preg_match

7)Email Validation Using ereg

8 )IP Address Matching Valdation

9)UK Postcode Validation

10)SSN,ISBN and Zipcode Validation

为什么每个程序设计者都应该学习 Python 或者 Ruby

Mon, 25 Jul 2011 10:47:13 +0000

这是一篇选自外文的评论文章，该文告诉我们为什么要选择python或者ruby，他们相比较其他的编程语言有哪些优势，对我们以后的开发会有怎样的帮助。

=========== 英文原文============

If you are a student, you probably know C, C++ and Java. A few know VB, or C# / .NET. At some point you’ve probably built some web pages, so you know HTML, CSS and maybe JavaScript. By and large, it is difficult to find students who have any exposure to languages beyond this. And this is a shame because there are a number of programming languages out there which will make you a better programmer.

Web 设计师专用的 Firefox 4 插件

Thu, 21 Jul 2011 09:30:09 +0000

有什么好的方法可以有效提高web的开发效率，无非就是拥有合适和便捷的开发工具，相信通过本文推荐的几款插件可以大大提高开发的效率和便于程序的调试，enjoy it…

1) Codtch

2)CSSUsage

3)JavaScript Debugger

4)ColorZilla

5) Firebug

6)Web Developer

7) Total Validator

8 ) HTML Validator

9) FirePHP

10)MeasureIt

项目管理工具

Tue, 12 Jul 2011 10:03:25 +0000

1. Basecamp

Basecamp 是一个很棒的在线项目管理和协作平台，用户可在上面创建和管理任务。使用 Basecamp，雇员可轻松的和团队以及客户分享文档、幻灯片和项目。

2. LightHouse

Lighthouse 是另一个在线协作工具，帮你管理工作流。有了 LightHouse 用户可自动组织各种工作任务、集成了 email 客户端，使用里程碑进行项目计划，可直接附加文档和图片。

3. Wrike

Wrike 是一个社会化项目管理软件，帮助成千上万的公司高效、实时的管理各种项目，包括项目管理、时间跟踪、甘特图、excel的导入导出、任务管理等等功能。

4. Comindwork

Comindwork 帮助用户管理各种不同的项目，有了 Comindwork，雇员和客户可管理待办事宜、wiki、email，使用甘特图表、MS Project 和工作流等技术。

5. CreativePro Office

CreativePro Office 是非常帮的项目管理工具，帮助雇员管理包括任务、时间消耗、发票金额、项目联系人、备注和消息等等，这些功能都在一个视图中进行展示，非常直观。

6. 5PM

5pm™ 是一个直观的基于 Web 的项目管理工具，帮助用户管理项目、任务以及协同工作，时间跟踪等等。

7. Zoho Projects

Zoho Projects 是一个在线项目管理软件，提供协作和bug跟踪功能。

8. ProjectDesk

Project Desk 是一个在线的项目和任务管理工具，提供虚拟的工作空间为成员提供高效的通讯手段。

9. Huddle

Huddle 帮助雇员管理任务、项目，分享文件和协作信息

10. Proworkflow

ProWorkflow 为你的公司管理项目、任务、时间跟踪、成员和联系人管理等等。

如何正确处理 Java 中的中文编码

Fri, 08 Jul 2011 10:13:41 +0000

在Java的程序设计过程中，经常碰到需要处理中文的地方，如何能正确的对汉字进行编码解码非常关键，不然通常都会出现汉字无法正常处理的情况，有时候会变成一些？？？，而有的时候会显示一些奇怪的符号，本文摘自IBM文库，该文章详细介绍了java中的中文编码问题。

几种常见的编码格式

为什么要编码

不知道大家有没有想过一个问题，那就是为什么要编码？我们能不能不编码？要回答这个问题必须要回到计算机是如何表示我们人类能够理解的符号的，这些符号也就是我们人类使用的语言。由于人类的语言有太多，因而表示这些语言的符号太多，无法用计算机中一个基本的存储单元—— byte 来表示，因而必须要经过拆分或一些翻译工作，才能让计算机能理解。我们可以把计算机能够理解的语言假定为英语，其它语言要能够在计算机中使用必须经过一次翻译，把它翻译成英语。这个翻译的过程就是编码。所以可以想象只要不是说英语的国家要能够使用计算机就必须要经过编码。这看起来有些霸道，但是这就是现状，这也和我们国家现在在大力推广汉语一样，希望其它国家都会说汉语，以后其它的语言都翻译成汉语，我们可以把计算机中存储信息的最小单位改成汉字，这样我们就不存在编码问题了。

所以总的来说，编码的原因可以总结为：

计算机中存储信息的最小单元是一个字节即 8 个 bit，所以能表示的字符范围是 0~255 个
人类要表示的符号太多，无法用一个字节来完全表示
要解决这个矛盾必须需要一个新的数据结构 char，从 char 到 byte 必须编码

如何“翻译”

明白了各种语言需要交流，经过翻译是必要的，那又如何来翻译呢？计算中提拱了多种翻译方式，常见的有 ASCII、ISO-8859-1、GB2312、GBK、UTF-8、UTF-16 等。它们都可以被看作为字典，它们规定了转化的规则，按照这个规则就可以让计算机正确的表示我们的字符。目前的编码格式很多，例如 GB2312、GBK、UTF-8、UTF-16 这几种格式都可以表示一个汉字，那我们到底选择哪种编码格式来存储汉字呢？这就要考虑到其它因素了，是存储空间重要还是编码的效率重要。根据这些因素来正确选择编码格式，下面简要介绍一下这几种编码格式。

ASCII 码

学过计算机的人都知道 ASCII 码，总共有 128 个，用一个字节的低 7 位表示，0~~31 是控制字符如换行回车删除等；32~~126 是打印字符，可以通过键盘输入并且能够显示出来。

ISO-8859-1

128 个字符显然是不够用的，于是 ISO 组织在 ASCII 码基础上又制定了一些列标准用来扩展 ASCII 编码，它们是 ISO-8859-1~ISO-8859-15，其中 ISO-8859-1 涵盖了大多数西欧语言字符，所有应用的最广泛。ISO-8859-1 仍然是单字节编码，它总共能表示 256 个字符。

GB2312

它的全称是《信息交换用汉字编码字符集基本集》，它是双字节编码，总的编码范围是 A1-F7，其中从 A1-A9 是符号区，总共包含 682 个符号，从 B0-F7 是汉字区，包含 6763 个汉字。

全称叫《汉字内码扩展规范》，是国家技术监督局为 windows95 所制定的新的汉字内码规范，它的出现是为了扩展 GB2312，加入更多的汉字，它的编码范围是 8140~FEFE（去掉 XX7F）总共有 23940 个码位，它能表示 21003 个汉字，它的编码是和 GB2312 兼容的，也就是说用 GB2312 编码的汉字可以用 GBK 来解码，并且不会有乱码。

搭建PHP在线代理

Thu, 07 Jul 2011 22:40:57 +0000

想用你的主机搭建在线代理服务器么，本文就介绍几个比较优秀的PHP在线代理脚本。

phpMyProxy

phpMyProxy is a free, light and powerful php-based proxy script. The script is free and released under a GNU GPL Version 3, so you’re pretty much free to use, share, modify, redistribute, etc. The proxy script is fast and secure, requires a little server resource, encodes web address, supports Gzip Compression to save bandwidth, works with HTTPS (Secure HTTP) connections and provides very easy customization (language translation and template modification). phpMyProxy script requires PHP 4.0.2 or higher with cURL installed and session support.

15个绚丽的jQuery特效

Thu, 07 Jul 2011 11:38:13 +0000

Vintage typewriter: The sexiest jQuery contact form ever

Shutter Effect Portfolio with jQuery and Canvas

How To Build a Sliding Feature Slideshow with jQuery

Drag Drop Shopping Cart Using JQuery

Image Wall with jQuery

Photobooth with PHP, jQuery and CSS3

HTML5 Grayscale Image Hover

10个优秀的JavaScript框架

Wed, 06 Jul 2011 22:01:43 +0000

本文推荐几个优秀的JavaScript框架：

1)JQuery-JavaScript Library

2) MooTools-JavaScript FrameWork

3)Adobe Spry-Ajax Framework

4)SproutCore-JavaScript Framework

5)JavaScriptMVC-javaScript Framework

6) Raphael-JavaScript Library

7)DHTMLX-JavaScript Library

8 )Rico -Ajax Framework

9) YUI Yahoo-JavaScript And CSS Library

10)Prototype-JavaScript Framework

巧用DOS脚本删除工程的SVN信息

Tue, 05 Jul 2011 20:33:52 +0000

从网络上的SVN服务器上面把代码下载下来，有时候想完全去除掉该工程项目的svn信息，我们都知道svn信息保存在工程项目中的每个隐藏的.svn文件夹下面，如果手动删除的话，有可能删除不完全，导致重新导入的时候会出现错误，本文分享一个实用的dos脚本，只要将其放置到工程项目的根目录下，单击运行一次即可，就会全部清除掉隐藏的svn文件信息。

代码如下：

@echo off
for /r %%a in (.) do if exist %%a.svn rd /s/q %%a.svn
pause
@echo on

将其拷贝到本地的文本文件中，命名为removesvn.bat即可。

然后将 removesvn.bat 放到需要清除svn信息的工程文件夹中运行一次就ok。

XML-RPC 之 Android实现（下）

Tue, 05 Jul 2011 17:55:01 +0000

代码对RPC的请求进行了封装，至于XML格式的生成请参照上一篇博文《XML-RPC 之 Android实现（上）》。

package org.xmlrpc.android;

import java.io.File;
import java.io.FileWriter;
import java.io.PushbackInputStream;
import java.io.StringWriter;
import java.net.URI;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.util.Map;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.FileEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.wordpress.android.util.ConnectionClient;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserFactory;
import org.xmlpull.v1.XmlSerializer;

import android.os.Environment;
import android.util.Log;
import android.util.Xml;

public class XMLRPCClient {
private static final String TAG_METHOD_CALL = "methodCall";
private static final String TAG_METHOD_NAME = "methodName";
private static final String TAG_METHOD_RESPONSE = "methodResponse";
private static final String TAG_PARAMS = "params";
private static final String TAG_PARAM = "param";
private static final String TAG_FAULT = "fault";
private static final String TAG_FAULT_CODE = "faultCode";
private static final String TAG_FAULT_STRING = "faultString";

private ConnectionClient client;
private HttpPost postMethod;
private XmlSerializer serializer;
private HttpParams httpParams;

/**
* XMLRPCClient constructor. Creates new instance based on server URI
*
* @param XMLRPC
*            server URI
*/
public XMLRPCClient(URI uri, String httpuser, String httppasswd) {
postMethod = new HttpPost(uri);
postMethod.addHeader("Content-Type", "text/xml");
postMethod.addHeader("charset", "UTF-8");
// UPDATE THE VERSION NUMBER BEFORE RELEASE! <3 Dan
postMethod.addHeader("User-Agent", "wp-android/1.4.1");

httpParams = postMethod.getParams();
HttpProtocolParams.setUseExpectContinue(httpParams, false);

// username & password not needed
UsernamePasswordCredentials creds = new UsernamePasswordCredentials(
httpuser, httppasswd);

// this gets connections working over https
if (uri.getScheme() != null) {
if (uri.getScheme().equals("https")) {
if (uri.getPort() == -1)
try {
client = new ConnectionClient(creds, 443);
} catch (KeyManagementException e) {
client = new ConnectionClient(creds);
} catch (NoSuchAlgorithmException e) {
client = new ConnectionClient(creds);
} catch (KeyStoreException e) {
client = new ConnectionClient(creds);
} catch (UnrecoverableKeyException e) {
client = new ConnectionClient(creds);
}
else
try {
client = new ConnectionClient(creds, uri.getPort());
} catch (KeyManagementException e) {
client = new ConnectionClient(creds);
} catch (NoSuchAlgorithmException e) {
client = new ConnectionClient(creds);
} catch (KeyStoreException e) {
client = new ConnectionClient(creds);
} catch (UnrecoverableKeyException e) {
client = new ConnectionClient(creds);
}
} else {
client = new ConnectionClient(creds);
}
} else {
client = new ConnectionClient(creds);
}

serializer = Xml.newSerializer();
}

/**
* Convenience constructor. Creates new instance based on server String
* address
*
* @param XMLRPC
*            server address
*/
public XMLRPCClient(String url, String httpuser, String httppasswd) {
this(URI.create(url), httpuser, httppasswd);
}

/**
* Convenience XMLRPCClient constructor. Creates new instance based on
* server URL
*
* @param XMLRPC
*            server URL
*/
public XMLRPCClient(URL url, String httpuser, String httppasswd) {
this(URI.create(url.toExternalForm()), httpuser, httppasswd);
}

/**
* Call method with optional parameters. This is general method. If you want
* to call your method with 0-8 parameters, you can use more convenience
* call methods
*
* @param method
*            name of method to call
* @param params
*            parameters to pass to method (may be null if method has no
*            parameters)
* @return deserialized method return value
* @throws XMLRPCException
*/
public Object call(String method, Object[] params) throws XMLRPCException {
return callXMLRPC(method, params);
}

/**
* Convenience method call with no parameters
*
* @param method
*            name of method to call
* @return deserialized method return value
* @throws XMLRPCException
*/
public Object call(String method) throws XMLRPCException {
return callXMLRPC(method, null);
}

/**
* Convenience method call with one parameter
*
* @param method
*            name of method to call
* @param p0
*            method's parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
public Object call(String method, Object p0) throws XMLRPCException {
Object[] params = { p0, };
return callXMLRPC(method, params);
}

/**
* Convenience method call with two parameters
*
* @param method
*            name of method to call
* @param p0
*            method's 1st parameter
* @param p1
*            method's 2nd parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
public Object call(String method, Object p0, Object p1)
throws XMLRPCException {
Object[] params = { p0, p1, };
return callXMLRPC(method, params);
}

/**
* Convenience method call with three parameters
*
* @param method
*            name of method to call
* @param p0
*            method's 1st parameter
* @param p1
*            method's 2nd parameter
* @param p2
*            method's 3rd parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
public Object call(String method, Object p0, Object p1, Object p2)
throws XMLRPCException {
Object[] params = { p0, p1, p2, };
return callXMLRPC(method, params);
}

/**
* Convenience method call with four parameters
*
* @param method
*            name of method to call
* @param p0
*            method's 1st parameter
* @param p1
*            method's 2nd parameter
* @param p2
*            method's 3rd parameter
* @param p3
*            method's 4th parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
public Object call(String method, Object p0, Object p1, Object p2, Object p3)
throws XMLRPCException {
Object[] params = { p0, p1, p2, p3, };
return callXMLRPC(method, params);
}

/**
* Convenience method call with five parameters
*
* @param method
*            name of method to call
* @param p0
*            method's 1st parameter
* @param p1
*            method's 2nd parameter
* @param p2
*            method's 3rd parameter
* @param p3
*            method's 4th parameter
* @param p4
*            method's 5th parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
public Object call(String method, Object p0, Object p1, Object p2,
Object p3, Object p4) throws XMLRPCException {
Object[] params = { p0, p1, p2, p3, p4, };
return callXMLRPC(method, params);
}

/**
* Convenience method call with six parameters
*
* @param method
*            name of method to call
* @param p0
*            method's 1st parameter
* @param p1
*            method's 2nd parameter
* @param p2
*            method's 3rd parameter
* @param p3
*            method's 4th parameter
* @param p4
*            method's 5th parameter
* @param p5
*            method's 6th parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
public Object call(String method, Object p0, Object p1, Object p2,
Object p3, Object p4, Object p5) throws XMLRPCException {
Object[] params = { p0, p1, p2, p3, p4, p5, };
return callXMLRPC(method, params);
}

/**
* Convenience method call with seven parameters
*
* @param method
*            name of method to call
* @param p0
*            method's 1st parameter
* @param p1
*            method's 2nd parameter
* @param p2
*            method's 3rd parameter
* @param p3
*            method's 4th parameter
* @param p4
*            method's 5th parameter
* @param p5
*            method's 6th parameter
* @param p6
*            method's 7th parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
public Object call(String method, Object p0, Object p1, Object p2,
Object p3, Object p4, Object p5, Object p6) throws XMLRPCException {
Object[] params = { p0, p1, p2, p3, p4, p5, p6, };
return callXMLRPC(method, params);
}

/**
* Convenience method call with eight parameters
*
* @param method
*            name of method to call
* @param p0
*            method's 1st parameter
* @param p1
*            method's 2nd parameter
* @param p2
*            method's 3rd parameter
* @param p3
*            method's 4th parameter
* @param p4
*            method's 5th parameter
* @param p5
*            method's 6th parameter
* @param p6
*            method's 7th parameter
* @param p7
*            method's 8th parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
public Object call(String method, Object p0, Object p1, Object p2,
Object p3, Object p4, Object p5, Object p6, Object p7)
throws XMLRPCException {
Object[] params = { p0, p1, p2, p3, p4, p5, p6, p7, };
return callXMLRPC(method, params);
}

/**
* Call method with optional parameters
*
* @param method
*            name of method to call
* @param params
*            parameters to pass to method (may be null if method has no
*            parameters)
* @return deserialized method return value
* @throws XMLRPCException
*/
@SuppressWarnings("unchecked")
private Object callXMLRPC(String method, Object[] params)
throws XMLRPCException {
try {
// prepare POST body
File tempFile = null;
if (method.equals("wp.uploadFile")) {
String tempFilePath = Environment.getExternalStorageDirectory()
+ File.separator + "wordpress" + File.separator + "wp-"
+ System.currentTimeMillis() + ".xml";

File directory = new File(tempFilePath).getParentFile();
if (!directory.exists() && !directory.mkdirs()) {
throw new XMLRPCException(
"Path to file could not be created.");
}

tempFile = new File(tempFilePath);
FileWriter fileWriter = new FileWriter(tempFile);
serializer.setOutput(fileWriter);

serializer.startDocument(null, null);
serializer.startTag(null, TAG_METHOD_CALL);
// set method name
serializer.startTag(null, TAG_METHOD_NAME).text(method)
.endTag(null, TAG_METHOD_NAME);
if (params != null && params.length != 0) {
// set method params
serializer.startTag(null, TAG_PARAMS);
for (int i = 0; i < params.length; i++) {
serializer.startTag(null, TAG_PARAM).startTag(null,
XMLRPCSerializer.TAG_VALUE);
XMLRPCSerializer
.serialize(serializer, params[i], false);
serializer.endTag(null, XMLRPCSerializer.TAG_VALUE)
.endTag(null, TAG_PARAM);
}
serializer.endTag(null, TAG_PARAMS);
}
serializer.endTag(null, TAG_METHOD_CALL);
serializer.endDocument();

fileWriter.flush();
fileWriter.close();
FileEntity fEntity = new FileEntity(tempFile,
"text/xml; charset="UTF-8"");
fEntity.setContentType("text/xml");
// fEntity.setChunked(true);
postMethod.setEntity(fEntity);
} else {
StringWriter bodyWriter = new StringWriter();
serializer.setOutput(bodyWriter);

serializer.startDocument(null, null);
serializer.startTag(null, TAG_METHOD_CALL);
// set method name
serializer.startTag(null, TAG_METHOD_NAME).text(method)
.endTag(null, TAG_METHOD_NAME);
if (params != null && params.length != 0) {
// set method params
serializer.startTag(null, TAG_PARAMS);
for (int i = 0; i < params.length; i++) {
serializer.startTag(null, TAG_PARAM).startTag(null,
XMLRPCSerializer.TAG_VALUE);
if (method.equals("metaWeblog.editPost")
|| method.equals("metaWeblog.newPost")) {
XMLRPCSerializer.serialize(serializer, params[i],
true);
} else {
XMLRPCSerializer.serialize(serializer, params[i],
false);

}
serializer.endTag(null, XMLRPCSerializer.TAG_VALUE)
.endTag(null, TAG_PARAM);
}
serializer.endTag(null, TAG_PARAMS);
}
serializer.endTag(null, TAG_METHOD_CALL);
serializer.endDocument();

HttpEntity entity = new StringEntity(bodyWriter.toString());
// Log.i("WordPress", bodyWriter.toString());
postMethod.setEntity(entity);
}

// set timeout to 40 seconds, does it need to be set for both client
// and method?
client.getParams().setParameter(
CoreConnectionPNames.CONNECTION_TIMEOUT, 40000);
client.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT,
40000);
postMethod.getParams().setParameter(
CoreConnectionPNames.CONNECTION_TIMEOUT, 40000);
postMethod.getParams().setParameter(
CoreConnectionPNames.SO_TIMEOUT, 40000);

// execute HTTP POST request
HttpResponse response = client.execute(postMethod);

Log.i("WordPress", "response = " + response.getStatusLine());
// check status code
int statusCode = response.getStatusLine().getStatusCode();

if ((method.equals("wp.uploadFile"))) { // get rid of the temp file
tempFile.delete();
}

if (statusCode != HttpStatus.SC_OK) {
throw new XMLRPCException("HTTP status code: " + statusCode
+ " was returned. "
+ response.getStatusLine().getReasonPhrase());
}

// setup pull parser
XmlPullParser pullParser = XmlPullParserFactory.newInstance()
.newPullParser();
HttpEntity entity = response.getEntity();
// change to pushbackinput stream 1/18/2010 to handle self installed
// wp sites that insert the BOM
PushbackInputStream is = new PushbackInputStream(
entity.getContent());

// get rid of junk characters before xml response. 60 = '<'. Added
// stopper to prevent infinite loop
int bomCheck = is.read();
int stopper = 0;
while (bomCheck != 60 && stopper < 20) {
bomCheck = is.read();
stopper++;
}
is.unread(bomCheck);

pullParser.setInput(is, "UTF-8");

// lets start pulling...
pullParser.nextTag();
pullParser.require(XmlPullParser.START_TAG, null,
TAG_METHOD_RESPONSE);

pullParser.nextTag(); // either TAG_PARAMS (<params>) or TAG_FAULT
// (<fault>)
String tag = pullParser.getName();
if (tag.equals(TAG_PARAMS)) {
// normal response
pullParser.nextTag(); // TAG_PARAM (<param>)
pullParser.require(XmlPullParser.START_TAG, null, TAG_PARAM);
pullParser.nextTag(); // TAG_VALUE (<value>)
// no parser.require() here since its called in
// XMLRPCSerializer.deserialize() below

// deserialize result
Object obj = XMLRPCSerializer.deserialize(pullParser);
entity.consumeContent();
return obj;
} else if (tag.equals(TAG_FAULT)) {
// fault response
pullParser.nextTag(); // TAG_VALUE (<value>)
// no parser.require() here since its called in
// XMLRPCSerializer.deserialize() below

// deserialize fault result
Map<String, Object> map = (Map<String, Object>) XMLRPCSerializer
.deserialize(pullParser);
String faultString = (String) map.get(TAG_FAULT_STRING);
int faultCode = (Integer) map.get(TAG_FAULT_CODE);
entity.consumeContent();
throw new XMLRPCFault(faultString, faultCode);
} else {
entity.consumeContent();
throw new XMLRPCException("Bad tag <" + tag
+ "> in XMLRPC response - neither <params> nor <fault>");
}
} catch (XMLRPCException e) {
// catch & propagate XMLRPCException/XMLRPCFault
throw e;
} catch (Exception e) {
// wrap any other Exception(s) around XMLRPCException
throw new XMLRPCException(e);
}
}
}

其他工具类的实现，比如错误，异常的实现类和Base64的编码和解码请参照：android_rpc。

XML-RPC 之 Android实现（上）

Tue, 05 Jul 2011 17:44:03 +0000

xml-rpc的文档规范请参照博文《XML-RPC 规范》，本文是其android版本的一个实现，代码摘自wordpress的官方android发布版。

主要XML的封装和解封代码实现如下，实现了将Java的数据类型封装成xml-rpc请求格式的xml数据和解析xml格式的返回数据来转换成java的数据类型：

package org.xmlrpc.android;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.Map.Entry;

import org.wordpress.android.models.MediaFile;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlSerializer;

class XMLRPCSerializer {
 static final String TAG_NAME = "name";
 static final String TAG_MEMBER = "member";
 static final String TAG_VALUE = "value";
 static final String TAG_DATA = "data";

 static final String TYPE_INT = "int";
 static final String TYPE_I4 = "i4";
 static final String TYPE_I8 = "i8";
 static final String TYPE_DOUBLE = "double";
 static final String TYPE_BOOLEAN = "boolean";
 static final String TYPE_STRING = "string";
 static final String TYPE_DATE_TIME_ISO8601 = "dateTime.iso8601";
 static final String TYPE_BASE64 = "base64";
 static final String TYPE_ARRAY = "array";
 static final String TYPE_STRUCT = "struct";

 static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd'T'HH:mm:ss");

 /**
 * 序列化请求数据，封装成对应的XML格式.
 *
 * 请求示例：
 *
 * <methodCall>
 *     <methodName>examples.getStateName</methodName>
 *       <params>
 *          <param>
 *             <value><i4>41</i4></value>
 *          </param>
 *        </params>
 *  </methodCall>
 *
 * 结构体：
 *  <struct>
 *     <member>
 *         <name>lowerBound</name>
 *         <value><i4>18</i4></value>
 *     </member>
 *     <member>
 *         <name>upperBound</name>
 *         <value><i4>139</i4></value>
 *     </member>
 *  </struct>
 *
 * 数组：
 *  <array>
 *     <data>
 *        <value><i4>12</i4></value>
 *        <value><string>Egypt</string></value>
 *        <value><boolean>0</boolean></value>
 *        <value><i4>-31</i4></value>
 *     </data>
 *  </array>
 * 
 * */
 static void serialize(XmlSerializer serializer, Object object,
 boolean convertToGMT) throws IOException {
 // check for scalar types:
 if (object instanceof Integer || object instanceof Short
 || object instanceof Byte) {
 // 基本类型： 整型
 serializer.startTag(null, TYPE_I4).text(object.toString()).endTag(null, TYPE_I4);
 } else if (object instanceof Long) {
 // 基本类型： 长整型
 serializer.startTag(null, TYPE_I8).text(object.toString()).endTag(null, TYPE_I8);
 } else if (object instanceof Double || object instanceof Float) {
 // 基本类型： 浮点型
 serializer.startTag(null, TYPE_DOUBLE).text(object.toString()).endTag(null, TYPE_DOUBLE);
 } else if (object instanceof Boolean) {
 // 基本类型： 布尔型
 Boolean bool = (Boolean) object;
 String boolStr = bool.booleanValue() ? "1" : "0";
 serializer.startTag(null, TYPE_BOOLEAN).text(boolStr).endTag(null, TYPE_BOOLEAN);
 } else if (object instanceof String) {
 // 基本类型： 字符串型
 serializer.startTag(null, TYPE_STRING).text(object.toString()).endTag(null, TYPE_STRING);
 } else if (object instanceof Date || object instanceof Calendar) {
 // 基本类型： 日期型
 Date date = (Date) object;
 SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd'T'HH:mm:ss");
 if (convertToGMT) {
 long pubDate = date.getTime();
 TimeZone tz = TimeZone.getDefault();
 long offset = tz.getOffset(pubDate);
 pubDate += offset * -1;
 date = new Date(pubDate);
 }
 String sDate = dateFormat.format(date);
 serializer.startTag(null, TYPE_DATE_TIME_ISO8601).text(sDate).endTag(null, TYPE_DATE_TIME_ISO8601);
 } else if (object instanceof byte[]) {
 // 基本类型： Base64编码型
 String value = new String(Base64Coder.encode((byte[]) object));
 serializer.startTag(null, TYPE_BASE64).text(value).endTag(null, TYPE_BASE64);
 } else if (object instanceof MediaFile) {
 // 基本类型： Base64编码型
 // convert media file binary to base64
 serializer.startTag(null, "base64");
 MediaFile videoFile = (MediaFile) object;
 InputStream inStream = new DataInputStream(new FileInputStream(videoFile.getFilePath()));
 byte[] buffer = new byte[3600];// you must use a 24bit multiple
 int length = -1;
 String chunk = null;
 // int ctr = 0;
 // Log.i("WordPress", "converting media file to base64");
 while ((length = inStream.read(buffer)) > 0) {
 chunk = Base64.encodeBytes(buffer, 0, length);
 serializer.text(chunk);
 // ctr+=3600;
 // Log.i("WordPress", "chunk " + ctr);
 }
 // Log.i("WordPress", "conversion done!");
 inStream.close();
 serializer.endTag(null, "base64");
 } else if (object instanceof List<?>) {
 // 复合类型： 数组型
 serializer.startTag(null, TYPE_ARRAY).startTag(null, TAG_DATA);
 List<Object> list = (List<Object>) object;
 Iterator<Object> iter = list.iterator();
 while (iter.hasNext()) {
 Object o = iter.next();
 serializer.startTag(null, TAG_VALUE);
 serialize(serializer, o, convertToGMT);
 serializer.endTag(null, TAG_VALUE);
 }
 serializer.endTag(null, TAG_DATA).endTag(null, TYPE_ARRAY);
 } else if (object instanceof Object[]) {
 // 复合类型： 数组型
 serializer.startTag(null, TYPE_ARRAY).startTag(null, TAG_DATA);
 Object[] objects = (Object[]) object;
 for (int i = 0; i < objects.length; i++) {
 Object o = objects[i];
 serializer.startTag(null, TAG_VALUE);
 serialize(serializer, o, convertToGMT);
 serializer.endTag(null, TAG_VALUE);
 }
 serializer.endTag(null, TAG_DATA).endTag(null, TYPE_ARRAY);
 } else if (object instanceof Map) {
 // 复合类型： 结构型
 serializer.startTag(null, TYPE_STRUCT);
 Map<String, Object> map = (Map<String, Object>) object;
 Iterator<Entry<String, Object>> iter = map.entrySet().iterator();
 while (iter.hasNext()) {
 Entry<String, Object> entry = iter.next();
 String key = entry.getKey();
 Object value = entry.getValue();

 serializer.startTag(null, TAG_MEMBER);
 serializer.startTag(null, TAG_NAME).text(key).endTag(null, TAG_NAME);
 serializer.startTag(null, TAG_VALUE);
 serialize(serializer, value, convertToGMT);
 serializer.endTag(null, TAG_VALUE);
 serializer.endTag(null, TAG_MEMBER);
 }
 serializer.endTag(null, TYPE_STRUCT);
 } else {
 throw new IOException("Cannot serialize " + object);
 }
 }

 /**
 * 反序列化服务器的返回数据，解封成Java的数据类型.
 *
 * 回复示例：
 *
 * <methodResponse>
 *    <params>
 *       <param>
 *         <value><string>South Dakota</string></value>
 *       </param>
 *    </params>
 * </methodResponse>
 * */
 static Object deserialize(XmlPullParser parser)
 throws XmlPullParserException, IOException {
 parser.require(XmlPullParser.START_TAG, null, TAG_VALUE);

 parser.nextTag();
 String typeNodeName = parser.getName();

 Object obj;
 if (typeNodeName.equals(TYPE_INT) || typeNodeName.equals(TYPE_I4)) {
 String value = parser.nextText();
 obj = Integer.parseInt(value);
 } else if (typeNodeName.equals(TYPE_I8)) {
 String value = parser.nextText();
 obj = Long.parseLong(value);
 } else if (typeNodeName.equals(TYPE_DOUBLE)) {
 String value = parser.nextText();
 obj = Double.parseDouble(value);
 } else if (typeNodeName.equals(TYPE_BOOLEAN)) {
 String value = parser.nextText();
 obj = value.equals("1") ? Boolean.TRUE : Boolean.FALSE;
 } else if (typeNodeName.equals(TYPE_STRING)) {
 obj = parser.nextText();
 } else if (typeNodeName.equals(TYPE_DATE_TIME_ISO8601)) {
 String value = parser.nextText();
 try {
 obj = dateFormat.parseObject(value);
 } catch (ParseException e) {
 e.printStackTrace();
 obj = value;
 // throw new IOException("Cannot deserialize dateTime " + value);
 }
 } else if (typeNodeName.equals(TYPE_BASE64)) {
 String value = parser.nextText();
 BufferedReader reader = new BufferedReader(new StringReader(value));
 String line;
 StringBuffer sb = new StringBuffer();
 while ((line = reader.readLine()) != null) {
 sb.append(line);
 }
 obj = Base64Coder.decode(sb.toString());
 } else if (typeNodeName.equals(TYPE_ARRAY)) {
 parser.nextTag(); // TAG_DATA (<data>)
 parser.require(XmlPullParser.START_TAG, null, TAG_DATA);

 parser.nextTag();
 List<Object> list = new ArrayList<Object>();
 while (parser.getName().equals(TAG_VALUE)) {
 list.add(deserialize(parser));
 parser.nextTag();
 }
 parser.require(XmlPullParser.END_TAG, null, TAG_DATA);
 parser.nextTag(); // TAG_ARRAY (</array>)
 parser.require(XmlPullParser.END_TAG, null, TYPE_ARRAY);
 obj = list.toArray();
 } else if (typeNodeName.equals(TYPE_STRUCT)) {
 parser.nextTag();
 Map<String, Object> map = new HashMap<String, Object>();
 while (parser.getName().equals(TAG_MEMBER)) {
 String memberName = null;
 Object memberValue = null;
 while (true) {
 parser.nextTag();
 String name = parser.getName();
 if (name.equals(TAG_NAME)) {
 memberName = parser.nextText();
 } else if (name.equals(TAG_VALUE)) {
 memberValue = deserialize(parser);
 } else {
 break;
 }
 }
 if (memberName != null && memberValue != null) {
 map.put(memberName, memberValue);
 }
 parser.require(XmlPullParser.END_TAG, null, TAG_MEMBER);
 parser.nextTag();
 }
 parser.require(XmlPullParser.END_TAG, null, TYPE_STRUCT);
 obj = map;
 } else {
 throw new IOException("Cannot deserialize " + parser.getName());
 }
 parser.nextTag(); // TAG_VALUE (</value>)
 parser.require(XmlPullParser.END_TAG, null, TAG_VALUE);
 return obj;
 }
}

其他工具类的实现，比如错误，异常的实现类和Base64的编码和解码请参照：android_rpc

XML-RPC 规范

Tue, 05 Jul 2011 16:35:28 +0000

Overview(简介) XML-RPC is a Remote Procedure Calling protocol that works over the Internet.

An XML-RPC message is an HTTP-POST request. The body of the request is in XML. A procedure executes on the server and the value it returns is also formatted in XML.

Procedure parameters can be scalars, numbers, strings, dates, etc.; and can also be complex record and list structures.

工作机制：

Request example（请求示例）

POST /RPC2 HTTP/1.0
User-Agent: Frontier/5.1.2 (WinNT)
Host: betty.userland.com
Content-Type: text/xml
Content-length: 181

<?xml version="1.0"?>
<methodCall>
   <methodName>examples.getStateName</methodName>
   <params>
      <param>
         <value><i4>41</i4></value>
      </param>
   </params>
</methodCall>

Header requirements（请求中需设置header的必要信息）

jQuery Mobile 教程

Tue, 05 Jul 2011 14:49:21 +0000

Creating a Website Using JQuery Mobile

在本教程中将告诉您如何利用jQuery Mobile建立一个网站。这个教程的第一部分为您解释该网站的特点并且完成网站的主页。

jQuery Mobile: What Can It Do for You?

这是一篇介绍jQuery Mobile主要特性和优点的详细教程，举例说明了如何利用这个新架构帮助你快速建立优质移动应用。

Getting Started with jQuery Mobile & Rails 3

本教程教我们如何利用Rails 3和jQuery Mobile创建CRUD应用。该应用程序将允许我们通过移动设备创建，读取，更新和删除博客帖子。

Creating a Simple App Using jQuery Mobile

在这篇文章中，我们将看看如何利用框架，动态（AJAX）的页面加载，iOS的风格设计和页面过渡等创建一个简单的移动网站。

How to create a mobile WordPress theme with jQuery Mobile

本教程为您介绍如何创建一个移动优化WordPress主题。

6.Two-Minute Tutorial 1

这个两分钟教程展示了如何使用AppLaud和PhoneGap Media API播放音频文件，并使用jQuery Mobile实现按钮和文本显示。它也显示了两种方法来访问音频文件：网址或本地上传。

jQuery Mobile Framework – A Forms Tutorial

jQuery Mobile是一个相对较新的移动网络框架，2010年10月首次发布。该框架有许多有趣的功能来支持移动应用开发。在本教程中，我们将集中于 jQuery Mobile的一些基本要素：页面结构，形式和Ajax提交表单。本教程是基于jQuery Mobile 1.0 alpha版本。

学习 Android 优秀开源项目

Tue, 05 Jul 2011 13:14:28 +0000

FBReaderJ

FBReaderJ用于Android平台的电子书阅读器，它支持多种电子书籍格式包括：oeb、ePub和fb2。此外还支持直接读取zip、tar和gzip等压缩文档。项目地址：FBReaderJ

Angle

Angle是一款专为Android平台设计的，适合快速开发的2D游戏引擎，基于OpenGL ES技术开发。该引擎全部用Java代码编写，并且可以根据自己的需要替换里面的实现。项目地址：angle

android-shuffle

android-shuffle是一个GTD（Getting Things Done）个人备忘记事本。项目地址：android-shuffle

Open GPS Tracker

GPSTracker是一个能够使用Android地图记录你的驾车或旅行路线的项目，出发前打开软件选择开始记录，你所经过的路线就会实时显示在地图上，同时还会显示当前的行驶速度。程序会按用户自己设置的标题自动存路线留做日后查看，也可以把路线分享给朋友。GPSTracker项目是一个Map方面的完整应用，包括两个主要组成部分，第一部分是一个收集和存储GPS追踪数据的系统服务，第二部分是Map Activity控制跟踪数据并在地图上显示提供接口。GPSTracker项目用到了osmdroid项目的部分功能，其中OpenStreetMap是一个可供自由编辑的世界地图，允许您查看，编辑或者使用世界各地的地理数据来帮助您。项目地址：open-gpstracker

Rokon

Rokon是一个强大、可扩展、灵活的Android 2D游戏引擎，基于OpenGL ES技术开发，物理引擎为Box2D，因此能够实现一些较为复杂的物理效果，有人将它称为Cocos2d-iPhone引擎的Android版（因为业务逻辑和编码风格上也确实很像）。项目地址：rokon

LGame

LGame是一款国人开发的Java游戏引擎，有Android及PC(J2SE)两个开发版本。其底层绘图器LGrpaphics封装有J2SE以及J2ME提供的全部Graphics API（PC版采用Graphics2D封装，Android版采用Canvas模拟实现），所以能够将J2SE或J2ME开发经验直接套用其中，两版本间主要代码能够相互移植。Android版内置有Admob接口，可以不必配置XML直接硬编码Admob广告信息。该引擎除了基本的音效、图形、物理、精灵等常用组件以外，也内置有Ioc、xml、http等常用Java组件的封装，代价是jar体积较为庞大，PC版已突破1.2MB，Android版有所简化也在500KB左右。此外，该引擎还内置有按照1:1实现的J2ME精灵类及相关组件，可以将绝大多数 J2ME游戏平移到Android或PC版中。项目地址：loon-simple

OpenIntents

通过"Intents"，Android给连接软件和动态替换组件提供了优秀的基础。Google定义了一批intents（如：打电话啊，联系人清单上选择一个联系人，打开浏览器，电池更换的时候提供提示，等等，详细清单请看：available intents和intent class) 但是任何程序可以自由定义额外的intents和content-providers。我们可以很容易的联想到独立开发的程序（比如在这次的比赛中）极少有可能会和新定义的intents和接口良好的一起工作。我们这个项目的目标是收集很可能在多个项目中都有用的想法（而且很可能已经被其他独立程序员实现了），定义一批比较合理且扩展性比较好的一批intents和接口，提供基础但稳定有效的实现，可以被其他Android程序所应用的，特别是其他参加比赛的程序员们。OpenIntents本身也会参加这次的比赛。我们提供小的样品程序来演示OpenIntents的用法和特性。因为我们专注于经常被使用到的那些intents，Google也很可能在不久的将来提供他们自己的标准intents（比如关于日历的。。。）当那个发生的时候，我们会提供透明的接口来直接呼叫Google的实现方法，而你已有的程序可以直接使用Google的新功能而不需要改变任何东西。而且，由于你的程序在设计初期就是已经支持intents的了，当Google的intents出来的时候，你可以很方便的直接他们的intents。还有可能的是Google可能会借用一些OpenIntents开发的intents。无论如何，如果你的程序使用OpenIntents，在和其他使用OpenIntents程序提供互相支持的同时，你会得到额外的附加值，从而全面增强用户体验。项目地址：openintents

android-bluetooth

Android Bluetooth API支持远程设备扫描、远程设备配对，服务发现（SDP）和客户端RFCOMM串行连接。项目地址：android-bluetooth

Android apktool

Android apktool是一个用来处理APK文件的工具，可以对APK进行反编译生成程序的源代码和图片、XML配置、语言资源等文件，也可以添加新的功能到APK文件中。用该工具来汉化Android软件然后重新打包发布是相当简单的。项目地址：android-apktool

quake2android

quake2android是一个将《雷神之锤2》（Quake2）游戏移植到Android平台上的开源项目。支持谷歌Nexus One，三星Galaxy S，摩托罗拉Droid X等手机。项目地址：quake2android

AndEngine

AndEngine是一个开源的，基于OpenGL实现的Android 2D游戏引擎。这里提供一些基于AndEngine实现的示例。项目地址：andengine

android-opencv

android-opencv是一个将OpenCV移到Android手机平台的开源项目，该项目使用OpenCV最新的一个分枝并利用一个改良过的Android NDK进行构建。项目地址：android-opencv

android-dalvik-vm-on-java

android-dalvik-vm-on-java该项目的目标是开发一个采用Java实现的Android Dalvik虚拟机。目的是为了学习Dalvik VM的思想和架构。当前支持Dalvik可执行文件格式（.dex），完整的Dalvik指令系统，J2ME CLDC API，多线程（包括同步阻塞，等待和通知）。项目地址：android-dalvik-vm-on-java

Android PC_BCR

Android PC_BCR让你能够使用你的Android手机做为PC机的外围条形码扫描仪。扫描的条形码将通过WiFi网络连接传PC机中。这个开源项目由多个组件组成，在手机设备上PC_BCR使用ZXing扫描仪器来扫描条形码，然后程序通过网络传到PC中，PC中有专门的PC_BCR程序接收。项目地址：android-pcbcr

创业编程七个错误认识

Mon, 04 Jul 2011 09:17:42 +0000

多少年来，人们普遍有一种看法，认为软件工程应该和其它种类的工程一样：仔细的设计，精确的规划，然后进行开发—严格按照设计说明书。就像修建一座桥梁，不是吗？这种开发方式的问题在于：软件，它是“软”的。它可以无限的延展。任何需要的时候你都可以大幅度的修改你的软件，人们也都是这么干的。还有，因为软件可以被拿来对任何事物进行模型造型，你能要求软件开发人员去实现的可能的东西几乎是无穷无尽。想要在软件里模拟集成电路吗？干吧。想管理银行？没问题。让五亿人和他们的朋友保持联系？为什么不呢？小菜一碟。不仅如此，在开发的中途我们还能要求程序员去做各种修改，这种事情经常的以一种不可预期的形式出现。

这可不是像修桥那样。

由于漠视这种需求不断变化的现实，多年来，无数的项目要么惨遭失败，要么巨额超出预算。所以，在总总的各种证据面前，整个行业为什么还要坚守这种错误的认识？很难说为什么。不过，最终，行业里开始出现一种新的认识：软件开发工作应该更好的响应需求的变化。事实上，为了适应这种需求上的变化，我们应该改进软件开发过程。没有比如今的web创业开发社区更欢迎这种趋势的了。所谓的敏捷开发方法已经开始流行，“lean start-up”运动号召对运行中的系统进行自动的或依据经验的超常快速变更响应。

所以，我们都是好样的，不是吗？虽然行动的不是那么快。尽管有越来越多的敏捷开发方法被人们接受，仍然有大量的传统错误认识游荡在我们周围…这些认识大部分都该丢到脑后。

1. 误解：你应该招聘一些“日本忍者”式的程序员

对编程超人的迷信是硅谷创业公司中最普遍的一种病症：一个孤僻的程序员，以匹萨和咖啡因为能量，头戴耳麦，通宵不倦的开发一个复杂的系统，所有的东西都自己一个人来干。时过境迁了。软件开发已经发展成一种团体运动。所有的创业公司只要获得了任何有意义的成功，都会成长起来。一个编程独侠客能够胜任的情况放到一个10人的公司里后就不可行了。而且，更糟糕的是，鼓励逞英雄的行为会在开发团队里产生腐蚀性的机能障碍。始终如一的朝九晚五、日复一日编写出公司赖以生存的稳固功能代码的程序员，输给了能以通宵加班(通常只是一晚)来期望获得慷慨的褒奖的精明极端利己主义者。与其奖励这种英雄，不如培养出真正具有团队精神的员工。

2. 误解: 程序员需要安静的工作，避免打搅

让人们独自的干活，这个听起来很有道理。每一次的打扰都是切实的中断你的思绪，而且你需要花很久才能重新找回那种“状态”。有些著名的软件公司甚至坚持要为每个程序员安排独立的办公室。他们这样就不会被打搅了，是吗？除非现代新形式的干扰并不会像一个真人拍你的肩头时引起你的分心，比如即时聊天工具，移动手机，Facebook，Twitter，电子邮件，以及从程序员头上戴的耳麦里传出的用于帮助集中精神的音乐。现实情况是，大多数的独自工作的程序员每天只花一小段时间用于真正的编程：各种形式的干扰事情层出不穷，整天他们都在进入状态和失去状态的循环中来来回回。然而，有个办法能解决这个问题：结对编程。两个程序员，一台电脑。没有Email，没有Twitter，没有手机电话(至少没有无计划的电话；你可以在有规律的间隔休息时间里处理这些事情)。如果按照这样做，你会收获一个完全编程的一天。而且，和他人一起工作，“进入状态”的过程几乎完全不费时间。这是一种完全不同的工作方式，我深信这种方式的效率远高于独自工作的形式。事实上，针对当前的办公室里的这些“电子设备引起的注意力分散”情况，我认为这是能让软件开发团队获得最高效率的唯一办法。

3. 误解: 创业公司竞争激烈，所以每个人都该干到精疲力竭为止

没白没夜的加班加点并不能让你做的更多，做的更快。事实上，这会让你适得其反。不错，你觉得一周就能完成。但大部分的创业公司的开发计划都会比这个长，程序员通常需要持续几个月的进行开发(如果不是几年的话)来成功的完成一个产品。很多创业公司的行为表现就好象是这罐金子就放在那个墙角，只要能再努力一点就能拿到它。很快，开发人员的精力就被榨干了，如僵尸一般只是做出在加班的样子，没有任何的工作效率。高强度的工作，只是从短期来看会获得更多的工作效率。著名的开发公司Pivotal帮助过成百上千的创业公司开发过系统，从来都是严格按照40小时工作日来完成任务的。

4. 误解: 工期紧必然需要走捷径

很多团队都以市场压力大、需要立即发布产品为由，写出劣质的代码。写出的测试程序绕开问题部位；疯狂的攻坚冲锋中认真设计原则被抛在脑后。但是，作为各个软件开发团队，大家都一样。高效能的团队在成功之余不失英雄本色：正相反，当压力出现时，他们岿然不动，以自身深厚的功底成功化解任务。我们无数次听到过高压下出高成就的传奇故事—要么是军事行动、专业运动，要么是飞行员在河上强行降落—其中的原因无非是英雄们的那句话，“我们受过专门训练”。

5. 误解：开发人员应该全权负责自己的代码

负责自己的代码，听起来很正确。理所当然的。个人职责嘛。可是，开发团队里在代码上分配归属人就意味着每个模块的程序只有一个开发人员来写，只有一个人能掌握。这会导致负责模块的程序员之间产生“地方保护主义”。对于公司老板来说，这造成了很大的风险，因为团队中损失一个人就会影响整个团队的进程，如果这个人是负责系统的关键核心模块的，那更会造成公司业务瘫痪。健康的工作方式是让每个程序员都经手过系统内的所有代码。结对编程能让你实现这个效果，知识会从一个人传递到另一个人。所谓的“巴士指数”(团队中的多少人被车撞才会导致大家都无法进行)是一个软件创业公司的关键风险指标。我们这里所说的不仅仅指的是巴士在使坏，还有你的竞争对手，他们乐衷于挖走你最好的程序员。理解整个系统的人越多，你的公司就越健壮，越有活力。

6. 误解：你需要一个怪异的招聘过程

你会在雇用一个演员时不进行试镜吗？如果要试，你就能短暂的做一回导演。这正是如今几乎所有的公司在招聘程序员时会出现的场景。通常的面试都会谈论应聘者的经验。这就完了。你可以想象一下，问一个踌躇满志的演员是否喜欢饰演哈姆雷特这个角色。你能传神的扮演他吗？好的。你被雇用了！很多著名的软件公司喜欢给应聘者出脑筋急转弯题。有些顶级的公司甚至给候选人进行IQ测试。他们中最可取的是在白板上模拟软件问题，让候选人解决。这些情况让人很无奈。我要说的是这非常明显的道理：招到好的程序员的唯一可靠的方法就是跟他们一起编程。我对程序员的面试是跟他们进行一个小时的快速的结对编程—而且这只是面试的一个开始。大量的筛选，把他们按满分100打分。什么样的会被选中？思维敏捷，抽象思考能力强，掌握各种算法，问题解决能力强。而最重要的是，领会能力。因为协作是对团队来说最重要的东西，如果你不能理解其他人是如何思考的，再聪明也没用。

7. 误解: 专业化很重要

非常自然的，管理者遇到问题时习惯把问题分解，各个击破。在开发团队里，这通常怂恿技术人员专项发展。前端开发，后台开发，数据库管理员等等。

Brad Feld

在他的博客里建议说，每个团队里都应该有个“全能程序员”，这个人是个真正的通才。他是对的，但他说的还不够。每个团队里的每个成员都应该是通才全才。为什么？因为专才导致团队脆弱。还记得“巴士指数”吗？每个专才都是一个弱点；如果他离开了，你找不到替代他的人，你完了。不仅如此，它还能使团队机能失调。专项的人需要把他们负责的系统里相互独立的模块通过定义好的接口相互通信。事实上，他们每人都写出了各自不统一通信方式。这导致了大量的额外开销，经常会出现“地方保护主义”或相互指责。而在著名的Pivotal公司，每个程序员都要接触到系统的各个层面，从HTML和JavaScript到Ruby，到数据库。而有些人认为专才会在系统的某个层面上更专业的，这种说法未必站得住脚。如今的软件技术变得已经不是那么复杂了。程序员能更容易的掌握各个层面上的知识以及如何操作它们。顺便说一下，这暗示出了另外一个非常重要的信息：你不再需要为某个特殊的技术而招聘人才了。缺少Ruby程序员？好，招一个Java程序员，培训他使用Ruby(这里使用结对编程格外的有效)。有些人称自己为“服务器端”程序员？没问题，让他们写JavaScript程序，他们很快就能学会。

如果他们是人才，那就体现在这里。

英文来源：What’s Your Start-up’s “Bus Count”? 7 Myths of Entrepreneurship and Programming 中文来源：http://www.aqee.net/2011/07/04/7-myths-of-entrepreneurship-and-programming/

人人网的 OAuth2.0 认证实现

Sat, 02 Jul 2011 18:58:59 +0000

现在貌似只有人人网最开始使用了OAuth2.0的认证，估计后续这些SNS站点都开始实现了，相比较OAuth1.0来看，2.0的认证过程确实方便了很多。

OAuth2.0 认证流程：

Java代码实现：

package com.carey.renren.example;  
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URLEncoder;
import java.util.Scanner;
import java.util.TreeMap;  
import com.carey.renren.RenRenHttpClient;
import com.carey.renren.RenRenOAuth;
import com.carey.renren.utils.RenRenHttpUtil;  

public class RenRenMain {      
 public static void main(String[] args) {        
    renrenRequest();    
 }      

 private static void renrenRequest() {        
  if (!java.awt.Desktop.isDesktopSupported()) {            
     System.err.println("Desktop is not supported (fatal)");            
     System.exit(1);        
  }          

  java.awt.Desktop desktop = java.awt.Desktop.getDesktop();          
  if (desktop == null || !desktop.isSupported(java.awt.Desktop.Action.BROWSE)) {            
      System.err.println("Desktop doesn't support the browse action");            
      System.exit(1);        
  }                  

  getAuthorizationCode(desktop);        
  //  界面返回：        
  //  http://graph.renren.com/oauth/login_success.html?code=ki2wk30AHg18KLWvriLA1rlf9tAUd1Um                 

  getAccessToken(desktop);        
  // 界面返回：        
  //  {         //  "access_token": "143511|5.57d2ad88cdd22398c03a2fcbb3bbd229.86400.1306422000-1167553647",        
  // "expires_in": 88680,        
  // "scope": "email status_update publish_feed"        
  // }                  

  getSessionToken(desktop);        
  // 界面返回：        
  //{"renren_token":{"session_secret":"ca076de790d8fc2470cb7b9da2c936f9","expires_in":88667,        
  // "session_key":"5.57d2ad88cdd22398c03a2fcbb3bbd229.86400.1306422000-1167553647"},        
  // "oauth_token":"143511|5.57d2ad88cdd22398c03a2fcbb3bbd229.86400.1306422000-1167553647","user":{"id":1167553647}}

  testAPI();        
  //  获取用户基本信息，输出结果为：        
  // [{"uid":1167553647,"tinyurl":"http://hd34.xiaonei.com/photos/hd34/20080322/13/30/tiny_22p107.jpg","vip":1,"sex":1,  
  //  "name":"周润生","star":1,"headurl":"http://hd34.xiaonei.com/photos/hd34/20080322/13/30/head_22p107.jpg","zidou":0}]
 }          

 private static void getAuthorizationCode(java.awt.Desktop desktop) {        
  System.out.println("get Authorization Code......");                  
  try {            
   String urlStr = RenRenOAuth.AuthorizationURL + "?" + "client_id="  + RenRenOAuth.APIKey + "&" + "response_type=code"
    + "&redirect_uri=" + RenRenOAuth.RedirectURL;            
   System.out.println("authorization url: n" + urlStr);              
   desktop.browse(new URI(urlStr));        
  } catch (Exception e) {            
   e.printStackTrace();        
  }    
 }  

 private static void getAccessToken(java.awt.Desktop desktop) {        
  System.out.println("get Access Token......");          
        System.out.println("Input your Authorization code：");       
  Scanner in = new Scanner(System.in);        
  String input = in.nextLine();          

  try {           
   String urlStr = RenRenOAuth.OAuthURL + "?" + "client_id=" + RenRenOAuth.APIKey + "&client_secret=" + RenRenOAuth.SecretKey + "&redirect_uri="    
    + RenRenOAuth.RedirectURL  + "&grant_type=authorization_code" + "&code=" + input;            
   System.out.println("access url: n" + urlStr);              
   desktop.browse(new URI(urlStr));        
  } catch (Exception e) {
   e.printStackTrace();
  }   
 }     

 private static void getSessionToken(java.awt.Desktop desktop) {
  System.out.println("get Session Token......");
  System.out.println("Input your Access token："); 
  Scanner in = new Scanner(System.in);       
  String input = in.nextLine();                 

  try {            
   input = URLEncoder.encode(input, "UTF-8");       
  } catch (UnsupportedEncodingException e1) {            
   e1.printStackTrace();        
  }          

  try {            
   String urlStr = RenRenOAuth.SessionURL + "?" + "oauth_token=" + input;            
   System.out.println("session url: n" + urlStr);              
   desktop.browse(new URI(urlStr));        
  } catch (Exception e) {            
   e.printStackTrace();        
  }    
 }          

 private static void testAPI() {        
  System.out.println("Input your Session Token：");        
  //Scanner in = new Scanner(System.in);        
  //String input = in.nextLine();                  
  String input = "5.57d2ad88cdd22398c03a2fcbb3bbd229.86400.1306422000-1167553647";                  
  TreeMap params = new TreeMap();        
  params.put("session_key", input);        

  //params.put("method", "friends.get");                  
  params.put("method", "users.getInfo");        
  params.put("uids", "1167553647");                  
  String content = sendPostRestRequest(params, "JSON", RenRenOAuth.ApiUrl);        
  if (content.indexOf("error_code") >= 0) {            
   //error        
  }        

  System.out.println(content);    
 }          

 public static String sendPostRestRequest(TreeMap params, String format, String url) {       
  RenRenHttpUtil.prepareParams(params, format);        
  String content = RenRenHttpClient.doPost(url, params);        
  return content;    
 }
}

上面代码的实现过程和OAuth2.0的认证流程相互一致，其他主要功能函数实现如下：

同步wordpress文章到百度空间

Sat, 02 Jul 2011 17:49:27 +0000

本文实现了wordpress的插件开发，自动同步 wordpress 的文章到百度空间。

== Description ==同步发布 WordPress 博文到百度空间.

支持设置发布到百度空间中文章的评论权限。
支持设置发布到百度空间中文章的访问权限。
支持设置发布到百度空间中文章的转载权限。
支持将Wordpress中文章链接发布到百度空间。
支持发布到百度空间中文章的自动归类

== Installation ==

上传整个文件夹 wp2baiduzone 到 /wp-content/plugins/ 目录
后台控制面板"插件(Plugins)“中激活 wp2baiduzone 插件
后台控制面板"配置(Settings)->wp2baiduzone"中配置插件信息（百度空间的账户信息和博文同步的权限信息）

软件配置界面：

下载地址：http://wordpress.org/extend/plugins/wp2baiduzone/

变更历史

时间：2012-06-26

鉴于最近百度空间进行了升级，所以原有的插件在新环境下可能无法正常工作，为了不影响新旧空间所有用户的使用，插件暂时没有做更新，对新版的百度空间做了一款补充插件，和原有插件的文件名都相同，下载下来替换掉现有的插件即可，部分功能有变更，待后续完善，下载地址 wp2baiduzone(20120626).zip.

时间：2013-09-19 新版的百度空间已经稳定了，插件目前更新到1.3稳定版本，可以进行同步。

通过GAE平台自动发布文章到百度空间

Sat, 02 Jul 2011 17:37:47 +0000

昨天写了一篇通过Java程序自动发送文章到百度空间，具体实现原理和代码请参照<<Java程序自动发布文章到百度空间>>今天把那版代码进行了更新，现在可以放置到GAE平台了，这样基于GAE平台环境搭建的个人博客就可以很方便的将个人的博文同步到百度空间。

具体的实现原理现在不多说了，现在展示一下核心代码：1.

Config.Java 配置个人百度空间的账户名和密码

package com.carey.baidublog;  

public class Config {    
 public static final String USERNAME = "username";    
 public static final String PASSWORD = "password";
}

GAEPublishBaiduActicleServlet.java 用来处理GAE的servlet请求

package com.carey.gae.baidu;  
import java.io.IOException;
import javax.servlet.http.*;  
import com.carey.baidublog.BDHttpClient;  

public class GAEPublishBaiduActicleServlet extends HttpServlet {    
 private static final long serialVersionUID = 1L;      

 public void doGet(HttpServletRequest req, HttpServletResponse resp)  throws IOException {        
  try {         
   BDHttpClient.publishBlog("gae-title", "gae-content", "gae-category");        
  } catch (Exception e) {            
   e.printStackTrace();        
  }          

  resp.setContentType("text/plain");        
  resp.getWriter().println("成功发布一篇博文到百度空间");    
 }
}

BDHttpClient.java 完成百度博文的发布

Java程序自动发布文章到百度空间

Sat, 02 Jul 2011 17:20:20 +0000

这几天建立了个博客，想把这个博客的内容同时导入到其他博客中去，同时，当在本博客发表一篇博文的时候，也同步传输到其他博客中去，这样就方便多了，以后只要维护一个就ok了。

CSDN的博客开放的比较好，符合 http://www.xmlrpc.com/metaWeblogApi 标准，可以有开放的API来调用，容易解决。

目前遇到的问题就是导入博文到百度空间，貌似百度现在还没有做出什么开放的API来，没办法来直接调用，不过也有方法来解决，那就是通过程序来模拟浏览器的登录过程和发表文章的过程，通过测试，搞定。。O(∩_∩)O哈哈~下面介绍一下程序的思路和展示一下源码：1.

基本思路就是通过程序来模拟浏览器的登录过程，本文的代码基于Java语言实现，主要利用的就是Apache的HttpClient包。

大家首先可以利用浏览器的插件来捕获我们正常到百度登录过程，和发表博文过程的所有Http请求的数据，着重分析一下表单数据的提交，就可以知道百度空间发文在后台做了那些操作和需要哪些重要的数据来验证用户的正常登录。

用程序来模拟浏览器登录的最重要的处理，就是Cookie的保存和后续数据的传输，因为像百度这类需要用户输入账户和密码来登录的系统，并且具有密码记忆功能的网站，用户的验证信息都存储在Cookie中。

因为为了让百度服务器识别用户的登录，那就要在程序中记录第一次登录过程的Cookie数据，然后在以后的http请求中将cookie数据回传给服务器，那样服务器就认为你一直登录了，不然文章是不能正确发布出去的，因为你没有cookie的话，服务器还认为你没有登录过，会拒绝操作。

用户的身份验证解决了以后，百度发表文章的时候，还要多加一步验证，就是通过访问新建博文的页面，获取一个临时的百度 token，它会与你接下来发表的博文一一对应，我猜测可能是服务器支持单用户多点登录，同时发表多篇博文吧，不过这都没关系了，反正我们照做就行啦。

文章分类的处理，我发现百度这边做的不够智能，如果你发表博文的时候，指定了一个不存在的类别，直接决绝发布，所以，还是想个笨点的办法，每次发布博文前，先建立一个类别，如果已经有了这个类型，重新建立一次也没关系，反正也不会覆盖掉，因为百度会拒绝建立新的类别，错误类型是类别已存在，这个善意的错误忽略就ok。。。哈哈 7.

所有这些前期工作做好了，就能正常发布文章了，下面贴出一下源码文件，大家按照自己的方式去修改吧：

Config.java

主要配置一下个人百度账号的用户名和密码

package com.carey.baidublog;   
 public class Config {    
 public static final String USERNAME = "username";    
 public static final String PASSWORD = "password";
}

PublishBlog.java

测试程序，调用函数发布文章到百度空间

package com.carey.baidublog;  
public class PublistBlog {    
 public static void main(String[] args) {        
  try {            
   BDHttpClient.publishBlog("Article-Title", "Article-Content",  "Article-category");            
   System.out.println("成功发布一篇文章到百度空间");        
  } catch (Exception e) {            
      e.printStackTrace();        
  }    
 }
}

BDHttpClient.java

发布百度博文的实现类，主要是http请求和cookie的处理，以及获取百度令牌token

AIR for Android 之源码和实现原理分析

Sat, 02 Jul 2011 15:55:24 +0000

airbootstap.jar 的实现机制简单来说其实就是：

通过继承Android的Activity来实现一个新的Activity（AppEntry），它通过“com.adobe.air.AndroidActivityWrapper” 封装实现了Android中Activity本身的方法，例如onResume，onPause等等，废话不说，直接上源码，相信大家浏览过一遍就基本清楚了。

package air.app;

import java.lang.reflect.Method;
import java.net.URISyntaxException;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.ActivityNotFoundException;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.os.Bundle;
import android.os.IBinder;
import android.os.Process;
import android.util.AttributeSet;
import android.view.ContextMenu;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.WindowManager;
import dalvik.system.DexClassLoader;

public class AppEntry extends Activity {
 private static final String LOG_TAG = "AppEntry";
 private static String RUNTIME_PACKAGE_ID = "com.adobe.air";
 private static Object sAndroidActivityWrapper = null;
 private static Class<?> sAndroidActivityWrapperClass;
 private static boolean sDexLoaded = false;
 private static DexClassLoader sDloader;

 /**
  * Activity 的 启动函数，用来初始化Adobe AIR的环境
  * */
 public void onCreate(Bundle paramBundle) {
  super.onCreate(paramBundle);
  if (!isRuntimeInstalled()) {
   showDialog();
  } else {
   loadDexAndCreateActivityWrapper();
   if (!sDexLoaded) {
    launchAIRService();
   } else {
    InvokeWrapperOnCreate();
   }
  }
 }

 /**
  * 执行指定的方法：paramMethod为方法名，paramArrayOfObject为方法的参数
  *
  * */
 private Object InvokeMethod(Method paramMethod, Object[] paramArrayOfObject) {
  Object localObject1 = null;
  if (!sDexLoaded) {
   return localObject1;
  }

  try {
   if (paramArrayOfObject != null) {
    localObject1 = paramMethod.invoke(sAndroidActivityWrapper,
      paramArrayOfObject);
   } else {
    Object[] arrayOfObject = new Object[0];
    localObject1 = paramMethod.invoke(sAndroidActivityWrapper,
      arrayOfObject);
   }
  } catch (Exception localException) {
  }
  return localObject1;
 }

 /**
  * 主要用来初始化Activity的包装类 sAndroidActivityWrapperClass， 后续的方法调用都是通过它来的
  * */
 private void InvokeWrapperOnCreate() {
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = Activity.class;
   arrayOfClass[1] = String[].class;
   Method localMethod = localClass.getMethod("onCreate", arrayOfClass);
   Boolean localBoolean1 = new Boolean(false);
   Boolean localBoolean2 = new Boolean(true);
   String[] arrayOfString = new String[5];
   arrayOfString[0] = "";
   arrayOfString[1] = "";
   arrayOfString[2] = "-nodebug";
   arrayOfString[3] = localBoolean1.toString();
   arrayOfString[4] = localBoolean2.toString();

   Object[] arrayOfObject = new Object[2];
   arrayOfObject[0] = this;
   arrayOfObject[1] = arrayOfString;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 private static void KillSelf() {
  Process.killProcess(Process.myPid());
 }

 /**
  * 用来启动Adobe AIR service服务
  * */
 private void launchAIRService() {
  try {
   Intent localIntent1 = new Intent("com.adobe.air.AIRServiceAction");
   localIntent1.setClassName(RUNTIME_PACKAGE_ID,
     "com.adobe.air.AIRService");

   bindService(localIntent1, new ServiceConnection() {

    @Override
    public void onServiceConnected(ComponentName arg0, IBinder arg1) {
     unbindService(this);
     loadDexAndCreateActivityWrapper();
     if (AppEntry.sDexLoaded) {
      InvokeWrapperOnCreate();
     } else {
      AppEntry.KillSelf();
     }
    }

    @Override
    public void onServiceDisconnected(ComponentName arg0) {
    }

   }, 1);
  } catch (Exception localException) {
  }
 }

 /**
  * 启动Android Market 来下载 Adobe AIR for Android 的apk程序
  * */
 private void launchMarketPlaceForAIR() {
  String str2 = null;
  try {
   PackageManager localPackageManager = getPackageManager();
   ComponentName localComponentName = getComponentName();
   Bundle localBundle = localPackageManager.getActivityInfo(
     localComponentName, 128).metaData;
   if (localBundle != null) {
    str2 = (String) localBundle.get("airDownloadURL");
   }
  } catch (android.content.pm.PackageManager.NameNotFoundException namenotfoundexception) {
  }

  if (str2 == null) {
   StringBuilder localStringBuilder = new StringBuilder()
     .append("market://details?id=");
   str2 = localStringBuilder.append(RUNTIME_PACKAGE_ID).toString();
  }
  BroadcastIntent("android.intent.action.VIEW", str2);
 }

 /**
  * 创建 DexClassLoader， sAndroidActivityWrapperClass 和 初始化
  * sAndroidActivityWrapper（通过调用方法CreateAndroidActivityWrapper）
  * */
 private void loadDexAndCreateActivityWrapper() {
  try {
   if (!sDexLoaded) {
    Context localContext = createPackageContext(RUNTIME_PACKAGE_ID,
      3);
    String str2 = RUNTIME_PACKAGE_ID;
    String str3 = getFilesDir().getAbsolutePath();
    ClassLoader localClassLoader = localContext.getClassLoader();
    sDloader = new DexClassLoader(str2, str3, null,
      localClassLoader);
    sAndroidActivityWrapperClass = sDloader
      .loadClass("com.adobe.air.AndroidActivityWrapper");
    if (sAndroidActivityWrapperClass != null) {
     sDexLoaded = true;
    }
   }

   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = Activity.class;
   Method localMethod = localClass.getMethod(
     "CreateAndroidActivityWrapper", arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   arrayOfObject[0] = this;
   sAndroidActivityWrapper = localMethod.invoke(null, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 /**
  * 用来启动 Activity
  * */
 public void BroadcastIntent(String paramString1, String paramString2) {
  try {
   Intent localIntent = Intent.parseUri(paramString2, 0)
     .setAction(paramString1).addFlags(268435456);
   startActivity(localIntent);
  } catch (ActivityNotFoundException localActivityNotFoundException) {
  } catch (URISyntaxException localURISyntaxException) {
  }
 }

 public void finishActivityFromChild(Activity paramActivity, int paramInt) {
  super.finishActivityFromChild(paramActivity, paramInt);
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = Activity.class;
   arrayOfClass[1] = Integer.TYPE;
   Method localMethod = localClass1.getMethod(
     "finishActivityFromChild", arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   arrayOfObject[0] = paramActivity;
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[1] = localInteger;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void finishFromChild(Activity paramActivity) {
  super.finishFromChild(paramActivity);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = Activity.class;
   Method localMethod = localClass.getMethod("finishFromChild",
     arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   arrayOfObject[0] = paramActivity;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 /**
  * 通过 getPackageInfo 的方法来测试 Adobe AIR 环境是否ready，如果抛出异常， 说明Adobe
  * AIR的相关软件还没有安装
  * */
 public boolean isRuntimeInstalled() {
  PackageManager localPackageManager = getPackageManager();
  int i;
  try {
   PackageInfo localPackageInfo = localPackageManager.getPackageInfo(
     RUNTIME_PACKAGE_ID, 256);
   i = 1;
  } catch (PackageManager.NameNotFoundException localNameNotFoundException) {
   i = 0;
  }

  return i == 1;
 }

 protected void onActivityResult(int paramInt1, int paramInt2,
   Intent paramIntent) {
  try {
   if (sDexLoaded) {
    Class localClass1 = sAndroidActivityWrapperClass;
    Class[] arrayOfClass = new Class[3];
    arrayOfClass[0] = Integer.TYPE;
    arrayOfClass[1] = Integer.TYPE;
    arrayOfClass[2] = Intent.class;
    Method localMethod = localClass1.getMethod("onActivityResult",
      arrayOfClass);
    Object[] arrayOfObject = new Object[3];
    Integer localInteger1 = Integer.valueOf(paramInt1);
    arrayOfObject[0] = localInteger1;
    Integer localInteger2 = Integer.valueOf(paramInt2);
    arrayOfObject[1] = localInteger2;
    arrayOfObject[2] = paramIntent;
    InvokeMethod(localMethod, arrayOfObject);
   }
  } catch (Exception localException) {
  }
 }

 protected void onApplyThemeResource(Resources.Theme paramTheme,
   int paramInt, boolean paramBoolean) {
  super.onApplyThemeResource(paramTheme, paramInt, paramBoolean);
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[3];
   arrayOfClass[0] = Resources.Theme.class;
   arrayOfClass[1] = Integer.TYPE;
   arrayOfClass[2] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onApplyThemeResource",
     arrayOfClass);
   Object[] arrayOfObject = new Object[3];
   arrayOfObject[0] = paramTheme;
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[1] = localInteger;
   Boolean localBoolean = Boolean.valueOf(paramBoolean);
   arrayOfObject[2] = localBoolean;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void onAttachedToWindow() {
  super.onAttachedToWindow();
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[0];
   Method localMethod = localClass.getMethod("onAttachedToWindow",
     arrayOfClass);
   Object[] arrayOfObject = new Object[0];
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void onBackPressed() {
  super.onBackPressed();
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[0];
   Method localMethod = localClass.getMethod("onBackPressed",
     arrayOfClass);
   Object[] arrayOfObject = new Object[0];
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 protected void onChildTitleChanged(Activity paramActivity,
   CharSequence paramCharSequence) {
  super.onChildTitleChanged(paramActivity, paramCharSequence);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = Activity.class;
   arrayOfClass[1] = CharSequence.class;
   Method localMethod = localClass.getMethod("onChildTitleChanged",
     arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   arrayOfObject[0] = paramActivity;
   arrayOfObject[1] = paramCharSequence;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void onConfigurationChanged(Configuration paramConfiguration) {
  super.onConfigurationChanged(paramConfiguration);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = Configuration.class;
   Method localMethod = localClass.getMethod("onConfigurationChanged",
     arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   arrayOfObject[0] = paramConfiguration;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void onContentChanged() {
  super.onContentChanged();
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[0];
   Method localMethod = localClass.getMethod("onContentChanged",
     arrayOfClass);
   Object[] arrayOfObject = new Object[0];
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public boolean onContextItemSelected(MenuItem paramMenuItem) {
  boolean bool1 = super.onContextItemSelected(paramMenuItem);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = MenuItem.class;
   arrayOfClass[1] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onContextItemSelected",
     arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   arrayOfObject[0] = paramMenuItem;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[1] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public void onContextMenuClosed(Menu paramMenu) {
  super.onContextMenuClosed(paramMenu);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = Menu.class;
   Method localMethod = localClass.getMethod("onContextMenuClosed",
     arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   arrayOfObject[0] = paramMenu;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void onCreateContextMenu(ContextMenu paramContextMenu,
   View paramView, ContextMenu.ContextMenuInfo paramContextMenuInfo) {
  super.onCreateContextMenu(paramContextMenu, paramView,
    paramContextMenuInfo);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[3];
   arrayOfClass[0] = ContextMenu.class;
   arrayOfClass[1] = View.class;
   arrayOfClass[2] = ContextMenu.ContextMenuInfo.class;
   Method localMethod = localClass.getMethod("onCreateContextMenu",
     arrayOfClass);
   Object[] arrayOfObject = new Object[3];
   arrayOfObject[0] = paramContextMenu;
   arrayOfObject[1] = paramView;
   arrayOfObject[2] = paramContextMenuInfo;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public CharSequence onCreateDescription() {
  CharSequence localCharSequence = super.onCreateDescription();
  Object localObject;
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = CharSequence.class;
   Method localMethod = localClass.getMethod("onCreateDescription",
     arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   arrayOfObject[0] = localCharSequence;
   localObject = (CharSequence) InvokeMethod(localMethod,
     arrayOfObject);
  } catch (Exception localException) {
   localObject = localCharSequence;
  }
  return (CharSequence) localObject;
 }

 protected Dialog onCreateDialog(int paramInt) {
  Dialog localDialog = super.onCreateDialog(paramInt);
  Object localObject;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = Dialog.class;
   Method localMethod = localClass1.getMethod("onCreateDialog",
     arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = localDialog;
   localObject = (Dialog) InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
   localObject = localDialog;
  }
  return (Dialog) localObject;
 }

 protected Dialog onCreateDialog(int paramInt, Bundle paramBundle) {
  Dialog localDialog = super.onCreateDialog(paramInt, paramBundle);
  Object localObject;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[3];
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = Bundle.class;
   arrayOfClass[2] = Dialog.class;
   Method localMethod = localClass1.getMethod("onCreateDialog",
     arrayOfClass);
   Object[] arrayOfObject = new Object[3];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = paramBundle;
   arrayOfObject[2] = localDialog;
   localObject = (Dialog) InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
   localObject = localDialog;
  }

  return (Dialog) localObject;
 }

 public boolean onCreateOptionsMenu(Menu paramMenu) {
  boolean bool1 = super.onCreateOptionsMenu(paramMenu);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = Menu.class;
   arrayOfClass[1] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onCreateOptionsMenu",
     arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   arrayOfObject[0] = paramMenu;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[1] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public boolean onCreatePanelMenu(int paramInt, Menu paramMenu) {
  boolean bool1 = super.onCreatePanelMenu(paramInt, paramMenu);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[3];
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = Menu.class;
   arrayOfClass[2] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onCreatePanelMenu",
     arrayOfClass);
   Object[] arrayOfObject = new Object[3];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = paramMenu;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[2] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public View onCreatePanelView(int paramInt) {
  View localView = super.onCreatePanelView(paramInt);
  Object localObject;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = View.class;
   Method localMethod = localClass1.getMethod("onCreatePanelView",
     arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = localView;
   localObject = (View) InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
   localObject = localView;
  }
  return (View) localObject;
 }

 public boolean onCreateThumbnail(Bitmap paramBitmap, Canvas paramCanvas) {
  boolean bool1 = super.onCreateThumbnail(paramBitmap, paramCanvas);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[3];
   arrayOfClass[0] = Bitmap.class;
   arrayOfClass[1] = Canvas.class;
   arrayOfClass[2] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onCreateThumbnail",
     arrayOfClass);
   Object[] arrayOfObject = new Object[3];
   arrayOfObject[0] = paramBitmap;
   arrayOfObject[1] = paramCanvas;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[2] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public View onCreateView(String paramString, Context paramContext,
   AttributeSet paramAttributeSet) {
  View localView = super.onCreateView(paramString, paramContext,
    paramAttributeSet);
  Object localObject;
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[4];
   arrayOfClass[0] = String.class;
   arrayOfClass[1] = Context.class;
   arrayOfClass[2] = AttributeSet.class;
   arrayOfClass[3] = View.class;
   Method localMethod = localClass.getMethod("onCreateView",
     arrayOfClass);
   Object[] arrayOfObject = new Object[4];
   arrayOfObject[0] = paramString;
   arrayOfObject[1] = paramContext;
   arrayOfObject[2] = paramAttributeSet;
   arrayOfObject[3] = localView;
   localObject = (View) InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
   localObject = localView;
  }
  return (View) localObject;
 }

 public void onDestroy() {
  super.onDestroy();
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[0];
   Method localMethod = localClass
     .getMethod("onDestroy", arrayOfClass);
   Object[] arrayOfObject = new Object[0];
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void onDetachedFromWindow() {
  super.onDetachedFromWindow();
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[0];
   Method localMethod = localClass.getMethod("onDetachedFromWindow",
     arrayOfClass);
   Object[] arrayOfObject = new Object[0];
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public boolean onKeyDown(int paramInt, KeyEvent paramKeyEvent) {
  boolean bool1 = super.onKeyDown(paramInt, paramKeyEvent);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[3];
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = KeyEvent.class;
   arrayOfClass[2] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onKeyDown",
     arrayOfClass);
   Object[] arrayOfObject = new Object[3];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = paramKeyEvent;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[2] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public boolean onKeyLongPress(int paramInt, KeyEvent paramKeyEvent) {
  boolean bool1 = super.onKeyLongPress(paramInt, paramKeyEvent);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[3];
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = KeyEvent.class;
   arrayOfClass[2] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onKeyLongPress",
     arrayOfClass);
   Object[] arrayOfObject = new Object[3];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = paramKeyEvent;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[2] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public boolean onKeyMultiple(int paramInt1, int paramInt2,
   KeyEvent paramKeyEvent) {
  boolean bool1 = super
    .onKeyMultiple(paramInt1, paramInt2, paramKeyEvent);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[4];
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = Integer.TYPE;
   arrayOfClass[2] = KeyEvent.class;
   arrayOfClass[3] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onKeyMultiple",
     arrayOfClass);
   Object[] arrayOfObject = new Object[4];
   Integer localInteger1 = Integer.valueOf(paramInt1);
   arrayOfObject[0] = localInteger1;
   Integer localInteger2 = Integer.valueOf(paramInt2);
   arrayOfObject[1] = localInteger2;
   arrayOfObject[2] = paramKeyEvent;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[3] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public boolean onKeyUp(int paramInt, KeyEvent paramKeyEvent) {
  boolean bool1 = super.onKeyUp(paramInt, paramKeyEvent);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[3];
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = KeyEvent.class;
   arrayOfClass[2] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onKeyUp", arrayOfClass);
   Object[] arrayOfObject = new Object[3];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = paramKeyEvent;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[2] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public void onLowMemory() {
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[0];
   Method localMethod = localClass.getMethod("onLowMemory",
     arrayOfClass);
   Object[] arrayOfObject = new Object[0];
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public boolean onMenuItemSelected(int paramInt, MenuItem paramMenuItem) {
  boolean bool1 = super.onMenuItemSelected(paramInt, paramMenuItem);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[3];
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = MenuItem.class;
   arrayOfClass[2] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onMenuItemSelected",
     arrayOfClass);
   Object[] arrayOfObject = new Object[3];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = paramMenuItem;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[2] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public boolean onMenuOpened(int paramInt, Menu paramMenu) {
  boolean bool1 = super.onMenuOpened(paramInt, paramMenu);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[3];
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = Menu.class;
   arrayOfClass[2] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onMenuOpened",
     arrayOfClass);
   Object[] arrayOfObject = new Object[3];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = paramMenu;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[2] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 protected void onNewIntent(Intent paramIntent) {
  Intent localIntent = paramIntent;
  super.onNewIntent(localIntent);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = Intent.class;
   Method localMethod = localClass.getMethod("onNewIntent",
     arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   arrayOfObject[0] = localIntent;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public boolean onOptionsItemSelected(MenuItem paramMenuItem) {
  boolean bool1 = super.onOptionsItemSelected(paramMenuItem);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = MenuItem.class;
   arrayOfClass[1] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onOptionsItemSelected",
     arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   arrayOfObject[0] = paramMenuItem;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[1] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public void onOptionsMenuClosed(Menu paramMenu) {
  super.onOptionsMenuClosed(paramMenu);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = Menu.class;
   Method localMethod = localClass.getMethod("onOptionsMenuClosed",
     arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   arrayOfObject[0] = paramMenu;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void onPanelClosed(int paramInt, Menu paramMenu) {
  super.onPanelClosed(paramInt, paramMenu);
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = Menu.class;
   Method localMethod = localClass1.getMethod("onPanelClosed",
     arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = paramMenu;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void onPause() {
  super.onPause();
  try {
   if (sDexLoaded) {
    Class localClass = sAndroidActivityWrapperClass;
    Class[] arrayOfClass = new Class[0];
    Method localMethod = localClass.getMethod("onPause",
      arrayOfClass);
    Object[] arrayOfObject = new Object[0];
    InvokeMethod(localMethod, arrayOfObject);
   }
  } catch (Exception localException) {
  }
 }

 protected void onPostCreate(Bundle paramBundle) {
  super.onPostCreate(paramBundle);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = Bundle.class;
   Method localMethod = localClass.getMethod("onPostCreate",
     arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   arrayOfObject[0] = paramBundle;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 protected void onPostResume() {
  super.onPostResume();
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[0];
   Method localMethod = localClass.getMethod("onPostResume",
     arrayOfClass);
   Object[] arrayOfObject = new Object[0];
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 protected void onPrepareDialog(int paramInt, Dialog paramDialog) {
  super.onPrepareDialog(paramInt, paramDialog);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   // arrayOfClass[0] = R.id.class;
   // 因为此处的第一个参数为int类型，所以做个替换就OK
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = Dialog.class;
   Method localMethod = localClass.getMethod("onPrepareDialog",
     arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = paramDialog;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 protected void onPrepareDialog(int paramInt, Dialog paramDialog,
   Bundle paramBundle) {
  super.onPrepareDialog(paramInt, paramDialog, paramBundle);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[3];
   // arrayOfClass[0] = R.id.class;
   // 因为此处的第一个参数为int类型，所以做个替换就OK
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = Dialog.class;
   arrayOfClass[2] = Bundle.class;
   Method localMethod = localClass.getMethod("onPrepareDialog",
     arrayOfClass);
   Object[] arrayOfObject = new Object[3];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = paramDialog;
   arrayOfObject[2] = paramBundle;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public boolean onPrepareOptionsMenu(Menu paramMenu) {
  boolean bool1 = super.onPrepareOptionsMenu(paramMenu);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = Menu.class;
   arrayOfClass[1] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onPrepareOptionsMenu",
     arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   arrayOfObject[0] = paramMenu;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[1] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public boolean onPreparePanel(int paramInt, View paramView, Menu paramMenu) {
  boolean bool1 = super.onPreparePanel(paramInt, paramView, paramMenu);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[4];
   arrayOfClass[0] = Integer.TYPE;
   arrayOfClass[1] = View.class;
   arrayOfClass[2] = Menu.class;
   arrayOfClass[3] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onPreparePanel",
     arrayOfClass);
   Object[] arrayOfObject = new Object[4];
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[0] = localInteger;
   arrayOfObject[1] = paramView;
   arrayOfObject[2] = paramMenu;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[3] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public void onRestart() {
  super.onRestart();
  try {
   if (sDexLoaded) {
    Class localClass = sAndroidActivityWrapperClass;
    Class[] arrayOfClass = new Class[0];
    Method localMethod = localClass.getMethod("onRestart",
      arrayOfClass);
    Object[] arrayOfObject = new Object[0];
    InvokeMethod(localMethod, arrayOfObject);
   }
  } catch (Exception localException) {
  }
 }

 protected void onRestoreInstanceState(Bundle paramBundle) {
  super.onRestoreInstanceState(paramBundle);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = Bundle.class;
   Method localMethod = localClass.getMethod("onRestoreInstanceState",
     arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   arrayOfObject[0] = paramBundle;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void onResume() {
  super.onResume();
  try {
   if (sDexLoaded) {
    Class localClass = sAndroidActivityWrapperClass;
    Class[] arrayOfClass = new Class[0];
    Method localMethod = localClass.getMethod("onResume",
      arrayOfClass);
    Object[] arrayOfObject = new Object[0];
    InvokeMethod(localMethod, arrayOfObject);
   }
  } catch (Exception localException) {
  }
 }

 public Object onRetainNonConfigurationInstance() {
  Object localObject1 = super.onRetainNonConfigurationInstance();
  Object localObject3;
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = Object.class;
   Method localMethod = localClass.getMethod(
     "onRetainNonConfigurationInstance", arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   arrayOfObject[0] = localObject1;
   localObject3 = InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
   localObject3 = localObject1;
  }
  return localObject3;
 }

 protected void onSaveInstanceState(Bundle paramBundle) {
  super.onSaveInstanceState(paramBundle);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = Bundle.class;
   Method localMethod = localClass.getMethod("onSaveInstanceState",
     arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   arrayOfObject[0] = paramBundle;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public boolean onSearchRequested() {
  boolean bool1 = super.onSearchRequested();
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onSearchRequested",
     arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[0] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public void onStart() {
  super.onStart();
 }

 public void onStop() {
  super.onStop();
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[0];
   Method localMethod = localClass.getMethod("onStop", arrayOfClass);
   Object[] arrayOfObject = new Object[0];
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 protected void onTitleChanged(CharSequence paramCharSequence, int paramInt) {
  super.onTitleChanged(paramCharSequence, paramInt);
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = CharSequence.class;
   Class localClass2 = Integer.TYPE;
   arrayOfClass[1] = localClass2;
   Method localMethod = localClass1.getMethod("onTitleChanged",
     arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   arrayOfObject[0] = paramCharSequence;
   Integer localInteger = Integer.valueOf(paramInt);
   arrayOfObject[1] = localInteger;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public boolean onTouchEvent(MotionEvent paramMotionEvent) {
  boolean bool1 = super.onTouchEvent(paramMotionEvent);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = MotionEvent.class;
   arrayOfClass[1] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onTouchEvent",
     arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   arrayOfObject[0] = paramMotionEvent;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[1] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public boolean onTrackballEvent(MotionEvent paramMotionEvent) {
  boolean bool1 = super.onTrackballEvent(paramMotionEvent);
  boolean bool3;
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[2];
   arrayOfClass[0] = MotionEvent.class;
   arrayOfClass[1] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onTrackballEvent",
     arrayOfClass);
   Object[] arrayOfObject = new Object[2];
   arrayOfObject[0] = paramMotionEvent;
   Boolean localBoolean = Boolean.valueOf(bool1);
   arrayOfObject[1] = localBoolean;
   bool3 = ((Boolean) InvokeMethod(localMethod, arrayOfObject))
     .booleanValue();
  } catch (Exception localException) {
   bool3 = bool1;
  }
  return bool3;
 }

 public void onUserInteraction() {
  super.onUserInteraction();
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[0];
   Method localMethod = localClass.getMethod("onUserInteraction",
     arrayOfClass);
   Object[] arrayOfObject = new Object[0];
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 protected void onUserLeaveHint() {
  super.onUserLeaveHint();
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[0];
   Method localMethod = localClass.getMethod("onUserLeaveHint",
     arrayOfClass);
   Object[] arrayOfObject = new Object[0];
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void onWindowAttributesChanged(
   WindowManager.LayoutParams paramLayoutParams) {
  super.onWindowAttributesChanged(paramLayoutParams);
  try {
   Class localClass = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = WindowManager.LayoutParams.class;
   Method localMethod = localClass.getMethod(
     "onWindowAttributesChanged", arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   arrayOfObject[0] = paramLayoutParams;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void onWindowFocusChanged(boolean paramBoolean) {
  super.onWindowFocusChanged(paramBoolean);
  try {
   Class localClass1 = sAndroidActivityWrapperClass;
   Class[] arrayOfClass = new Class[1];
   arrayOfClass[0] = Boolean.TYPE;
   Method localMethod = localClass1.getMethod("onWindowFocusChanged",
     arrayOfClass);
   Object[] arrayOfObject = new Object[1];
   Boolean localBoolean = Boolean.valueOf(paramBoolean);
   arrayOfObject[0] = localBoolean;
   InvokeMethod(localMethod, arrayOfObject);
  } catch (Exception localException) {
  }
 }

 public void showDialog() {
  AlertDialog.Builder localBuilder1 = new AlertDialog.Builder(this);
  AlertDialog.Builder localBuilder2 = localBuilder1.setTitle(2130968578);
  AlertDialog.Builder localBuilder3 = localBuilder1
    .setMessage(2130968579);

  AlertDialog.Builder localBuilder4 = localBuilder1.setPositiveButton(
    2130968576,
    new android.content.DialogInterface.OnClickListener() {
     @Override
     public void onClick(DialogInterface arg0, int arg1) {
      launchMarketPlaceForAIR();
      System.exit(0);
     }
    });

  AlertDialog.Builder localBuilder5 = localBuilder1.setNegativeButton(
    2130968577,
    new android.content.DialogInterface.OnClickListener() {
     @Override
     public void onClick(DialogInterface arg0, int arg1) {
      System.exit(0);
     }

    });

  AlertDialog.Builder localBuilder6 = localBuilder1
    .setOnCancelListener(new android.content.DialogInterface.OnCancelListener() {
     @Override
     public void onCancel(DialogInterface arg0) {
      System.exit(0);
     }
    });

  AlertDialog localAlertDialog = localBuilder1.show();
 }
}

源码看完了，不知大家了解的怎么样了，不管怎样先休息一下，过端午了，先吃粽子啦。。。

AIR for Android

Sat, 02 Jul 2011 15:49:51 +0000

工程项目，建立步骤如下：1.

下载工程项目所需的资源文件 air_for_android-flex_4_5-air_2_6-v_1 2.

建立 Android 工程 TestAIR (注意不要勾选Create Activity，先不创建Activity)

Porject Name: TestAIR
Standard Android Platform: 2.2
Application Name: TestAIR
Package Name: com.carey
Min SDK Version: 8

将下载下来的资源文件覆盖新创建工程的同名目录和文件，包括 assets 和 res，airbootstap.jar 将作为链接库 4.

删除"res/layout" 目录 5.

将 airbootstrap.jar 添加到 Build Path 6.

新建一个Class文件，名称为 MainApp，内容如下：

package com.carey;  
import air.app.AppEntry;
import android.os.Bundle;  

public class MainApp extends AppEntry {    

  @Override   
  public void onCreate(Bundle arg0) {        
      System.out.println("carey test adobe air for android!!!");        
      super.onCreate(arg0);    
  }
}

更新 Manifest 文件中的 Activity 为 MainApp

内容如下：

Extending AIR for Android (4)

Sat, 02 Jul 2011 15:35:06 +0000

Application Licensing

Android provides APIs to help you enforce licensing policies for non-free apps in the Android Market. You might want to go read up on Android Licensing before you give this one a try. To add Application Licensing to you AIR for Android application you first need to follow the steps outlined in the Android documentation. The broad steps are as follows:1.

Set up an Android Market publisher account 2.

Extending AIR for Android (3)

Sat, 02 Jul 2011 15:24:28 +0000

Widgets

Widgets in Android are the mini apps that can be displayed on the home screen of the device. There is a fairly limited amount of things that can be displayed in Widgets. So unfortunately Widgets can’t be built with AIR for Android. However a custom application Widget can be packaged with an AIR for Android application. To add a Widget to an AIR for Android application you can use the default AppEntry class instead of wrapping it with another class (MainApp in my example). (It doesn’t, however, do any harm to keep the MainApp class there.) To add a Widget simply add its definition to the AndroidManifest.xml file, create the Widget with Java, and create a corresponding layout resource.

Extending AIR for Android (2)

Sat, 02 Jul 2011 15:11:56 +0000

System Notifications and Services

AIR for Android applications don’t yet have an API to do Android system notifications. But you can add system notifications to your AIR for Android application through a startup hook. In order for the AIR application to communicate with the native Android APIs you must provide a bridge for the communication. The simplest way to create that bridge is using a network socket. The Android application can listen for data on the socket and then read that data and determine if it needs to display a system notification. Then the AIR application can connect to the socket and send the necessary data. This is a pretty straightforward example but some security (for instance a key exchange) should be implemented to insure that malicious apps don’t discover and abuse the socket. Also some logic to determine which socket should be used would likely be necessary.

Extending AIR for Android (1)

Sat, 02 Jul 2011 14:47:46 +0000

Adobe AIR provides a consistent platform for desktop and mobile apps. While consistency is very important there are times when developers need to extend beyond the common APIs. This article will walk you through how to integrate AIR for Android applications with other native APIs and functionality in the Android SDK. It covers three common use cases for native extensibility: System Notifications, Widgets, and Application Licensing.

If you’d like to follow along you will need the following prerequisites:

利用Appspot访问外部资源

Sat, 02 Jul 2011 14:26:16 +0000

网上翻墙的技术层出不群，本人自己也使用过很多，用过之后，发现还是利用appspot 最实在，最方便。

既然要利用appspot 进行翻墙，那么首先得解决访问*.appspot .com的问题, 因为它本身就是一个墙外的东西，真是灰常像先有鸡还是先有蛋的两难问题啊。。。

幸好这个问题比较容易解决，现将解决方法罗列如下：

【本文用的是win7，xp神马的类似】

建立自己的appspot 代理 gappproxy, 在 google code 上面下载其源代码工程 gappproxy-read-only，

fetchserver是用来上传到appspot的，比如我自己的代理地址为：http://careyproxy.appspot.com/fetch.py

修改hosts文件，win7 在 C:Windows\System32\drivers\etc 下面，注意需要管理员的权限，修改如下：

203.208.39.104 careyproxy.appspot.com
209.85.225.101 sites.google.com
209.85.225.101 docs.google.com
209.85.225.101 spreadsheets.google.com
209.85.225.101 picasaweb.google.com

修改 gappproxy-read-onlylocalproxyproxy.conf 配置文件

listen_port = 8008
fetch_server = http://careyproxy.appspot.com/fetch.py

运行 gappproxy-read-onlylocalproxy proxy.py，命令行输出如下：

说明服务已经启动了

修改本机浏览器的代理地址为127.0.0.1：8008，试试是不是已经能访问facebook和twitter啦

现在开始慢慢欣赏墙外的世界吧。。。

Google ClientLogin for Installed Applications

Sat, 02 Jul 2011 14:20:22 +0000

访问Google的很多服务都需要账户的验证，例如Google Calendar，Google Mail，Google Apps等等，其中ClientLogin验证是使用最多的情况。

本文就简单介绍一下手机应用程序和桌面应用程序的ClientLogin的基本流程和方法。

The ClientLogin authorization process（验证过程）

Authorization with ClientLogin involves a sequence of interactions between three entities: the installed application, Google services, and the user.

This diagram illustrates the sequence:

图片中的验证流程说明如下：

When the third-party application needs to access a user’s Google service, it retrieves the user’s login name and password.
The third-party application then makes a ClientLogin call to Google’s Authorization service.
If the Google Authorization service decides additional vetting is necessary, it returns failure response with a CAPTCHA token and challenge, in the form of a URL for a CAPTCHA image.
If a CAPTCHA challenge is received, the third-party application displays the CAPTCHA image for the user and solicits an answer from the user.
If requested, the user submits an answer to the CAPTCHA challenge.
The third-party application makes a new ClientLogin call, this time including the CAPTCHA answer and token (received with the failure response).
On a successful login attempt (with or without CAPTCHA challenge), the Google Authorization service returns a token to the application.
The application contacts the Google service with a request for data access, referencing the token received from the Google Authorization service.
If the Google service recognizes the token, it supplies the requested data access.

脚本方式获取Google ClientLogin Auth Token

Sat, 02 Jul 2011 14:06:53 +0000

在开发基于Google服务的应用程序中，有很多的情况都需要获取Auth Token。

本文编写了一个简单的shell脚本文件，可方便程序开发人员快速的获取到Auth Token来调试程序。

本示例程序获取的Googel服务为ah，即Google App Engine，如果需要获取其他服务的token，只要修改脚本中的 service=ah 为自己的服务即可。

Google 常用服务和Service Name 对照表

Google API	Service name
Google Analytics Data APIs	`analytics`
Google Apps APIs (Domain Information & Management)	`apps`
Google Base Data API	`gbase`
Google Sites Data API	`jotspot`
Blogger Data API	`blogger`
Book Search Data API	`print`
Calendar Data API	`cl`
Google Code Search Data API	`codesearch`
Contacts Data API	`cp`
Documents List Data API	`writely`
Finance Data API	`finance`
Gmail Atom feed	`mail`
Health Data API	`health` `weaver` (H9 sandbox)
Maps Data APIs	`local`
Picasa Web Albums Data API	`lh2`
Sidewiki Data API	`annotateweb`
Spreadsheets Data API	`wise`
Webmaster Tools API	`sitemaps`
YouTube Data API	`youtube`

Google Service 评测请参照 Google Account Service Names （Google工程师 Tony Ruscoe）脚本代码如下（get_auth_token.sh）：

打造个人的云端笔记本之CareyDiary

Sat, 02 Jul 2011 13:58:17 +0000

打造个人的云端笔记本（CareyDiary）在自己的日常生活中，有好多情况都需要记录一点东西，而且又希望能长久的保存，自从有了Android手机，记笔记倒是方便了，但是发现，每次一刷完机，东西全没了，提前做好备份工作吧，又嫌麻烦，还是找个智能的方法吧，不然怎么叫智能机呢。。。

通过前段时间对欧美业务的开发，发现为自己打造一个在线记笔记的软件还是很实用的，怪不得国外都喜欢这个东西。

本文的软件基于Google官方的Note程序移植而来，毕竟官方的东西还是可信的，O(∩_∩)O哈哈~

云端服务：

http://diary.zhourunsheng.com 后台采用GAE服务的支持，Java语言开发，和 Google C2DM消息push架构

本地APP：http://careydiary.googlecode.com/files/careydiary-android.apk

基于Android2.2系统开发，整合系统的Sync机制和Google账户的管理，可实现本地笔记和在线笔记的同步

系统架构介绍：

从上图不难看出，本系统主要是利用了Google的消息push机制C2DM, 从而可以有效的实现在线笔记和本地笔记的及时同步，因为服务器的后台开发基于GAE，所以又能方便集合个人的账户认证管理，只要你拥有一个GMail邮件账户，即可利用本服务实现信息的在线存储。

[Android Cloud to Device Messaging Framework]

Android Cloud to Device Messaging (C2DM) is a service that helps developers send data from servers to their applications on Android devices. The service provides a simple, lightweight mechanism that servers can use to tell mobile applications to contact the server directly, to fetch updated application or user data. The C2DM service handles all aspects of queueing of messages and delivery to the target application running on the target device.

探索GAE背后的奥秘之参考文章推荐

Sat, 02 Jul 2011 12:56:32 +0000

Google’s Dr. Kai-Fu Lee on Cloud Computing

The Cost of Latency Google App Engine Blog Bigtable: A Distributed Storage System for Structured Data

From Spark Plug to Drive Train: Life of an App Engine Request

Google Megastore Google App Engine官方文档 Google Architecture

Google App Engine - a first look

Google Chose Jetty for App Engine

Google App Engine is Down - Backup Data Center Having Problems

面向虚拟基础设施的云服务，第 2 部分: Platform as a Service (PaaS) 和 AppScale

探索GAE背后的奥秘之Datastore设计

Sat, 02 Jul 2011 12:50:42 +0000

本篇会首先会从程序员角度来介绍一下Datastore在使用方面的一些信息，之后会接着介绍Datastore是如何构建的。

使用方面

首先，在编程方面，Datastore是基于"Entity（实体）“这个概念，而且Entity和"对象"这个概念比较类似，同时Entity可以包括多个Property（属性），Property的类别有整数，浮点和字符串等，比如，可以设计一个名为"Person"的Entity，它包含名为"Name"的字符串Property和名为"Age"的整数Property。由于Datastore是"Schema-less"的，所以数据的Schema都由应用维护，而且能非常方便地对一个Entity所包含的属性进行增删和修改。在存储方面，一个Entity的实例可以被认为是一个普通的"Row（行）"，而包含所有这种Entity的实例的Table被称为Kind，比如，所有通过"Person"这个Entity生成实例，比如小吴，小朱和小华等，它们都会存放在同一个名为"Person"的Kind中。在结构方面，虽然也能通过特定的方式在Datastore中实现关系型结构，但是Datastore在设计上是为层次（Hierarchical）性结构"度身定做"的，有Root Entity和Child Entity之分，比如，可以把"Person"作为Root Entity（父实体），“Address"作为"Person"的Child Entity，两者合在一起可以称为一个"Entity Group”。这样做的好处是能将这两个实体集中一个BigTable本地分区中，而且能对这两个实体进行本地事务。

接下来，将谈一下Datastore支持那些高级功能：其一是提供名为GQL（Google Query Language）的查询语言，GQL是SQL的一个非常小的子集，包括对”>"，"<“和”=“等操作符。其二是App Engine会根据代码中查询语句来自动生成相应Index，但不支持对Composite Index生成。其三是虽然由于Datastore分布式的设计，所以在速度方面和传统的关系型数据库相比一定的差距，但是Google的架构师保证大部分对Datastore的操作能在200ms之内完成，同时也得益于它的分布式设计，使得它在扩展性方面特别出色。其四是Datastore也支持在实体之间创建关系，比如在Python版App Engine中可以使用ReferenceProperty在实体间构建一对多和多对多的关系。

下表为Datastore和传统的关系型数据库之间的比较：

	Datastore	关系型数据库
SQL支持	只支持一些基本的查询	全部支持
主要结构	层次（Hierarchical）	关系
Index	部分可自动创建	手动创建
事务	只支持在一个Entity Group内执行	支持
平均执行速度（ms）	低于200	低于100
扩展型	非常好	很困难，而且需要进行大量的修改

表1. Datastore和关系型数据库之间的比较

最后，在接口方面，Python版提供一套私有的API和框架，在基本功能方面，比较容易学习，但在部分高级功能方面，比如关系和事务等方面，学习难度很高；Java版的API是基于JDO和JPA这两套官方的ORM标准，但是和现在事实的标准Hibernate有一定的差异。

实现方面

在实现方面，Datastore是在BigTable的基础上构建的，所以本段会首先重新介绍一下BigTable，之后会介绍Datastore的两个组成部分：Entities Table和Index，最后会讲一下它在事务和备份这两方面所采用的机制。

BigTable

在本系列的第一篇已经按照Google的Paper对BigTable技术做了一定的介绍，但其实BigTable本身其实没有之前介绍的那样复杂，其实就是一个非常巨大的Table，这也是它之所以名为"BigTable"的原因，而且结构就像图1那样非常简单，就是一个个ROW，每个ROW都有一个Name和一组Cloumn，但是为了支持海量的数据，它将这个大的Table进行分片（Sharding）处理，每台服务器存储一个海量的Table的一小部分，并且为了查询效率，会对这个Table进行排序。就像App Engine的创始人之一Ryan Barrett所说的那样"BigTable is a sharded, sorted array “。

图1. BigTable简化版模型

在功能方面，首先，BigTable支持基本的CRUD操作，也就是增加(Create)，查询(Read)，更新(Update)和删除(Delete)。其次支持对Single-Row的事务与基于前缀和范围的扫描。

Entities Table

它是Datastore最核心的Table，是以BigTable的形式存在的，主要用于存储所有的Entity，而且是格式非常简单，每行都会有一个Row Name，也称为Entity Key（可认为它是一个Entity的Primary Key），而且只有唯一一个Column，主要用于存放被序列化的Entity。每个Entity的Key的生成是基于它的父Entity（如果有的话）和其父至上的Entity，直到其Root Entity。以下图为例，timmy的父Entity是jane，jane的父Entity兼Root Entity是Ethel，所以最后timmy的Entity Key是”/Grandparent:Ethel/Parent:Jane/Child:Timmy”。

图2. Entity Key的例子 Index

探索GAE背后的奥秘之GAE架构

Sat, 02 Jul 2011 12:39:08 +0000

本篇将首先介绍App Engine的一些设计理念，接着将对App Engine的组成部分等进行介绍。

设计理念

App Engine在设计理念方面，主要可以总结为下面这五条：

重用现有的Google技术：大家都知道，重用是软件工程的核心理念之一，因为通过重用不仅能减低开发成本，而且能简化架构。在App Engine开发的过程中，重用的思想也得到了非常好的体现，比如Datastore是基于Google的bigtable技术，Images服务是基于Picasa的，用户认证服务是利用Google Account的，Email服务是基于Gmail的等。
无状态：为了让更好地支持扩展，Google没有在应用服务器层存储任何重要的状态，而主要在datastore这层对数据进行持久化，这样当应用流量突然爆发时，可以通过为应用添加新的服务器来实现扩展。
硬限制：App Engine对运行在其之上的应用代码设置了很多硬性限制，比如无法创建Socket和Thread等有限的系统资源，这样能保证不让一些恶性的应用影响到与其临近应用的正常运行，同时也能保证在应用之间能做到一定的隔离。
利用Protocol Buffers技术来解决服务方面的异构性：应用服务器和很多服务相连，有可能会出现异构性的问题，比如应用服务器是用Java写的，而部分服务是用C++写的等。Google在这方面的解决方法是基于语言中立，平台中立和可扩展的Protocol Buffer，并且在App Engine平台上所有API的调用都需要在进行RPC（Remote Procedure Call，远程方面调用）之前被编译成Protocol Buffer的二进制格式。
分布式数据库：因为App Engine将支撑海量的网络应用，所以独立数据库的设计肯定是不可取的，而且很有可能将面对起伏不定的流量，所以需要一个分布式的数据库来支撑海量的数据和海量的查询。

组成部分

图1. GAE的架构图简单而言，其架构可以分为三个部分：前端，Datastore和服务群：前端共包括四个模块：

Front End：既可以认为它是Load Balancer，也可以认为它是Proxy，它主要负责负载均衡和将请求转发给App Server（应用服务器）或者Static Files等工作。
Static Files：在概念上，比较类似于CDN（Content Delivery Network，内容分发网络），用于存储和传送那些应用附带的静态文件，比如图片，CSS和JS脚本等。
App Server：用于处理用户发来的请求，并根据请求的内容来调用后面的Datastore和服务群。
App Master：是在应用服务器间调度应用，并将调度之后的情况通知Front End。

Datastore

它是基于BigTable技术的分布式数据库，虽然其也可以被理解成为一个服务，但是由于其是整个App Engine唯一存储持久化数据的地方，所以其是App Engine中一个非常核心的模块。其具体细节将在下篇和大家讨论。

服务群整个服务群包括很多服务供App Server调用，比如Memcache，图形，用户，URL抓取和任务队列等。

Python版和Java版App Engine在实现方面的区别

因为大多数服务都可以被这两个版本共享，所以两者之间的区别主要集中在App Server端，Python版App Server应该是经过Google修改的Python Runtime，版本号应该是2.5.2，而Java版App Server是基于Jetty 6的，因为它的体积和最常用的Tomcat相比更娇小，这样能使得一台服务器支持更多的应用，而且其应该经过Google的一定的修改。

流程

在这里举一个普通的HTTP请求的处理流程为例：

用户发送一个HTTP请求。
Front End接受这个请求，并将这个请求转发给一个空闲的App Server。
App Server会处理这个请求。
检查用于处理这个请求的Handler是不是已经被初始化了，如果没有的话，需要对这个Handler进行初始化。
调用服务群的用户认证服务来对用户进行认证，如果失败的话，需要终止整个请求的处理工作，并返回用户无法被认证的信息。
查看这个请求所需的数据是否已经缓存在Memcahe中，如果没有的话，将对Datastore发出查询请求来得到数据。
通过整合上步得到数据来生成相关的HTML，并返回给用户。
由于HTML里面会包含对一些静态文件的引用，比如图片和CSS等，所以当用户收到HTML之后，还会通过Front End对Static Files里面存储的静态文件进行读取。

文章来源：http://www.dbanotes.net/arch/google_app_engine-arch_intro.html

探索GAE背后的奥秘之GAE简介

Sat, 02 Jul 2011 12:30:44 +0000

通过前面两篇介绍，大家应该对Google强大的基础设施有一定的了解。本篇开始介绍构筑在这强大基础设施之上的Google App Engine。

Google App Engine的介绍

由于发布S3和EC2这两个优秀的云服务，使得Amazon已经率先在云计算市场站稳了脚跟，而身为云计算这个浪潮的发起者之一的Google肯定不甘示弱，并在2008年四月份推出了Google App Engine这项PaaS服务，虽然现在无法称其为一个革命性的产品，但肯定是现在市面上最成熟，并且功能最全面的PaaS平台。

Google App Engine 提供一整套开发组件来让用户轻松地在本地构建和调试网络应用，之后能让用户在Google强大的基础设施上部署和运行网络应用程序，并自动根据应用所承受的负载来对应用进行扩展，并免去用户对应用和服务器等的维护工作。同时提供大量的免费额度和灵活的资费标准。在开发语言方面，现支持Java和Python这两种语言，并为这两种语言提供基本相同的功能和API。

目前已经支持google开发的第三种语言Go语言平台的开发了。

功能在功能上，主要有六个方面：

动态网络服务，并提供对常用网络技术的支持，比如SSL等。
持久存储空间，并支持简单的查询和本地事务。
能对应用进行自动扩展和负载平衡。
一套功能完整的本地开发环境，可以让用户在本机上对App Engine进行开发和调试。
支持包括Email和用户认证等多种服务。
提供能在指定时间和定期触发事件的计划任务和能实现后台处理的任务队列。

使用流程整个使用流程主要包括五个步骤：

下载SDK和IDE，并在本地搭建开发环境。
在本地对应用进行开发和调试。
使用GAE自带上传工具来将应用部署到平台上。
在管理界面中启动这个应用。
利用管理界面来监控整个应用的运行状态和资费。

由于本系列是专注于GAE的实现和设计两方面，所以不会对GAE的使用有非常深入地介绍，如果希望大家对GAE的使用方面有更深的理解，具体可以参看一下GAE的官方文档。

Google App Engine的主要组成部分

主要可分为五部分：

应用服务器：主要是用于接收来自于外部的Web请求。
Datastore：主要用于对信息进行持久化，并基于Google著名的BigTable技术。
服务：除了必备的应用服务器和Datastore之外，GAE还自带很多服务来帮助开发者，比如：Memcache，邮件，网页抓取，任务队列，XMPP等。
管理界面：主要用于管理应用并监控应用的运行状态，比如，消耗了多少资源，发送了多少邮件和应用运行的日志等。
本地开发环境：主要是帮助用户在本地开发和调试基于GAE的应用，包括用于安全调试的沙盒，SDK和IDE插件等工具。

应用服务器

应用服务器依据其支持语言的不同而有不同的实现。

Python的实现

Python版应用服务器的基础就是普通的Python 2.5.2版的Runtime，并考虑在未来版本中添加对Python 3的支持，但是因为Python 3对Python而言，就好比Java2之于Java1，跨度非常大，所以引入Python3的难度很大。在Web技术方面，支持诸如Django，CherryPy，Pylons和Web2py等Python Web框架，并自带名为"WSGI"的CGI框架。虽然Python版应用服务器是基于标准的Python Runtime，但是为了安全并更好地适应App Engine的整体架构，对运行在应用服务器内的代码设置了很多方面的限制，比如不能加载用C编写Python模块和无法创建Socket等。

Java的实现

在实现方面，Java版应用服务器和Python版基本一致，也是基于标准的Java Web容器，而且选用了轻量级的Jetty技术，并跑在Java 6上。通过这个Web容器不仅能运行常见的Java Web 技术，包括Servlet，JSP，JSTL和GWT等，而且还能跑大多数常用的Java API（App Engine有一个 The JRE Class White List

来定义那些Java API能在App Engine的环境中被使用）和一些基于JVM的脚本语言，例如JavaScript，Ruby或Scala等，但同样无法创建Socket和Thread，或者对文件进行读写，也不支持一些比较高阶的API和框架，包括JDBC，JSF，Struts 2，RMI，JAX-RPC和Hibernate等。

Datastore

Datastore提供了一整套强大的分布式数据存储和查询服务，并能通过水平扩展来支撑海量的数据。但Datastore并不是传统的关系型数据库，它主要以"Entity"的形式存储数据，一个Entity包括一个Kind（在概念上和数据库的Table比较类似）和一系列属性。

Datastore提供强一致性和乐观（optimistic）同步控制，而在事务方面，则支持本地事务，也就是在只能同一个Entity Group内执行事务。

在接口方面，Python版提供了非常丰富的接口，而且还包括名为GQL的查询语言，而Java版则提供了标准的JDO和JPA这两套API。

探索GAE背后的奥秘之Google的整体架构猜想

Sat, 02 Jul 2011 12:14:38 +0000

本文是基于现有的公开资料和个人的经验来对Google的整体架构进行总结和猜想。

在软件工程界，大家有一个共识，那就是"需求决定架构"，也就是说，架构的发展是为了更好地支撑应用。那么本文在介绍架构之前，先介绍一下Google所提供的主要产品有哪些？

产品

对于Google和它几个主要产品，比如搜索和邮件等，大家已经非常熟悉了，但是其提供服务的不只于此，并主要可分为六大类：

各种搜索：网页搜索，图片搜索和视频搜索等。
广告系统：AdWords和AdSense。
生产力工具：Gmail和Google Apps等。
地理产品：地图，Google Earth和Google Sky等。
视频播放：Youtube。
PaaS平台：Google App Engine。

设计理念

根据现有的资料，Google的设计理念主要可以总结出下面这六条：

Scale，Scale，Scale Scale：因为Google大多数服务所面对的客户都是百万级别以上的，导致Scale也就是伸缩已经深深植入Google的DNA中，而且Google为了帮助其开发人员更好地开发分布式应用和服务，不仅研发了用于大规模数据处理MapReduce框架，还推出了用于部署分布式应用的PaaS平台Google App Engine。
容错：一个分布式系统，就算是构建在昂贵的小型机或者大型机之上，也会不时地出现软件或者硬件方面的错误，何况Google的分布式系统还是浇筑在便宜的X86服务器之上，即使其设备标称的MTBF（平均故障间隔时间）很高，但是由于一个集群内的设备极多，导致其错误发生的几率非常高，比如李开复曾经提过这样一个例子：在一个拥有两万台X86服务器的集群中，每天大约有110台机器会出现宕机等恶劣情况，所以容错是一个不可被忽视的问题，同时这点也被Google院士Jeffrey Dean在多次演讲中提到。
低延迟：延迟是影响用户体验的一个非常重要的因素，Google的副总裁Marissa Mayer曾经说过：“如果每次搜索的时间多延迟半秒的话，那么使用搜索服务的人将减少20%"，从这个例子可以看出，低延迟对用户体验非常关键，而且为了避免光速和复杂网络环境造成的延时，Google已在很多地区设置了本地的数据中心。
廉价的硬件和软件：由于Google每天所处理的数据和请求在规模上是史无前例的，所以现有的服务器和商业软件厂商是很难为Google"度身定做"一套分布式系统，而且就算能够设计和生产出来，其价格也是Google所无法承受的，所以其上百万台服务器基本采用便宜的X86系统和开源的Linux，并开发了一整套分布式软件栈，其中就包括上篇提到的MapReduce，BigTable和GFS等。
优先移动计算：虽然随着摩尔定律的不断发展，使得很多资源都处于不断地增长中，比如带宽等，但是到现在为止移动数据成本远大于移动计算的成本，所以在处理大规模数据的时候，Google还是倾向于移动计算，而不是移动数据。
服务模式：在Google的系统中，服务是相当常用的，比如其核心的搜索引擎需要依赖700-1000个内部服务，而且服务这种松耦合的开发模式在测试，开发和扩展等方面都有优势，因为它适合小团队开发，并且便于测试。

整体架构的猜想

在整体架构这部分，首先会举出Google的三种主要工作负载，接着会试着对数据中心进行分类，最后会做一下总结。

三种工作负载对于Google而言，其实工作负载并不仅仅只有搜索这一种，主要可以被分为三大类：

本地交互：用于在用户本地为其提供基本的Google服务，比如网页搜索等，但会将内容的生成和管理工作移交给下面的内容交付系统，比如：生成搜索所需的Index等。通过本地交互，能让用户减少延迟，从而提高用户体验，而且其对SLA要求很高，因为是直接面对客户的。
内容交付：用于为Google大多数服务提供内容的存储，生成和管理工作，比如创建搜索所需的Index，存储YouTube的视频和GMail的数据等，而且内容交互系统主要基于Google自己开发那套分布式软件栈。还有，这套系统非常重视吞吐量和成本，而不是SLA。
关键业务：主要包括Google一些企业级事务，比如用于企业日常运行的客户管理和人力资源等系统和赚取利润的广告系统（AdWords和AdSense），同时关键业务对SLA的要求非常高。

两类数据中心

按照2008年数据，Google在全球有37个数据中心，其中19个在美国，12个在欧洲，3个在亚洲(北京、香港、东京)，另外3个分布于俄罗斯和南美。下图显示其中36个数据中心在全球的分布：

图1. 2008年Google全球数据中心分布图根据 Jeffrey Dean

在2009年末的一次演讲和最近几期季报可以推测出Google并没有在2009年过多地增加全球数据中心的数量，总数应该还是稍多于36个，但很有可能在台湾、马来西亚、立陶宛等地增加新的数据中心。

虽然Google拥有数据中心数量很多，但是它们之间存在一定的差异，而且主要可以分为两类：其一是巨型数据中心，其二是大中型数据中心。

巨型数据中心

服务器规模应该在十万台以上，常坐落于发电厂旁以获得更廉价的能源，主要用于Google内部服务，也就是内容交付服务，而且在设计方面主要关注成本和吞吐量，所以引入了大量的定制硬件和软件，来减低PUE并提升处理量，但其对SLA方面要求不是特别严厉，只要保证绝大部分时间可用即可。下图是Google巨型数据中心的一个代表，这个数据中心位于美国俄勒冈州北部哥伦比亚河畔的Dalles市，总占地面积接近30英亩，并占用了附近一个1.8GW水力发电站的大部分电力输出，当这个数据中心全部投入使用后，将消耗103兆瓦的电力，这相当于一个中小型城市的整个生活用电。

图2. Google在美国俄勒冈州哥伦比亚河畔的巨型数据中心近景图大中型数据中心：服务器规模在千台至万台左右，可用于本地交互或者关键业务，在设计方面上非常重视延迟和高可用性，使得其坐落地点尽可能地接近用户而且采用了标准硬件和软件，比如Dell的服务器和MySQL的数据库等，常见的PUE大概在1.5和1.9之间。本来坐落于北京朝阳区酒仙桥附近的"世纪互联"机房的Google中国数据中心也属于大中型数据中心这类，其采用的硬件有DELL的工作站和Juniper的防火墙等，下图为其一角。

图3. Google前中国数据中心的一角（参[26]）关于两者的区别：具体请查看下表：

	巨型数据中心	大中型数据中心
工作负载	内容交付	本地交互/关键业务
地点	离发电厂近	离用户近
设计特点	高吞吐，低成本	低延迟，高可用性
服务器定制化	多	少
SLA	普通	高
服务器数量	十万台以上	千台以上
数据中心数量	十个以内	几十个
PUE估值	1.2	1.5

表1. 巨型与大中型数据中心的对比表

探索GAE背后的奥秘之Google的核心技术

Fri, 01 Jul 2011 17:44:02 +0000

本系列文章基于公开资料对Google App Engine的实现机制这个话题进行深度探讨。在切入Google App Engine之前，首先会对Google的核心技术和其整体架构进行分析，以帮助大家之后更好地理解Google App Engine的实现。

本篇将主要介绍Google的十个核心技术，而且可以分为四大类：

分布式基础设施：GFS、Chubby 和 Protocol Buffer。
分布式大规模数据处理：MapReduce 和 Sawzall。
分布式数据库技术：BigTable 和数据库 Sharding。
数据中心优化技术：数据中心高温化、12V电池和服务器整合。

分布式基础设施

GFS

由于搜索引擎需要处理海量的数据，所以Google的两位创始人Larry Page和Sergey Brin在创业初期设计一套名为"BigFiles"的文件系统，而GFS（全称为"Google File System"）这套分布式文件系统则是"BigFiles"的延续。

首先，介绍它的架构，GFS主要分为两类节点：

Master节点：主要存储与数据文件相关的元数据，而不是Chunk（数据块）。元数据包括一个能将64位标签映射到数据块的位置及其组成文件的表格，数据块副本位置和哪个进程正在读写特定的数据块等。还有Master节点会周期性地接收从每个Chunk节点来的更新（“Heart-beat”）来让元数据保持最新状态。
Chunk节点：顾名思义，肯定用来存储Chunk，数据文件通过被分割为每个默认大小为64MB的Chunk的方式存储，而且每个Chunk有唯一一个64位标签，并且每个Chunk都会在整个分布式系统被复制多次，默认为3次。

下图就是GFS的架构图：

图1. GFS的架构图（参片[15]）接着，在设计上，GFS主要有八个特点：

大文件和大数据块：数据文件的大小普遍在GB级别，而且其每个数据块默认大小为64MB，这样做的好处是减少了元数据的大小，能使Master节点能够非常方便地将元数据放置在内存中以提升访问效率。
操作以添加为主：因为文件很少被删减或者覆盖，通常只是进行添加或者读取操作，这样能充分考虑到硬盘线性吞吐量大和随机读写慢的特点。
支持容错：首先，虽然当时为了设计方便，采用了单Master的方案，但是整个系统会保证每个Master都会有其相对应的复制品，以便于在Master节点出现问题时进行切换。其次，在Chunk层，GFS已经在设计上将节点失败视为常态，所以能非常好地处理Chunk节点失效的问题。
高吞吐量：虽然其单个节点的性能无论是从吞吐量还是延迟都很普通，但因为其支持上千的节点，所以总的数据吞吐量是非常惊人的。
保护数据：首先，文件被分割成固定尺寸的数据块以便于保存，而且每个数据块都会被系统复制三份。
扩展能力强：因为元数据偏小，使得一个Master节点能控制上千个存数据的Chunk节点。
支持压缩：对于那些稍旧的文件，可以通过对它进行压缩，来节省硬盘空间，并且压缩率非常惊人，有时甚至接近90%。
用户空间：虽然在用户空间运行在运行效率方面稍差，但是更便于开发和测试，还有能更好利用Linux的自带的一些POSIX API。

现在Google内部至少运行着200多个GFS集群，最大的集群有几千台服务器，并且服务于多个Google服务，比如Google搜索。但由于GFS主要为搜索而设计，所以不是很适合新的一些Google产品，比YouTube、Gmail和更强调大规模索引和实时性的Caffeine搜索引擎等，所以Google已经在开发下一代GFS，代号为"Colossus"，并且在设计方面有许多不同，比如：支持分布式Master节点来提升高可用性并能支撑更多文件，Chunk节点能支持1MB大小的chunk以支撑低延迟应用的需要。

Chubby

简单的来说，Chubby 属于分布式锁服务，通过 Chubby，一个分布式系统中的上千个client都能够对于某项资源进行"加锁"或者"解锁"，常用于BigTable的协作工作，在实现方面是通过对文件的创建操作来实现"加锁"，并基于著名科学家Leslie Lamport的Paxos算法。

Protocol Buffer

Protocol Buffer，是Google内部使用一种语言中立、平台中立和可扩展的序列化结构化数据的方式，并提供 Java、C++ 和 Python 这三种语言的实现，每一种实现都包含了相应语言的编译器以及库文件，而且它是一种二进制的格式，所以其速度是使用 XML

进行数据交换的10倍左右。它主要用于两个方面：其一是RPC通信，它可用于分布式应用之间或者异构环境下的通信。其二是数据存储方面，因为它自描述，而且压缩很方便，所以可用于对数据进行持久化，比如存储日志信息，并可被Map Reduce程序处理。与Protocol Buffer比较类似的产品还有Facebook的 Thrift，而且 Facebook 号称Thrift在速度上还有一定的优势。

分布式大规模数据处理

MapReduce

首先，在Google数据中心会有大规模数据需要处理，比如被网络爬虫（Web Crawler）抓取的大量网页等。由于这些数据很多都是PB级别，导致处理工作不得不尽可能的并行化，而Google为了解决这个问题，引入了MapReduce这个编程模型，MapReduce是源自函数式语言，主要通过"Map（映射）“和"Reduce（化简）“这两个步骤来并行处理大规模的数据集。Map会先对由很多独立元素组成的逻辑列表中的每一个元素进行指定的操作，且原始列表不会被更改，会创建多个新的列表来保存Map的处理结果。也就意味着，Map操作是高度并行的。当Map工作完成之后，系统会先对新生成的多个列表进行清理（Shuffle）和排序，之后会这些新创建的列表进行Reduce操作，也就是对一个列表中的元素根据Key值进行适当的合并。下图为MapReduce的运行机制：

图2. MapReduce的运行机制（参[19]）

同步wordpress文章到CSDN

Thu, 30 Jun 2011 23:29:14 +0000

本文实现了wordpress的插件开发，自动同步 wordpress的文章到CSDN。

== Description == 同步发布 WordPress 博文到支持 Metaweblog API 的博客系统. Version 1.0 支持功能

支持发布wordpress的博文到实现Metaweblog API 的博客系统（CSDN，博客园等）
支持将Wordpress中文章链接发布到其他博客系统。
支持发布文章的自动归类

== Installation ==

上传整个文件夹 wp2metaweblog 到 /wp-content/plugins/ 目录
后台控制面板"插件(Plugins)“中激活 wp2metaweblog 插件
后台控制面板"配置(Settings)->wp2metaweblog"中配置插件信息（博客系统的账户信息）

软件配置界面:

软件下载地址：http://code.google.com/p/wp2metaweblog/downloads/list

AsyncQueryHandler

Thu, 30 Jun 2011 14:03:54 +0000

Class Overview A helper class to help make handling asynchronous

ContentResolver queries easier.

AsyncQueryHandler的目的就是为了将查询数据库的操作放到后台执行，当后台数据查询完了以后，再通知界面的更新，以此来提高前台页面的显示速度！

内部的实现机制其实就是Handler，我们自己平时做大数据量显示的时候也用到过，另起一个线程去执行任务，当后台计算完成的时候通过Handler发送Message来重绘界面，这个的实现原理类似，做了一层封装而已，方便开发人员的调用。

Public Methods

修饰符	方法
final void	cancelOperation(int token) Attempts to cancel operation that has not already started.
void	handleMessage(Message msg) Subclasses must implement this to receive messages.
final void	startDelete(int token, Object cookie, Uri uri, String selection, String[] selectionArgs) This method begins an asynchronous delete.
final void	startInsert(int token, Object cookie, Uri uri, ContentValues initialValues) This method begins an asynchronous insert.
void	startQuery(int token, Object cookie, Uri uri, String[] projection, String selection, String[] selectionArgs, String orderBy) This method begins an asynchronous query.
final void	startUpdate(int token, Object cookie, Uri uri, ContentValues values, String selection, String[] selectionArgs) This method begins an asynchronous update.

Protected Methods

返回值	方法
Handler	createHandler(Looper looper)
void	onDeleteComplete(int token, Object cookie, int result) Called when an asynchronous delete is completed.
void	onInsertComplete(int token, Object cookie, Uri uri) Called when an asynchronous insert is completed.
void	onQueryComplete(int token, Object cookie, Cursor cursor) Called when an asynchronous query is completed.
void	onUpdateComplete(int token, Object cookie, int result) Called when an asynchronous update is completed.

其实这些方法都是成对来使用的，比如查询操作，我们通过调用 startDelete (int token,Object cookie,Uri uri,String selection,String[]

每个程序员都该阅读的书

Thu, 30 Jun 2011 09:39:29 +0000

调查问卷：What is the single most influential book every programmer should read?

Code Complete (2nd Ed) by Steve McConnell 《代码大全（第二版）》 2.

Pragmatic Programmer 《程序员修炼之道》 3.

Structure and Interpretation of Computer Programs 《计算机程序的构造和解释》 4.

The C Programming Language 《C程序设计语言》 5.

Introduction to algorithms (Cormen, Leiserson, Rivest, Stein) 《算法导论》 6.

Refactoring: Improving the Design of Existing Code 《重构：改善既有代码的设计》 7.

Design Patterns 《设计模式》 8.

The Mythical Man-Month 《人月神话》 9.

The Art of Computer Programming 《计算机程序设计艺术》 10.

关于我

Thu, 23 Jun 2011 22:21:14 +0000

我是谁，我是谁，我是天空一朵云！！！

个人信息

职业：系统架构设计师
现居：辽宁大连
兴趣：互联网最前沿技术，只要喜欢，什么都可以
主页：http://zhourunsheng.com

联系方式（Email）

Gmail：zhourunsheng2008@gmail.com
Foxmail：396468178@qq.com

公众平台二维码

网站政策

如未另行说明，本网站的内容根据

Creative Commons Attribution 3.0 License（知识共享许可协议·3.0·版）

授予许可，代码示例根据

Apache 2.0 License (Apache 许可 2.0 版）

授予许可。

Ubuntu 10.10 Manual 手册

Thu, 23 Jun 2011 12:56:46 +0000

Official Ubuntu 10.10 Manual 手册《Getting Started with Ubuntu 10.10》，现在已经可以免费下载了。

该书是一本不错的入门书籍和查询手册，对于一步一步掌握Ubuntu有很大的参考价值。

下载地址：http://ubuntu-manual.org/

使用命令：

wget http://files.ubuntu-manual.org/manuals/getting-started-with-ubuntu/10.10/en_US/screen/Getting%20Started%20with%20Ubuntu%2010.10.pdf

下载链接：《Getting Started with Ubuntu 10.10》

如何成为Python高手

Thu, 23 Jun 2011 09:14:23 +0000

本文是从 How to become a proficient Python programmer 这篇文章翻译而来。

这篇文章主要是对我收集的一些文章的摘要。因为已经有很多比我有才华的人写出了大量关于如何成为优秀Python程序员的好文章。

我的总结主要集中在四个基本题目上：函数式编程，性能，测试，编码规范。

如果一个程序员能将这四个方面的内容知识都吸收消化，那他/她不管怎样都会有巨大的收获。

函数式编程

命令式的编程风格已经成为事实上的标准。命令式编程的程序是由一些描述状态转变的语句组成。虽然有时候这种编程方式十分的有效，但有时也不尽如此(比如复杂性) —— 而且，相对于声明式编程方式，它可能会显得不是很直观。

如果你不明白我究竟是在说什么，这很正常。这里有一些文章能让你脑袋开窍。但你要注意，这些文章有点像《骇客帝国》里的红色药丸 —— 一旦你尝试过了函数式编程，你就永远不会回头了。

性能

你会看到有如此多的讨论都在批评这些“脚本语言”(Python，Ruby)是如何的性能低下，可是你却经常的容易忽略这样的事实：是程序员使用的算法导致了程序这样拙劣的表现。

这里有一些非常好的文章，能让你知道Python的运行时性能表现的细节详情，你会发现，通过这些精炼而且有趣的语言，你也能写出高性能的应用程序。而且，当你的老板质疑Python的性能时，你别忘了告诉他，这世界上第二大的搜索引擎就是用Python写成的 —— 它叫做Youtube(参考 Python摘录)

测试

如今在计算机科学界，测试可能是一个最让人不知所措的主题了。有些程序员能真正的理解它，十分重视TDD(测试驱动开发)和它的后继者BDD(行为驱动开发)。而另外一些根本不接受，认为这是浪费时间。那么，我现在将告诉你：如果你不曾开始使用TDD/BDD，那你错过了很多最好的东西！

这并不只是说引入了一种技术，可以替换你的公司里那种通过愚蠢的手工点击测试应用程序的原始发布管理制度，更重要的是，它是一种能够让你深入理解你自己的业务领域的工具 —— 真正的你需要的、你想要的攻克问题、处理问题的方式。如果你还没有这样做，请试一下。下面的这些文章将会给你一些提示：

编码规范

并非所有的代码生来平等。有些代码可以被另外的任何一个好的程序员读懂和修改。但有些却只能被读，而且只能被代码的原始作者修改 —— 而且这也只是在他或她写出了这代码的几小时内可以。为什么会这样？因为没有经过代码测试(上面说的)和缺乏正确的编程规范。

下面的文章给你描述了一个最小的应该遵守的规范合集。如果按照这些指导原则，你将能编写出更简洁和漂亮的代码。作为附加效应，你的程序会变得可读性更好，更容易的被你和任何其他人修改。

那就去传阅这这些资料吧。从坐在你身边的人开始。也许在下一次程序员沙龙或编程大会的时候，也已经成为一名Python编程高手了！

祝你学习旅途顺利。

如果你喜欢这些文章，请在微博上顶一下，让其他人也知道。

本文转自：http://www.aqee.net/2011/06/23/how-to-become-a-proficient-python-programmer/

Sina App Engine 与 Google App Engine

Wed, 22 Jun 2011 08:44:00 +0000

新浪推出了自己的云计算服务平台，和Google一样，都叫App Engine。

根据NIST的定义，Google App Engine属于PaaS平台型服务，那么它具体提供什么样的服务，新浪推出的Sina App Engine和Google的又有哪些区别呢？

背景

云计算服务在Google、Amazon等公司成功产品的引领下，正在商业化的道路上大步向前。在NIST的定义中，有三种云计算服务模型。

Software as a Service (SaaS)：软件即服务模型，用户直接使用构建在云端的软件。例如，Google Docs, Salesforce.com
Platform as a Service (PaaS)：平台即服务模型，用户使用云平台所支持的语言和工具，开发应用并部署在云平台。例如，Google App Engine, Force.com
Infrastructure as a Service (IaaS)：基础架构即服务模型，提供处理器、存储、网络等（虚拟）硬件资源给用户，用户可任意安装软件和开发环境，包括安装操作系统。例如，Amazon EC2, Joyent

可见，三种模型从应用到平台再到架构，越来越底层，用户得到的可操作性和灵活性也越来越大。

Google App Engine是什么？

Google App Engine（GAE）提供一整套开发组件来让用户轻松地在本地构建和调试网络应用，之后能让用户在Google强大的基础设施上部署和运行网络应用程序。配置可随应用的访问量和数据存储需要的增长轻松扩展，使用 GAE，将不再需要维护服务器：只需上传你的应用程序，它便可立即为你的客户提供服务。

简单来说，这和虚拟主机服务类似，只是运行环境不同。虚拟主机支持的是ASP, JSP, PHP等网页应用，而GAE现支持Java、Python和Google自家开发的Go这三种语言开发的应用程序，并为这三种语言提供基本相同的功能和API。

GAE提供大量的免费使用额度和灵活的资费标准。多达 500 MB 的存储空间，以及可支持每月约 500 万页面浏览量的足够的 CPU 和带宽，完全免费。选择付费服务则可按需提高相应配置。

功能支持

网址抓取（URL Fetch）：访问互联网上的资源，抓取检索数据。
邮件（Mail）：GAE可以利用基于Gmail的基础设施来发送电子邮件。
Memcache缓存：高性能的内存缓存保障，对于那些不需要持久性存储和事务功能的数据（例如临时数据或从数据存储区复制到缓存以进行高速访问的数据）很有用。
图像操作（Image Manipulation）：使用该 API，您可以对 JPEG 和 PNG 格式的图像进行缩放、裁剪、旋转和翻转，还能使用预先定义的算法提升图片的质量。
计划任务和任务队列（Scheduled Tasks & Task Queues）：允许将任务计划为按指定间隔运行，这些任务通常称为Cron job。另外可以通过在一个队列插入任务（以Web Hook的形式）来实现后台处理，GAE会根据调度方面的设置来安排这个队列里面的任务执行。

Sina App Engine是什么？

Sina App Engine（SAE），是由新浪公司开发和运营的开放云计算平台。SAE为App开发者提供稳定、快捷、透明、可控的服务化的平台，并且减少开发者的开发和维护成本。和GAE一样，他们都属于PaaS平台型云计算服务。