博客园_Love in coding...

[转]html5之Canvas坐标变换应用-时钟实例

2012-02-08T08:34:00Z

本文转自：http://www.cnblogs.com/whitewolf/archive/2011/03/02/1969398.html

在上一篇中我们了解html5的Canvas ，在这一篇中不用多说，写一个html5的时钟应用程序试手。在这里主要设置了坐标变换的平移（translate）和旋转变换（ratate），以及html5 Canvas的路径绘图，beginPath，closePath，rect，arc等，还有就是html5 Canvas路径绘图重要的绘图状态的保存和恢复机制，save，restore。

多的也不说了，直接上代码，有不解的欢迎提问，以及对我的建议指教都可以，。

ff下效果图：

代码：

<html> 
<head> 
</head> 
<body> 
    <canvas id="myCanvas" width="600" height="300">你的浏览器还不支持哦</canvas> 

    <script type="text/javascript"> 
        var c = document.getElementById("myCanvas"); 
        var cxt = c.getContext("2d"); 
        var slen = 60; 
        var mlen = 50; 
        var hlen = 40; 
        cxt.strokeRect(0, 0, c.width, c.height); 
        cxt.beginPath(); 
        cxt.strokeStyle = "#00f"; 
        cxt.fillStyle = "#00f"; 
        cxt.arc(200, 150, 5, 0, 2 * Math.PI, true); 
        cxt.fill(); 
        cxt.closePath(); 

        cxt.beginPath(); 
        cxt.strokeStyle = "#00f"; 
        cxt.arc(200, 150, 100, 0, 2 * Math.PI, true); 
        cxt.stroke(); 
        cxt.closePath(); 
        cxt.beginPath(); 
        cxt.translate(200, 150); //平移原点； 
        cxt.rotate(-Math.PI / 2); 
        cxt.save();        
        for (var i = 0; i < 60; i++) { 
            if (i % 5 == 0) { 
                //                cxt.fillStyle = "#ff0000"; 
                cxt.fillRect(80, 0, 20, 5); 
                cxt.fillText("" + (i / 5 == 0 ? 12 : i / 5), 70, 0); 
            } else { 
               // cxt.strokeStyle = "#00f"; 
                cxt.fillRect(90, 0, 10, 2); 
            } 
            //document.getElementById("div1").innerText += " " + i; 
            cxt.rotate(Math.PI / 30); 
        } 
        cxt.closePath(); 

        var ls = 0, lm = 0, lh = 0; 
function Refresh() { 
    cxt.restore(); 
    cxt.save(); 
    cxt.rotate(ls * Math.PI / 30); 
    cxt.clearRect(5, -1, slen+1, 2+2); 
    cxt.restore(); cxt.save(); 

    cxt.rotate(lm * Math.PI / 30); 
    cxt.clearRect(5, -1, mlen+1, 3+2); 
    cxt.restore(); cxt.save(); 

    cxt.rotate(lh * Math.PI / 6); 
    cxt.clearRect(5, -3, hlen+1, 4+2); 

    var time = new Date(); 
            var s = ls=time.getSeconds(); 
            var m = lm=time.getMinutes(); 
            var h = lh=time.getHours();            
            cxt.restore(); 
            cxt.save(); 
            cxt.rotate(s * Math.PI / 30); 
            cxt.fillRect(5, 0, slen, 2); 
            cxt.restore(); cxt.save(); 
            cxt.rotate(m * Math.PI / 30); 
            cxt.fillRect(5, 0, mlen, 3); 
            cxt.restore(); cxt.save(); 
            cxt.rotate(h * Math.PI / 6); 
            cxt.fillRect(5, -2, hlen, 4); 
        } 
        var MyInterval = setInterval("Refresh();", 1000); 
    </script> 
<div id="div1" style=" background:#00f;"></div> 
</body> 
</html>

按 Ctrl+C 复制代码

我的html5系列：

作者：破狼
出处：http://www.cnblogs.com/whitewolf/
本文版权归作者和博客园、CSDN共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。该文章也同时发布在我的独立博客中-博客园--破狼和CSDN--野狼。

本文链接

[转]利用 Ant 和 Eclipse 有效地提高部署工作效率

2012-02-08T06:34:00Z

本文转自：http://www.ibm.com/developerworks/cn/java/j-lo-ant-eclipse/

读者定位为具有 Java 和 Ant 使用经验的开发人员。

读者可以学习到如何使用 Ant 解决一些多用户开发环境中，根据不同的目标环境编译成不同部署包的问题。

工作场景

现在有一个 web 项目，是多人进行开发的，通过 CVS 来管理。另外该项目还有一些测试人员，他们测试部署在测试服务器上的应用程序，发现 bug 后通过 bug 管理系统通知开发人员，在开发人员修复 bug 并经过本地测试后，由专门的人负责检出（check out）代码，编译打包后部署到测试服务器上。

该项目的成员小 A 就是负责检出代码、编译打包，并部署到服务器上的人。除了这个任务之外，他还是该项目的编程人员。在项目进入测试阶段后，小 A 在得到组中别的成员修复了 bug 并且检入（check in）了代码的消息后（也有可能是小 A 自己检入了代码），小 A 首先更新本地的代码，先在本地做测试，确认修复了 bug 后打成 WAR 包部署到测试服务器上，并通知测试人员已经修复了 bug，让测试人员继续进行测试。

小 A 的烦恼

在该项目中，有一些为测试方便开发而写的代码和页面，比如跳过用户认证，但是在部署到测试机环境的时候，需要删除这些代码和页面；另外作为一个具有灵活性和扩展性的应用程序，又有一些配置文件，配置文件中的值会根据环境的改变而变动。例如，在项目中使用了 Log4j 记录日志，需要给 Log4j 指定日志文件的保存路径，本地程序员开发的时候用的是 Windows 系统，给 Log4j 指定的也是 Windows 的文件系统，在测试阶段的时候，需要部署到 Linux 系统中，那么日志的保存路径也需要做相应的改动。部署到测试服务器上的时候，除了 Log4j 需要改之外，还有很多别的配置项目也需要变动，并且分散在各个 package 中。小 A 的烦恼也随之而来，每次他在做完本地测之后，就根据测试机的需要逐个找配置文件，更改相应的值，并删除那些为测试方便写的代码和页面，每天可能根据需要做好几次这样的事情，最烦的是他在快做完对测试机环境更改的时候，某开发人员突然通知小 A 说：“我又改了一点代码，刚检入，你再重打一个包吧。”，小 A 又不得不从头开始做新一轮的检出代码、本地测试、更改配置文件、删除不需要的文件、打包部署的工作。另外小 A 在测试阶段的后期被通知要求除了每次生成一个测试环境的 WAR 包外还必须生成一个在产品环境下的 WAR 包，他做的事情就更多了。

从上面的场景可以看出，小 A 的工作效率低而且容易出错，甚至有可能导致整个项目的工作效率低下。其实可以通过 Ant 来帮助小 A 快速而且有效地完成这个工作。在 Ant 中，根据目标环境的需要，可以把所有要更改的配置文件的项目集中写到某个配置文件中。这样根据不同的目标环境得到不同的配置文件，Ant 在编译包时根据不同的目标环境切换不同的配置文件即可。比如小 A 现在碰到的有 3 中环境：开发环境、测试环境以及产品环境，根据这三种环境可以生成三个不同的配置文件：develop_deploy.property、test_deploy. property 和 product_deploy. property，当小 A 想生成不同的包时只需在这三个配置文件之间切换就可以了。

在正式开始编写脚本之前，我们需要下载安装相应的软件。

Eclipse：为了使 Ant 的开发更加简单，我们选择了 Eclipse3.1 作为开发环境。当然你可以使用任何你喜欢的文本编辑工具来开发你的 Ant。Eclipse 的最新版本可以在 http://eclipse.org/上下载。
Ant：Ant 是基于 Java 的编译工具，它就像 C/C++ 中的 make，但是没有 make 那样难用。Ant 的最新版本可以在 http://ant.apache.org/bindownload.cgi上下载。如果你用 Eclipse 来开发 Ant，则不用去单独下载 Ant，因为在 Eclipse 中已经集成了 Ant。
CVS 客户端（cvs.exe）：CVS 可以在 http://www.nongnu.org/cvs/上下载

用 Eclipse3.1 来创建 Ant 脚本

如果你使用 Eclipse 来编写 Ant，建议使用 Eclipse 3.1 以后的版本。除了以前 Ant 编辑器提供的语法高亮，提示语法错误等功能外，Eclipse3.1 版本增加了许多新的功能。比如：脚本代码的折叠；快速定位某属性或者目标（target）段的定义；在同一 builder 文件中重构属性名和目标名（快捷方式 Alt + Shift +R）；调试 Ant 脚本等。

下面我们就来看看 Eclipse 3.1 中对 Ant 的支持

打开“File”－“New”－“Project”－“Simple”－“Project”，点击“Next”，输入工程名“Ant”，然后点击直到“Finish”

在新建的 Ant 工程中，新建 Test.xml，并且拷贝下面的脚本。该段脚本的内容就不做介绍了，我们主要看 Eclipse 提供了哪些功能。注意这时候打开的并不是 Ant 编辑器，将内容拷贝进去之后，关掉打开的“Test.xml”，然后再重新打开它，这样 Eclipse 就会用 Ant 编辑器打开它，并且也语法高亮了。

<?xml version="1.0" encoding="UTF-8"?> 
 <project name="Test" default="init" basedir="."> 
 <property name="test" value="test"/> 
 <target name="init"> 
	 <echo>${test}</echo> 
 </target> 
 </project>

自动提示和代码折叠功能。如果是 Ant 内置的命令或者前面已经定义的变量，编辑器会自动提示；编辑器右边的加 / 减号可以代码折叠。如下所示：
快速定位目标（target）或者定义变量处。在上图中，将鼠标移至 default=”init” 中的 init 上之后，按下 ctrl 键，鼠标变成手状，单击就可以定位到定义该目标的地方
快速重构目标名或者属性名。选中目标 / 属性名，按下 Alt + Shift + R，然后键入你要修改后的值，所有引用到的地方都会随之改动。如下图所示，选中 init 后，按下快捷键，改成 initial：
调试 Ant 脚本。在标签“<target name=..”的左边设置一断点，然后在编辑器中右击，出现的菜单中选“Debug As”－“Ant Build”，出现后的窗口与调试 Java 程序的界面差不多。

这是调试窗口，这里可以选择单步跟进、跳出等：

下面是运行时变量窗口。可以看到 test 变量的值是“test”：

运行结果窗口：

由此可见，如果使用好 Eclipse Ant 编辑器所提供强大的功能的话能大大提高写 Ant 脚本的效率。

Ant 中使用 property（属性）文件

刚开始写 Ant 的初学者可能会把所有的信息都放在 build.xml 中，下面就是这样的一个例子。

<project name="testBuild" default="compile" basedir="."> 
 <target name="init"> 
	 <mkdir dir="c:/temp/dest/testProj" /> 
 </target> 
 <target name="compile" depends="init"> 
	 <javac srcdir="c:/temp/src/testProj" destdir="c:/temp/dest/testProj "/> 
 <echo>Build into c:/temp/dest/testProj, successfully.</echo> 
 </target> 
 </project>

在上面的例子中，所有的路径信息都是写在 build.xml 中。但是 Ant 脚本可能在不同的机器或者不同的系统上运行，也有可能一些值需要根据环境的不同而变化，在 Ant 中可以把所有这些可能变化的地方都放到一个配置文件中，然后在 Ant 脚本中引用这个配置文件就可以了，针对上面的例子，如下所示：

<project name="testBuild" default="compile" basedir="."> 
	 <property file="build.properties"/> 
	 <target name="init"> 
		 <mkdir dir="${dest.dir}" /> 
	 </target> 
	 <target name="compile" depends="init"> 
		 <javac srcdir="${src.dir}" destdir="${dest.dir}"/> 
		 <echo>Build into ${dest.dir}, successfully.</echo> 
	 </target> 
 </project> 
 build.properties 的内容：
 dest.dir=c:/temp/dest/testProj 
 src.dir=c:/temp/src/testProj

如果想在 Ant 脚本中引用值的话，只需用 $ 符号开头，在一对"{}"中写入要引用的键值。如上例中，需要引用编译的目标路径用"${dest.dir}"。

使用 Ant 任务从 CVS 中检出（check out）源代码，并编译打包

Ant 中提供了 cvs 任务（Task）可以从 CVS 服务器中检出资源（注意：在使用 Ant 的 cvs 任务之前，请先将 cvs.exe 下载到你的机器，并且将它添加到你本地的 PATH 环境变量中，然后重新启动 Eclipse。否则在执行下面脚本的时候就会得到 error=2 的错误）。cvs 的可选用属性很多，在这里介绍经常使用到的几个属性。从 CVS 中检出资源一般需要指定：

CVS 所在的服务器地址：目标 CVS 服务器地址
用户名：登录该 CVS 服务器你指定的用户名
密码：登录该 CVS 服务器需要的密码
库路径（Repository Path）：服务器中的库路径
模块名：当前需要检出的模块名，一般都是以工程的名字作为模块名
标签名：需要从 CVS 中检出哪个标签

在介绍使用 Ant 的 cvs 之前，先说一下本地的目录结构。在 C 盘的 temp 目录下，分别有四个目录，如下所示：

build 目录：放编译后的类以及资源文件
dist 目录：放生成的 jar 文件或者 war 文件
lib 目录：放在编译过程中需要用到的 jar 文件
src 目录：放从 cvs 中检出的源文件（包括 JSP 等）

在 Ant 中这样写就可以从中检出资源：

<cvs cvsRoot=":pserver:username:pwd@cvs.server:/home/testPath" 
 package="TestProj" dest=" c:/temp/src/testProj " failonerror="true" />

这段脚本片断的意思就是从叫"cvs.server"的服务器中，用用户名是 username、密码为 pwd 的用户检出在库路径是 /home/testPath 下的 TestProj 模块（项目），检出后的资源放入本地目录 c:/temp/src/testProj 中。在上面这段脚本中，可以看到有很多值可能会根据不同的环境或者用户随之改变的，比如用户名和密码等；而且从脚本的重复可利用性来说，需要把有些值抽出来放到配置文件中，如服务器的地址和库路径等。因此把这些可能需要更改的地方放到 property 文件中，效果会更好。改完后的完整 Ant 脚本如下所示：

<?xml version="1.0"?> 
 <project name="testWeb" default="checkout" basedir="."> 
	 <target name="checkout"> 
		 <property file="TestWeb.properties" /> 
		 <cvs cvsRoot="${cvs.root}" package="${cvs.projectName}" 
 tag="${cvs.tag}" dest="${src.dir}" failonerror="true" /> 
	 </target> 
 </project>

对应的 TestWeb.properties 文件内容如下所示：

base.dir=c:/temp/ 
 src.dir=${base.dir}/src 

 cvs.server=cvs.server 
 cvs.user=username 
 cvs.pw=pwd 
 cvs.repositoryPath=/home/testPath 
 cvs.projectName=TestProj 
 cvs.root=:pserver:${cvs.user}:${cvs.pw}@${cvs.server}:${cvs.repositoryPath} 
 cvs.tag=

在检出了资源后，需要对其进行编译打包。为了使 Ant 脚本更加具有可读性和灵活性，我们需要对上面的 Ant 脚本进行一些改动。首先将 Ant 脚本中进行分段，如下所示：

<?xml version="1.0"?> 
 <project name="testWeb" default="all" basedir="."> 
	 <target name="all" depends="init,clean,checkout,build"> 
    <!-- 脚本的入口点 --> 
	 </target> 
	 <target name="init"> 
    <!-- 做初始化属性文件和设置 classpath 等设置初始条件 --> 
	 </target> 
	 <target name="clean"> 
     <!-- 删除上一次留下的没用的目录和文件 --> 
	 </target> 
	 <target name="checkout"> 	
     <!-- 从 CVS 中检出资源 --> 
	 </target> 
	 <target name="build"> 
     <!-- 编译源文件并打包到指定的目录 --> 
	 </target> 
 </project>

上面的脚本中，总共分成了 5 个目标（target），脚本的入口点是"all"，all 按顺序调用 init，clean，checkout，build。其中：

init 是用来做初始化属性文件和设置 classpath 等设置初始条件的事情
clean 用来删除上一次留下的没用的目录和文件
checkout 已经介绍过了，是用来从 CVS 中检出资源
build 用来编译源文件并打 WAR 包到指定的目录

详细的 Ant 脚本可以参见随本文所附的 TestWeb.xml 和 TestWeb.properties。

编译过程与产生不同目标环境的脚本分开执行

在前面介绍的 Ant 脚本中，根据从 CVS 服务器中检出的资源打成了一个默认的 war 包，并没有考虑根据不同的目标环境来生成不同的包，从下一节开始介绍如何根据不同的环境来生成不同的部署包。

还有一个问题是：为什么需要把从 CVS 中检出资源、编译的过程跟根据目标环境打包的过程分开？

这是因为本身 CVS 检出资源是需要花一定的时间，如果资源比较多这个过程就会花费挺长时间；另外，在多人开发的情况下必须保证在生成不同的部署包的时候是用的是同一套代码生成的，否则会出现各个服务器上运行的版本不一致，如果检出资源、编译的过程跟生成包的脚本一起执行的话就会出现这个问题（比如小 A 在测试服务器测试通过的时候之后，再生成一个在产品环境下的部署包，如果分两次从 CVS 服务器中检出资源的话，在此期间可能会有开发人员往 CVS 服务器中检入代码，导致生成的版本不一致），因此，必须将这两个过程分开执行。现在我们开始建立另外一个 Ant 脚本文件，叫 deploy.xml，专门用来生成包；另外与 deploy.xml 相对应的还有一个 deploy.properties 文件。在 deploy.xml 中会引用 deploy.properties 文件。另外根据在前面的场景中碰到的环境，创建三个不同的属性文件 , develop_deploy.property、test_deploy. property 和 product_deploy. Property，在打包的时候，根据不同的目标环境，将相应属性文件中的内容拷贝至 deploy.properties 文件中（或者也可以直接在 deploy.xml 中直接切换不同的属性文件），然后在 Eclipse 中直接执行 deploy.xml；如果在命令行中，可以用下面的命令来执行：

ant – f deploy.xml

解开 WAR 包

我们首先得建立一个目录（这里是 unpack）用来存放解压后的文件。Ant 中提供了 unzip 命令用来解压 ear/war/jar 包。除了这个目录外，根据不同的目标环境，在运行目录下建立一个与目标环境相对应的目录，重新打好的 war 包就放在这个目录下，比如针对场景中的情况，如果需要创建一个产品环境下的部署包，我们可以建立一个 TestWebProduct 目录，目录名写在配置文件中（${pack.base.dir}）。

<target name="init"> 
    <echo>init in deploy</echo> 
    <property file="deploy.properties" /> 
    <delete dir="${unpack.base.dir}" failonerror="false" /> 
    <delete dir="${pack.base.dir}" failonerror="false" /> 
    <mkdir dir="${unpack.base.dir}" /> 
    <mkdir dir="${pack.base.dir}" /> 
</target> 

<target name="unpack"> 
    <echo>unpack the ${war.name}</echo> 
    <copy file="${dest.dir}/${war.name}" todir="${unpack.base.dir}" />
    <unzip src="${unpack.base.dir}/${war.name}" 
        dest="${unpack.base.dir}/${projectName}" /> 
    <delete file="${unpack.base.dir}/${war.name}" /> 
</target>

在 init 段中首先删除掉上次解压的目录和目标打包目录，然后重新建立目录；在 unpack 中，首先将编译好的默认 war 包拷贝至 unpack 定义的目录，解压之后把 unpack 下的 war 包删除。下面是这时候对应的属性文件。

projectName=MTSWeb 
 war.name=MTSWeb.war 

 # 根目录
 base.dir=c:/temp 
 # 默认的 war 包所在的目录
 dest.dir=${base.dir}/dist 
 # 解压后的目录
 unpack.base.dir=${base.dir}/unpack 
 # 目标环境相对应的目录
 pack.base.dir=${base.dir}/TestWebProduct

利用 Ant 提供的 filter 任务替换属性值

现在根据不同环境的需要，对某些配置文件的值做一些替换。在 Ant 中，提供了 filter 任务，使得替换值很方便。当然也可以使用下面介绍的正则表达式来替换属性值。filter 主要用来在同一行内容中的替换，而正则表达式一下子可以替换多行内容。filter 的使用例子：

<filter token=" log4j.logger" value="INFO"/> 
  <copy todir="${dest.dir}" filtering="true"> 
    <fileset dir="${src.dir}"/> 
  </copy>

这段脚本的意思就是在 src.dir 目录下的所有文件中，如果有预先定义好的"@log4j.logger@"占位符的话，在拷贝到 dest.dir 目录后，所有的占位符都被替换成了"INFO"。

你也可以将所有被替换的值放到某个属性文件中，filter 任务将属性文件中的每一个条目读出来并且设置成一个 Filter。如下所示：

<filter filtersfile="deploy_env.properties"/> 
  <copy todir="${dest.dir}" filtering="true"> 
    <fileset dir="${src.dir}"/> 
  </copy>

上面的脚本表示所有在 deploy_env 中出现的条目将被作为一个 filter，在拷贝到 dest.dir 目录后，所有 src.dir 目录中存在的占位符将被替换成 deploy_env 中的值。具体的例子可以参见随本文附带的 deploy.xml， deploy_env.properties 和 Test.properties。

其中 deploy.xml 是 ant 脚本，deploy_env.properties 中包含所有要替换的值，在 Test.properties 中是包含有占位符的资源文件。

利用正则表达式替换属性值

Ant 中支持多种正则表达式，在运行 Ant 的时候用哪种正则表达式可以通过设置 ant.regexp.regexpimpl 的值来切换，Ant 支持的的正则表达式有：

java.util.regex package of JDK 1.4
jakarta-regexp
installation dependencies

正则表达式的例子：

<replaceregexp byline="true"> 
 <regexp pattern="正则表达式"/> 
 <substitution expression="将要替换的值"/> 
 <fileset dir="${unpack.war.dir}/WEB-INF" includes="web.xml"/> 
 </replaceregexp>

byline 属性用来确认被替换的时候是一次替换一行还是多行；pattern 属性用来指明正则表达式；substitution expression 中是替换的值，替换的值都定义在相对应的配置文件中；fileset 属性中的 dir 用来指定被替换文件所在的目录，includes 用来指定要替换哪个文件。需要注意的是，如果在正则表达式或者替换的值中出现"<"的话，需要用转义符"<"。

在 Eclipse3.1 中已经内置了对正则表达式的支持；但是如果你在命令行中运行需要正则表达式支持的脚本的话，则需要自己将正则表达式的包下载下来加到 classpath 中。在随文章的 deploy.xml 中提供了一个简单的替换属性文件的值的例子。正则表达式的例子可以在本文所带的 deploy.xml 中找到。

Ant 使用条件表达式，根据属性值删除不需要的文件

在生成部署包的时候，还有可能会根据目标环境的不同，删除一些不同的文件。比如在产品环境中那些作为测试需要的代码往往需要删除，但是测试环境中并不需要。因此就需要条件表达式来做判断。如下所示：

<target name="checkTestEnv"> 
	 <condition property="isTestEnv"> 
		 <istrue value="${deploy.isTestEnv}" /> 
	 </condition> 
	 <antcall target="trueCondition" /> 
	 <antcall target="falseCondition" /> 
 </target> 
 <target name="trueCondition" if="isTestEnv"> 
	 <echo message="true condition in ${projectName}" /> 
 </target> 
 <target name="falseCondition" unless="isTestEnv"> 
	 <echo message="false condition in ${projectName}" /> 
 </target>

在上面的例子中，先读出 ${deploy.isTestEnv} 的值（在配置文件 deloy.properties 中），根据读出的值对属性 isTestEnv 设值，如果 ${deploy.isTestEnv} 的值是 true，isTestEnv 的值也是 true；否则是 false。然后分别调用目标段 trueCondition 和 falseCondition。在这里，表达式值的判断是用"istrue"，在 Ant 中还提供了很多别的表达式，比如 not/and/or，equals 等等，具体关于条件表达式的信息可以参考：http://ant.apache.org/manual/CoreTasks/condition.html，该页也可以在随下载下来的文档中找到。

在段 trueCondition 中，判断 isTestEnv，如果是真的话就运行，否则不运行；在段 falseCondition 中，也判断 isTestEnv，如果是假就运行，否则不运行，在段中可以根据情况做相应的事情。条件判断式的例子可以在本文的 deploy.xml 中找到。

重新打包，并拷贝到不同的目录

在上面的替换过程完成后，调用 war 将 unpack 目录下的内容重新打包。

<target name="repack"> 
	 <war destfile="${pack.base.dir}/${projectName}.war" 
		 basedir="${unpack.base.dir}/${projectName}"
		 webxml="${unpack.base.dir}/${projectName}/WEB-INF/web.xml" 
		 manifest="${unpack.base.dir}/${projectName}/META-INF/MANIFEST.MF"> 
	 </war> 
 </target>

详细的例子可以参见随本文的附件 deploy.xml 和 deploy.properties。

结论

通过本文可以看出编写好有效的 Ant 脚本能很好的解决在编译部署包的时候出现的问题，将那些变化的内容放到配置文件中，在部署的时候切换不同的配置文件就可以实现生成不同的部署包。文中也介绍了如何使用 Eclipse 来提高你编写 / 调试 Ant 脚本的效率。

本文链接

[转]Eclipse之ANT使用

2012-02-08T05:57:00Z

本文转自：http://abc.zxj-001.blog.163.com/blog/static/25693412010101611444230/

Ant是Java平台下非常棒的批处理命令执行程序，能非常方便地自动完成编译，测试，打包，部署等等一系列任务，大大提高开发效率。如果你现在还没有开始使用Ant，那就要赶快开始学习使用，使自己的开发水平上一个新台阶。

　　Eclipse中已经集成了Ant，我们可以直接在Eclipse中运行Ant。

　　以前面建立的Hello工程为例，创建以下目录结构：

　　新建一个build.xml，放在工程根目录下。build.xml定义了Ant要执行的批处理命令。虽然Ant也可以使用其它文件名，但是遵循标准能更使开发更规范，同时易于与别人交流。

　　通常，src存放Java源文件，classes存放编译后的class文件，lib存放编译和运行用到的所有jar文件，web存放JSP等web文件，dist存放打包后的jar文件，doc存放API文档。

　　然后在根目录下创建build.xml文件，输入以下内容：

＜?xml version="1.0"?＞
＜project name="Hello world" default="doc"＞

＜!-- properies --＞
＜property name="src.dir" value="src" /＞
＜property name="report.dir" value="report" /＞
＜property name="classes.dir" value="classes" /＞
＜property name="lib.dir" value="lib" /＞
＜property name="dist.dir" value="dist" /＞
＜property name="doc.dir" value="doc"/＞

＜!-- 定义classpath --＞
＜path id="master-classpath"＞
＜fileset file="${lib.dir}/*.jar" /＞
＜pathelement path="${classes.dir}"/＞
＜/path＞

＜!-- 初始化任务 --＞
＜target name="init"＞
＜/target＞

＜!-- 编译 --＞
＜target name="compile" depends="init" description="compile the source files"＞
＜mkdir dir="${classes.dir}"/＞
＜javac srcdir="${src.dir}" destdir="${classes.dir}" target="1.4"＞
＜classpath refid="master-classpath"/＞
＜/javac＞
＜/target＞

＜!-- 测试 --＞
＜target name="test" depends="compile" description="run junit test"＞
＜mkdir dir="${report.dir}"/＞
＜junit printsummary="on"
haltonfailure="false"
failureproperty="tests.failed"
showoutput="true"＞
＜classpath refid="master-classpath" /＞
＜formatter type="plain"/＞
＜batchtest todir="${report.dir}"＞
＜fileset dir="${classes.dir}"＞
＜include name="**/*Test.*"/＞
＜/fileset＞
＜/batchtest＞
＜/junit＞
＜fail if="tests.failed"＞
***********************************************************
**** One or more tests failed! Check the output ... ****
***********************************************************
＜/fail＞
＜/target＞

＜!-- 打包成jar --＞
＜target name="pack" depends="test" description="make .jar file"＞
＜mkdir dir="${dist.dir}" /＞
＜jar destfile="${dist.dir}/hello.jar" basedir="${classes.dir}"＞
＜exclude name="**/*Test.*" /＞
＜exclude name="**/Test*.*" /＞
＜/jar＞
＜/target＞

＜!-- 输出api文档 --＞
＜target name="doc" depends="pack" description="create api doc"＞
＜mkdir dir="${doc.dir}" /＞
＜javadoc destdir="${doc.dir}"
author="true"
version="true"
use="true"
windowtitle="Test API"＞
＜packageset dir="${src.dir}" defaultexcludes="yes"＞
＜include name="example/**" /＞
＜/packageset＞
＜doctitle＞＜![CDATA[＜h1＞Hello, test＜/h1＞]]＞＜/doctitle＞
＜bottom＞＜![CDATA[＜i＞All Rights Reserved.＜/i＞]]＞＜/bottom＞
＜tag name="todo" scope="all" description="To do:" /＞
＜/javadoc＞
＜/target＞
＜/project＞

　　以上xml依次定义了init（初始化），compile（编译），test（测试），doc（生成文档），pack（打包）任务，可以作为模板。

　　选中Hello工程，然后选择“Project”，“Properties”，“Builders”，“New…”，选择“Ant Build”：

　　填入Name：Ant_Builder；Buildfile：build.xml；Base Directory：${workspace_loc:/Hello}（按“Browse Workspace”选择工程根目录），由于用到了junit.jar包，搜索Eclipse目录，找到junit.jar，把它复制到Hello/lib目录下，并添加到Ant的Classpath中：

　　然后在Builder面板中钩上Ant_Build，去掉Java Builder：

　　再次编译，即可在控制台看到Ant的输出：

Buildfile: F:\eclipse-projects\Hello\build.xml

init:

compile:
[mkdir] Created dir: F:\eclipse-projects\Hello\classes
[javac] Compiling 2 source files to F:\eclipse-projects\Hello\classes

test:
[mkdir] Created dir: F:\eclipse-projects\Hello\report
[junit] Running example.HelloTest
[junit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.02 sec

pack:
[mkdir] Created dir: F:\eclipse-projects\Hello\dist
[jar] Building jar: F:\eclipse-projects\Hello\dist\hello.jar

doc:
[mkdir] Created dir: F:\eclipse-projects\Hello\doc
[javadoc] Generating Javadoc
[javadoc] Javadoc execution
[javadoc] Loading source files for package example...
[javadoc] Constructing Javadoc information...
[javadoc] Standard Doclet version 1.4.2_04
[javadoc] Building tree for all the packages and classes...
[javadoc] Building index for all the packages and classes...
[javadoc] Building index for all classes...
[javadoc] Generating F:\eclipse-projects\Hello\doc\stylesheet.css...
[javadoc] Note: Custom tags that could override future standard tags: @todo. To avoid potential overrides, use at least one period character (.) in custom tag names.
[javadoc] Note: Custom tags that were not seen: @todo
BUILD SUCCESSFUL
Total time: 11 seconds

　　Ant依次执行初始化，编译，测试，打包，生成API文档一系列任务，极大地提高了开发效率。将来开发J2EE项目时，还可加入部署等任务。并且，即使脱离了Eclipse环境，只要正确安装了Ant，配置好环境变量ANT_HOME=＜Ant解压目录＞，Path=…;%ANT_HOME%\bin，在命令行提示符下切换到Hello目录，简单地键入ant即可

本文链接

[转]搭建Windows下Java Web开发环境

2012-02-08T03:19:00Z

本文转自：http://hi.baidu.com/surgeon/blog/item/26e4e2fee117a2365c60082e.html

概要
1．SSH开发相关软件及开发包下载
2．软件安装及相关设置
3．最简单的Web程序

1.软件下载
在Ｄ盘建一个目录JavaTools，用来存放下载的软件和开发包。（本教程将使用D盘，你也可以使用C盘或E盘）。下载软件的原则，有Zip版的不下载exe版的。
1）JDK：JDK 6 Update 7 Windows版
下载页面：http://java.sun.com/javase/downloads/index.jsp
下载链接：
https://cds.sun.com/is-bin/INTERSHOP.enfinity/WFS/CDS-CDS_Developer-Site/en_US/-/USD/ViewFilteredProducts-SingleVariationTypeFilter;pgid=yYdgaHqkkjVSR0EUPIQsoQ3D0000o_tQgoGy;sid=AeftgEasIkTtgQ4qZlGlhakFzl2YCYvpVAUiQVuyc5IGAw==
更多信息：http://java.sun.com
2）IDE：Eclipse IDE for Java EE Developers
下载页面：
http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/ganymede/R/eclipse-jee-ganymede-win32.zip
下载链接：
http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/ganymede/R/eclipse-jee-ganymede-win32.zip&url=http://download.actuatechina.com/eclipse/technology/epp/downloads/release/ganymede/R/eclipse-jee-ganymede-win32.zip&mirror_id=385
更多信息：http://www.eclipse.org/
3）Web Server：Tomcat 6.0.16
下载页面：
http://tomcat.apache.org/download-60.cgi
下载链接：
http://www.meisei-u.ac.jp/mirror/apache/dist/tomcat/tomcat-6/v6.0.16/bin/apache-tomcat-6.0.16.zip
更多信息：
http://tomcat.apache.org/
4）Database：MySQL-5.0 Without installer
下载页面：
http://dev.mysql.com/downloads/mysql/5.0.html#win32
下载链接：
http://dev.mysql.com/get/Downloads/MySQL-5.0/mysql-noinstall-5.0.51b-win32.zip/from/pick#mirrors
更多信息：
http://dev.mysql.com/
5）Database GUI客户端
下载页面：
http://dev.mysql.com/downloads/gui-tools/5.0.html
下载链接：
http://dev.mysql.com/get/Downloads/MySQLGUITools/mysql-gui-tools-noinstall-5.0-r12-win32.zip/from/pick#mirrors
6）Eclipse插件
6.1) Sysdeo Eclipse Tomcat Launcher plugin
下载链接：
http://www.eclipsetotale.com/tomcatPlugin/tomcatPluginV321.zip
更多信息：
http://www.eclipsetotale.com/tomcatPlugin.html
7）开发包
7.1）Struts 2.1.2
下载链接：
http://www.meisei-u.ac.jp/mirror/apache/dist/struts/binaries/struts-2.1.2-all.zip
下载页面：
http://struts.apache.org/download.cgi#struts212
更多信息：
http://struts.apache.org/
7.2）Spring Framework 2.5.5
下载链接：
http://downloads.sourceforge.net/springframework/spring-framework-2.5.5-with-dependencies.zip?modtime=1214221252&big_mirror=0
下载页面：
http://www.springframework.org/download
更多信息：
http://www.springframework.org/
7.3) Hibernate
下载页面：http://www.hibernate.org/6.html
Hibernate Core 3.2.6 GA
下载链接：
http://sourceforge.net/project/showfiles.php?group_id=40712&package_id=127784&release_id=574498
Hibernate Annotations 3.3.1 GA
下载链接：
http://sourceforge.net/project/showfiles.php?group_id=40712&package_id=139933
Hibernate Tools3.2.2 Beta
下载链接：
http://sourceforge.net/project/downloading.php?groupname=jboss&filename=HibernateTools-3.2.2.Beta1.zip&use_mirror=osdn
Hibernate Validator 3.0.0 GA
下载链接：
http://sourceforge.net/project/showfiles.php?group_id=40712&package_id=225206
7.4) FreeMarker 2.3.13
下载链接：
http://prdownloads.sourceforge.net/freemarker/freemarker-2.3.13.tar.gz
更多信息：
http://www.freemarker.org/
下载后的JavaTools的内容如下：
D:\JavaTools\apache-tomcat-6.0.16.zip
D:\JavaTools\eclipse-jee-ganymede-win32.zip
D:\JavaTools\freemarker-2.3.13.tar.gz
D:\JavaTools\hibernate-3.2.6.ga.zip
D:\JavaTools\hibernate-annotations-3.3.1.GA.zip
D:\JavaTools\HibernateTools-3.2.2.Beta1.zip
D:\JavaTools\hibernate-validator-3.0.0.GA.zip
D:\JavaTools\jdk-6u7-windows-i586-p.exe
D:\JavaTools\mysql-gui-tools-noinstall-5.0-r12-win32.zip
D:\JavaTools\mysql-noinstall-5.0.51b-win32.zip
D:\JavaTools\spring-framework-2.5.5-with-dependencies.zip
D:\JavaTools\struts-2.1.2-all.zip
D:\JavaTools\tomcatPluginV321.zip
（注：其它的软件和开发包在开发中用到时再下载，如jQuery）
2.安装设置
1）安装JDK
双击jdk-6u7-windows-i586-p.exe安装JDK
不安装公共JRE和JavaDB，安装到D:\，如图示。

安装完成后，在Window环境变量的系统变量中添加JAVA_HOME，其值为D:\jdk1.6.0_07，在Path环境变量的前面加上%JAVA_HOME%\bin;（分号不要掉了）。
2）安装Eclipse
将D:\JavaTools\eclipse-jee-ganymede-win32.zip解压到D:\eclipse，改名为D:\eclipse3.4.0。
右键单击D:\eclipse3.4.0\eclipse.exe，发送到桌面一个快捷方式，将快捷方式改名为eclipse3.4.0.exe。
将D: \JavaTools\tomcatPluginV321.zip解压到D:\JavaTools\tomcatPluginV321\，将里面的 com.sysdeo.eclipse.tomcat_3.2.1目录及内容复制到D:\eclipse3.4.0\dropins目录下。
启动Eclipse，注意将workspace设置到eclipse3.4.0目录下，并设为默认。见下图。

如果正常，进去后在工具条上会看到

退出Eclipse。
3）安装Tomcat
将D:\JavaTools\apache-tomcat-6.0.16.zip解压到D:\apache-tomcat-6.0.16，改名为D:\tomcat-6.0.16。
执行D:\tomcat-6.0.16\bin\startup.bat启动Tomcat。
在浏览器中查看http://localhost:8080/
正常的话可以看到Tomcat的页面。
关闭浏览器窗口，关闭Tomcat控制台窗口。
4）安装MySQL
将D:\JavaTools\mysql-noinstall-5.0.51b-win32.zip解压到D:\mysql-5.0.51b-win32，改名为
D:\mysql-5.0.51b。
执行D:\mysql-5.0.51b\bin\mysqld-nt.exe启动mysql。
将D:\JavaTools\mysql-gui-tools-noinstall-5.0-r12-win32.zip解压到D:\MySQL GUI Tools 5.0\。
执行D:\MySQL GUI Tools 5.0\MySQLQueryBrowser.exe启动客户端。
正常情况下OK进去以后，可以访问数据库。
（注：为了访问方便，可以建立以上可执行文件的快捷方式）
3.Hello Java Web
1）建立Web工程
建立目录D:\Project用来放工程。
启动Eclipse。
菜单Window-->Preferences-->Tomcat。
Tomcat version，Tomcat home和Context declaration mode的选择如下图所示。

OK保存。
菜单File-->New-->Project…-->Java-->Tomcat Project，下一步，Project name填Bitrac。
Use default location取消，然后选择D:\Project如下图所示

Location后面要加上\Bitrac。
下一步，设置WebRoot，见下图

Finish完成工程创建。
正常的话会转到Java视图，可以在Eclipse中看到如下图所示的工程结构。

在Eclipse中右键单击WebRoot/WEB-INF/src，delete删除这个目录。
在Bitrac 上点右键，快捷菜单中选择Tomcat project-->Update context definition，成功后，会看到D:\tomcat-6.0.16\conf\Catalina\localhost下面有个Bitrac.xml 文件。
在Bitrac上点右键，快捷菜单中选择Properties-->Tomcat-->Context name，将Bitrac改成bitrac，再重复上面的步骤Update context definition。
在Bitrac上点右键，快捷菜单中选择Properties-->Resource-->Text file encoding-->Other，选择UTF-8，OK保存。（上述操作实际是打开了工程属性对话框，后面将用这一说法代替）
2）新增文件
选择WebRoot，快捷键Ctrl+N打开新建文件对话框，Web-->Jsp，下一步，文件名填index.jsp，finish完成新建文件。
在新文件的<body></body>之间写上Hello Java Web。
3）运行
点工具条上Tomcat插件按钮中的第一个按钮启动Tomcat。
在浏览器中查看http://localhost:8080/bitrac/
正常的话会看到Hello Java Web，最简单的Java Web程序完成。
4）为复杂的Java Web程序做准备
点Tomcat插件工具条的第二个按钮停止Tomcat。
4.1）将D:\JavaTools\struts-2.1.2-all.zip解压到D:\JavaTools\struts-2.1.2
将下列文件
D:\JavaTools\struts-2.1.2\lib\struts2-core-2.1.2.jar
D:\JavaTools\struts-2.1.2\lib\xwork-2.1.1.jar
D:\JavaTools\struts-2.1.2\lib\commons-fileupload-1.2.1.jar
D:\JavaTools\struts-2.1.2\lib\commons-io-1.3.2.jar
D:\JavaTools\struts-2.1.2\lib\commons-logging-api-1.1.jar
D:\JavaTools\struts-2.1.2\lib\ognl-2.6.11.jar
复制到D:\Project\Bitrac\WebRoot\WEB-INF\lib
4.2）将D:\JavaTools\freemarker-2.3.13.tar.gz解压到D:\JavaTools\freemarker-2.3.13
将D:\JavaTools\freemarker-2.3.13\lib\freemarker.jar复制到
D:\Project\Bitrac\WebRoot\WEB-INF\lib，改名为freemarker-2.3.13.jar
4.3）将D:\JavaTools\spring-framework-2.5.5-with-dependencies.zip解压到
D:\JavaTools\spring-framework-2.5.5
将D:\JavaTools\spring-framework-2.5.5\dist\spring.jar复制到
D:\Project\Bitrac\WebRoot\WEB-INF\lib，改名为spring-2.5.5.jar
4.4）将D:\JavaTools\hibernate-3.2.6.ga.zip解压到D:\JavaTools\hibernate-3.2\
将D:\JavaTools\hibernate-3.2\hibernate3.jar复制到
D:\Project\Bitrac\WebRoot\WEB-INF\lib，改名为hibernate-3.2.6.jar
4.5）将D:\JavaTools\hibernate-annotations-3.3.1.GA.zip解压到
D:\JavaTools\hibernate-annotations-3.3.1.GA\
将D:\JavaTools\hibernate-annotations-3.3.1.GA\hibernate-annotations.jar复制到
D:\Project\Bitrac\WebRoot\WEB-INF\lib，改名为hibernate-annotations-3.3.1.jar
4.6）将D:\JavaTools\hibernate-validator-3.0.0.GA.zip解压到
D:\JavaTools\hibernate-validator-3.0.0.GA
将D:\JavaTools\hibernate-validator-3.0.0.GA\hibernate-validator.jar复制到
D:\Project\Bitrac\WebRoot\WEB-INF\lib，改名为hibernate-validator-3.0.0.jar
打开Bitrac工程属性对话框
Java Build Path-->Libraries-->Add Jars…，将lib下的jar都添加到当前Libraries中。
将D:\JavaTools\struts-2.1.2\apps\struts2-blank-2.1.2.war中的web.xml用winrar解压出来，复制到D:\Project\Bitrac\WebRoot\WEB-INF下。
打开D:\Project\Bitrac\WebRoot\WEB-INF\web.xml
将index.html改为index.jsp，保存。
启动tomcat。

本文链接

[转]修改visual studio 2010 HelpLibrary（MSDN）的路径

2012-02-08T02:39:00Z

本文转自：http://blog.csdn.net/lwj2099/article/details/5727636

今天装了Microsoft Visual Studio 2010,这次的VS2010没有所谓的MSDN,取代的就是HelpLibrary.安装vs2010时没有把HelpLibrary装上，现在想装上，于是打开Help Library管理器，点击“设置”，选择“我要使用本地帮助”，发现库位置为默认C:/ProgramData/Microsoft/HelpLibrary，不能更改，于是只有先按照默认路径安装，点击“确定”。

然后点击“从磁盘安装内容”，再点击“浏览”，选择cn_visual_studio_2010_ultimate_x86_dvd_532347.iso里面ProductDocumentation文件夹里的HelpContentSetup.msha文件，后面选项简单，自己看着点就是了。到此，Help Library按照默认路径安装完成了。

这个文档很大，要想移到其他地方，可以按照下面步骤，比如要移到D:/Program Files/HelpLibrary下：
1、找到C:/ProgramData/Microsoft/HelpLibrary，把HelpLibrary文件夹复制到D:/Program Files/HelpLibrary
2、打开注册表，找到HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Help/v1.0，此处有一个LocalStore的值 .数据就是之前默认保存的路径了.先备份一下,然后替换成自己想要的文件夹路径D:/Program Files/HelpLibrary.
3、找到文件D:/Program Files/HelpLibrary/manifest/queryManifest.3.xml，进行编辑：找到下面两行：
<catalogPath>C:/ProgramData/Microsoft/HelpLibrary/catalogs/VS/100/EN-US</catalogPath>
<contentPath>C:/ProgramData/Microsoft/HelpLibrary/content</contentPath>

将C:/ProgramData/Microsoft改为D:/Program Files即可。

本文链接

[转]Android.mk的用法和基础

2012-02-03T02:27:00Z

本文转自：http://www.cnblogs.com/lilactutu/archive/2010/12/06/1897696.html

一个Android.mk file用来向编译系统描述你的源代码。具体来说：该文件是GNU Makefile的一小部分，会被编译系统解析一次或多次。你可以在每一个Android.mk file中定义一个或多个模块，你也可以在几个模块中使用同一个源代码文件。编译系统为你处理许多细节问题。例如，你不需要在你的Android.mk中列出头文件和依赖文件。NDK编译系统将会为你自动处理这些问题。这也意味着，在升级NDK后，你应该得到新的toolchain/platform支持，而且不需要改变你的Android.mk文件。

先看一个简单的例子：一个简单的"hello world"，比如下面的文件：

sources/helloworld/helloworld.c

sources/helloworld/Android.mk

相应的Android.mk文件会象下面这样：

---------- cut here ------------------

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE

:= helloworld

LOCAL_SRC_FILES := helloworld.c

include $(BUILD_SHARED_LIBRARY)

---------- cut here ------------------

我们来解释一下这几行代码：

LOCAL_PATH := $(call my-dir)

一个Android.mk file首先必须定义好LOCAL_PATH变量。它用于在开发树中查找源文件。在这个例子中，宏函数’my-dir’, 由编译系统提供，用于返回当前路径（即包含Android.mk file文件的目录）。

include $( CLEAR_VARS)

CLEAR_VARS 由编译系统提供，指定让GNU MAKEFILE为你清除许多LOCAL_XXX变量（例如 LOCAL_MODULE, LOCAL_SRC_FILES, LOCAL_STATIC_LIBRARIES, 等等...),除LOCAL_PATH 。这是必要的，因为所有的编译控制文件都在同一个GNU MAKE执行环境中，所有的变量都是全局的。

LOCAL_MODULE := helloworld

LOCAL_MODULE变量必须定义，以标识你在Android.mk文件中描述的每个模块。名称必须是唯一的，而且不包含任何空格。注意编译系统会自动产生合适的前缀和后缀，换句话说，一个被命名为'foo'的共享库模块，将会生成'libfoo.so'文件。

LOCAL_SRC_FILES := helloworld.c

LOCAL_SRC_FILES变量必须包含将要编译打包进模块中的C或C++源代码文件。注意，你不用在这里列出头文件和包含文件，因为编译系统将会自动为你找出依赖型的文件；仅仅列出直接传递给编译器的源代码文件就好。

在Android中增加本地程序或者库，这些程序和库与其所载路径没有任何关系，只和它们的Android.mk文件有关系。Android.mk和普通的Makefile有所不同，它具有统一的写法，主要包含一些系统公共的宏。

在一个Android.mk中可以生成多个可执行程序、动态库和静态库。

1，编译应用程序的模板：

#Test Exe

LOCAL_PATH := $(call my-dir)

#include $(CLEAR_VARS)

LOCAL_SRC_FILES:= main.c

LOCAL_MODULE:= test_exe

#LOCAL_C_INCLUDES :=

#LOCAL_STATIC_LIBRARIES :=

#LOCAL_SHARED_LIBRARIES :=

include $(BUILD_EXECUTABLE)

（菜鸟级别解释：:=是赋值的意思，$是引用某变量的值）LOCAL_SRC_FILES中加入源文件路径，LOCAL_C_INCLUDES 中加入所需要包含的头文件路径，LOCAL_STATIC_LIBRARIES加入所需要链接的静态库（*.a）的名称，LOCAL_SHARED_LIBRARIES中加入所需要链接的动态库（*.so）的名称，LOCAL_MODULE表示模块最终的名称，BUILD_EXECUTABLE表示以一个可执行程序的方式进行编译。

2，编译静态库的模板：

#Test Static Lib

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_SRC_FILES:= \

helloworld.c

LOCAL_MODULE:= libtest_static

#LOCAL_C_INCLUDES :=

#LOCAL_STATIC_LIBRARIES :=

#LOCAL_SHARED_LIBRARIES :=

include $(BUILD_STATIC_LIBRARY)

一般的和上面相似，BUILD_STATIC_LIBRARY表示编译一个静态库。

3，编译动态库的模板：

#Test Shared Lib

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_SRC_FILES:= \

helloworld.c

LOCAL_MODULE:= libtest_shared

TARGET_PRELINK_MODULES := false

#LOCAL_C_INCLUDES :=

#LOCAL_STATIC_LIBRARIES :=

#LOCAL_SHARED_LIBRARIES :=

include $(BUILD_SHARED_LIBRARY)

一般的和上面相似，BUILD_SHARED_LIBRARY表示编译一个静态库。

以上三者的生成结果分别在如下，generic依具体target会变：

out/target/product/generic/obj/EXECUTABLE

out/target/product/generic/obj/STATIC_LIBRARY

out/target/product/generic/obj/SHARED_LIBRARY

每个模块的目标文件夹分别为：

可执行程序：XXX_intermediates

静态库： XXX_static_intermediates

动态库： XXX_shared_intermediates

另外，在Android.mk文件中，还可以指定最后的目标安装路径，用LOCAL_MODULE_PATH和 LOCAL_UNSTRIPPED_PATH来指定。不同的文件系统路径用以下的宏进行选择：

TARGET_ROOT_OUT：表示根文件系统。

TARGET_OUT：表示system文件系统。

TARGET_OUT_DATA：表示data文件系统。

用法如：

CAL_MODULE_PATH:=$(TARGET_ROOT_OUT)

本文链接

[转]Android JNI使用方法

2012-02-03T02:18:00Z

本文转自：http://www.open-open.com/lib/view/open1324909652374.html

经过几天的努力终于搞定了android JNI部分，下面将我的这个小程序和大家分享一下。android JNI是连接android Java部分和C/C++部分的纽带，完整使用JNI需要Java代码和C/C++代码。其中C/C++代码用于生成库文件，Java代码用于引用C /C++库文件以及调用C/C++方法。

android Java部分代码：

`01`	`jnitest.java`

02

`03`	`package` `com.hello.jnitest;`

04

05

06

`07`	`import` `android.app.Activity;`

08

`09`	`import` `android.os.Bundle;`

10

11

12

`13`	`public` `class` `jnitest` `extends` `Activity {`

14

`15`	`/** Called when the activity is first created. */`

16

`17`	`@Override`

18

`19`	`public` `void` `onCreate(Bundle savedInstanceState) {`

20

`21`	`super.onCreate(savedInstanceState);`

22

`23`	`setContentView(R.layout.main);`

24

`25`	`Nadd test =` `new` `Nadd();`

26

`27`	`setTitle("The Native Add Result is "+String.valueOf(test.nadd(10,` `20)));`

28

29 }

30

31 }

32

`33`	`Nadd.java`

34

`35`	`package` `com.hello.jnitest;`

36

37

38

`39`	`public` `class` `Nadd {`

40

`41`	`static` `{`

42

`43`	`System.loadLibrary("hello_jni");`

44

45 }

46

47

48

`49`	`public` `native` `int` `nadd(int` `a,` `int` `b);`

50

51 }

Java代码说明：

1）jnitest.java是一个activity的类对象，在该类对象中生成调用JNI函数的类对象，同时调用JNI方法，最后将JNI方法的结果显示到标题栏上；

2）Nadd.java是一个引用和声明JNI库和函数的类，其中System.loadLibrary();函数用来引用JNI库，默认JNI库放在 android系统的/system/lib/目录下；public nadd int nadd(int a, int b);为声明需要在java程序中使用的JNI库中的函数；

JNI中java部分的代码到此就结束了，总结一下在java代码中需要做两件事：

1）使用System.loadLibrary()函数来引用JNI库；

2）声明调用JNI库的函数且前面添加native关键字；

android C/C++部分代码：

`01`	`#define LOG_TAG "hello-JNI"`

`02`	`#include <stdio.h>`

`03`	`#include <stdlib.h>`

`04`	`#include <unistd.h>`

`05`	`#include <sys/types.h>`

`06`	`#include <sys/stat.h>`

`07`	`#include <fcntl.h>`

`08`	`#include <assert.h>`

`09`	`#include "jni.h"`

`10`	`#include "JNIHelp.h"`

`11`	`#include "android_runtime/AndroidRuntime.h"`

`12`	`static` `jint com_hello_jnitest_jnitest_nadd(JNIEnv *env, jobject obj, jint a, jint b)`

13 {

`14`	`return` `(a * b);`

15 }

`16`	`static` `JNINativeMethod gMethods[] = {`

`17`	`{"nadd",` `"(II)I", (void` `*)com_hello_jnitest_jnitest_nadd},`

18 };

`19`	`static` `int` `register_android_test_hello(JNIEnv *env)`

20 {

`21`	`return` `android::AndroidRuntime::registerNativeMethods(env,` `"com/hello/jnitest/Nadd", gMethods, NELEM(gMethods));`

22 }

`23`	`jint JNI_OnLoad(JavaVM vm,` `void` `reserved)`

24 {

`25`	`JNIEnv *env = NULL;`

`26`	`if` `(vm->GetEnv((void` `**)&env, JNI_VERSION_1_4) != JNI_OK) {`

`27`	`printf("Error GetEnv\n");`

`28`	`return` `-1;`

29 }

`30`	`assert(env != NULL);`

`31`	`if` `(register_android_test_hello(env) < 0) {`

`32`	`printf("register_android_test_hello error.\n");`

`33`	`return` `-1;`

34 }

`35`	`return` `JNI_VERSION_1_4;`

36 }

JNI C/C++代码说明：

1）JNI_OnLoad()函数。该函数在Java程序调用System.loadLibrary()时，被调用执行，用于向JavaVM注册JNI函数等。在本例中首先通过参数JavaVM（Java虚拟机指针）获取当前应用程序所在的线程，即：JNIEnv。再通过调用 android::AndroidRuntime::registerNativeMethods()注册native实现的函数指针。

2）JNI函数和Java调用函数的映射关系。使用JNINativeMethod将java调用的函数名与JNI实现的函数名联系在一起；

3）JNI函数实现；

Android.mk代码：

`1`	`LOCAL_PATH := $(call my-dir)`

`2`	`include $(CLEAR_VARS)`

`3`	`LOCAL_PRELINK_MODULE :=` `false`

`4`	`LOCAL_SRC_FILES := \`

`5`	`com_hello_jnitest.cpp`

`6`	`LOCAL_SHARED_LIBRARIES := \`

`7`	`libandroid_runtime`

`8`	`LOCAL_MODULE := libhello_jni`

`9`	`include $(BUILD_SHARED_LIBRARY)`

需要注意的是：

1）JNI C/C++部分的代码需要在android源代码树上进行编译，编译完成后我的做法是直接将生成的.so通过adb push方法上传到android虚拟机的/system/lib/目录下；

2）java代码可以在eclipse下直接编译且在虚拟机上执行；

编译JNI C/C++部分代码（在android内核源代码根目录下）：

#make libhello_jni

之后在out/target/product/generic/system/lib/目录下生成libhello_jni.so

上传libhello_jni.so到android虚拟机：

#adb push out/target/product/generic/system/lib/libhello_jni.so /system/lib

注意：此时有可能出现Out of Memory的错误提示。当出现如上错误提示时，需要使用#adb remount重新加载一下就可以了。

另外，也有可能直接使用eclipse启动android虚拟机时出现上述错误且使用#adb remount也出现的情况，此时需要手动启动android虚拟机，如：#emulator -avd xxx -partition-size 128，之后在使用#adb push就可以了。

本文链接

[转]Android中的Frame动画

2012-02-03T01:58:00Z

本文转自：http://vlinux.iteye.com/blog/472855

相信有Android手机的人都玩过一款Kuba的游戏（没玩过的我推荐去玩一下），里面用手指接触到屏幕后产生的爆炸效果确实增加了游戏的不少色彩。那么这个是怎么做出来的呢？

很明显，这个效果应该是一个动画序列图实现的，即Frame-by-Frame动画。Android实现Frame-by-Frame动画我会的有两种方法：

1、animation-list配置，预先将一个动画按照每帧分解成的多个图片所组成的序列。然后再在Android的配置文件中将这些图片配置到动画里面。

Xml代码

<animation-list xmlns:android="http://schemas.android.com/apk/res/android"
android:oneshot="false">
<item android:drawable="@drawable/explode1" android:duration="50" />
<item android:drawable="@drawable/explode2" android:duration="50" />
<item android:drawable="@drawable/explode3" android:duration="50" />
<item android:drawable="@drawable/explode4" android:duration="50" />
</animation-list>

<animation-list xmlns:android="http://schemas.android.com/apk/res/android"
    android:oneshot="false">
    <item android:drawable="@drawable/explode1" android:duration="50" />
    <item android:drawable="@drawable/explode2" android:duration="50" />
    <item android:drawable="@drawable/explode3" android:duration="50" />
    <item android:drawable="@drawable/explode4" android:duration="50" />
</animation-list>

但是由此带来的不便也是显而易见的：drawable目录下拥挤了过多的动画帧文件。如果游戏大起来，动画效果丰富，那么drawable目录下将拥有数量庞大的图片文件，这将是开发人员的灾难(见下图)。

2、AnimationDrawable动画。其实我们发现，我们完全可以将同一动画序列的每帧图片都合并到一个大的图片中去，然后读取图片的时候按照约定好的宽、高去读就能准确的将该帧图片精确的读出来了。下图是小雪行走序列图。

将序列图读出并且转化为动画的核心代码为

Java代码

animationDrawable = new AnimationDrawable();
Bitmap[] bitmaps = new Bitmap[PlayerConst.PLAYER_XIAOXUE_WALK_FRAME];
for (int frame = 0; frame < bitmaps.length; frame++) {
Bitmap bitmap = Bitmap.createBitmap(xiaoxueWalkSerBitmap,
frame*PlayerConst.PLAYER_XIAOXUE_WALK_WIDTH,
lay*PlayerConst.PLAYER_XIAOXUE_WALK_HEIGHT,
PlayerConst.PLAYER_XIAOXUE_WALK_WIDTH,
PlayerConst.PLAYER_XIAOXUE_WALK_HEIGHT);
animationDrawable.addFrame(new BitmapDrawable(bitmap),100);
}// for,每层有 PLAYER_XIAOXUE_WALK_FRAME 帧
animationDrawable.setOneShot(false);
setBackgroundDrawable(animationDrawable);

animationDrawable = new AnimationDrawable();
Bitmap[] bitmaps = new Bitmap[PlayerConst.PLAYER_XIAOXUE_WALK_FRAME];
for (int frame = 0; frame < bitmaps.length; frame++) {
	Bitmap bitmap = Bitmap.createBitmap(xiaoxueWalkSerBitmap, 
			frame*PlayerConst.PLAYER_XIAOXUE_WALK_WIDTH, 
			lay*PlayerConst.PLAYER_XIAOXUE_WALK_HEIGHT, 
			PlayerConst.PLAYER_XIAOXUE_WALK_WIDTH,
			PlayerConst.PLAYER_XIAOXUE_WALK_HEIGHT);
	animationDrawable.addFrame(new BitmapDrawable(bitmap),100);
}// for,每层有 PLAYER_XIAOXUE_WALK_FRAME 帧
animationDrawable.setOneShot(false);
setBackgroundDrawable(animationDrawable);

具体例子可以从附件中找到。

3、SurfaceView动画。也许你很快就发现，前两个动画都必须依赖View才能展示，并且每个View只能展示一个动画。而在游戏中不可能只有一动画，更恐怖的是很多动画都是随机产生的，并不是事先约定好的，而动态创建／删除View的代价非常高，并不适合做高性能的游戏。这个时候你需要的是SurfaceView。

在SurfaceView中的动画有一点是和前边两种动画有区别的：那就是画布上所有的一切都必须自己亲自打理。在前边几个基于Animation的动画你只需关心当前动画的序列即可，其他都由系统帮你处理完毕。而在SurfaceView中，你就是那个处理程序，所有的一切包括背景都必须有你来亲自打理。

为此我写了一个框架专门来处理这个琐事，框架只有两个类：AnimationDraw和DrawRunning。其中AnimationDraw则是一个动画类，它负责描述当前动画元素的位置、当前播放到第几帧、每帧的延时是多少、是否重复播放等。

Java代码

import java.util.Date;
import android.graphics.Bitmap;
/**
* 动画绘画元素
* @author vlinux
*
*/
public class AnimationDraw {
protected float x;
protected float y;
protected Bitmap[] bitmaps;
protected long duration;
protected Long lastBitmapTime;
protected int step;
protected boolean repeat;
/**
* 动画构造函数-for静态图片
* @param x:X坐标<br/>
* @param y:Y坐标<br/>
* @param bitmap:显示的图片<br/>
* @param duration:图片显示的时间<br/>
*/
public AnimationDraw(float x, float y, Bitmap bitmap, long duration) {
Bitmap[] bitmaps = {bitmap};
this.x = x;
this.y = y;
this.bitmaps = bitmaps;
this.duration = duration;
this.repeat = true;
lastBitmapTime = null;
step = 0;
}
/**
* 动画构造函数
* @param x:X坐标<br/>
* @param y:Y坐标<br/>
* @param bitmap:显示的图片<br/>
* @param duration:图片显示的时间<br/>
* @param repeat:是否重复动画过程<br/>
*/
public AnimationDraw(float x, float y, Bitmap[] bitmaps, long duration, boolean repeat) {
this.x = x;
this.y = y;
this.bitmaps = bitmaps;
this.duration = duration;
this.repeat = repeat;
lastBitmapTime = null;
step = 0;
}
public Bitmap nextFrame() {
if (step >= bitmaps.length) {
// 判断step是否越界
if( !repeat ) {
return null;
} else {
lastBitmapTime = null;
}//if
}// if
if (null == lastBitmapTime) {
// 第一次执行
lastBitmapTime = new Date().getTime();
return bitmaps[step = 0];
}// if
// 第X次执行
long nowTime = System.currentTimeMillis();
if (nowTime - lastBitmapTime <= duration) {
// 如果还在duration的时间段内,则继续返回当前Bitmap
// 如果duration的值小于0,则表明永远不失效,一般用于背景
return bitmaps[step];
}// if
lastBitmapTime = nowTime;
return bitmaps[step++];// 返回下一Bitmap
}
public float getX() {
return x;
}
public float getY() {
return y;
}
}

import java.util.Date;

import android.graphics.Bitmap;

/**
 * 动画绘画元素
 * @author vlinux
 *
 */
public class AnimationDraw {

	protected float x;
	protected float y;
	protected Bitmap[] bitmaps;
	protected long duration;
	
	protected Long lastBitmapTime;
	protected int step;
	protected boolean repeat;
	
	/**
	 * 动画构造函数-for静态图片
	 * @param x:X坐标<br/>
	 * @param y:Y坐标<br/>
	 * @param bitmap:显示的图片<br/>
	 * @param duration:图片显示的时间<br/>
	 */
	public AnimationDraw(float x, float y, Bitmap bitmap, long duration) {
		Bitmap[] bitmaps = {bitmap};
		this.x = x;
		this.y = y;
		this.bitmaps = bitmaps;
		this.duration = duration;
		this.repeat = true;
		lastBitmapTime = null;
		step = 0;
	}
	
	/**
	 * 动画构造函数
	 * @param x:X坐标<br/>
	 * @param y:Y坐标<br/>
	 * @param bitmap:显示的图片<br/>
	 * @param duration:图片显示的时间<br/>
	 * @param repeat:是否重复动画过程<br/>
	 */
	public AnimationDraw(float x, float y, Bitmap[] bitmaps, long duration, boolean repeat) {
		this.x = x;
		this.y = y;
		this.bitmaps = bitmaps;
		this.duration = duration;
		this.repeat = repeat;
		lastBitmapTime = null;
		step = 0;
	}
	
	
	public Bitmap nextFrame() {

		if (step >= bitmaps.length) {
			// 判断step是否越界
			if( !repeat ) {
				return null;
			} else {
				lastBitmapTime = null;
			}//if
		}// if

		if (null == lastBitmapTime) {
			// 第一次执行
			lastBitmapTime = new Date().getTime();
			return bitmaps[step = 0];
		}// if

		// 第X次执行
		long nowTime = System.currentTimeMillis();
		if (nowTime - lastBitmapTime <= duration) {
			// 如果还在duration的时间段内,则继续返回当前Bitmap
			// 如果duration的值小于0,则表明永远不失效,一般用于背景
			return bitmaps[step];
		}// if
		lastBitmapTime = nowTime;
		return bitmaps[step++];// 返回下一Bitmap
	}
	
	public float getX() {
		return x;
	}

	public float getY() {
		return y;
	}
	
}

DrawRunning则是一个负责画图的线程，它是程序的核心。

Java代码

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.view.SurfaceHolder;
/**
* 绘画线程
*
* @author vlinux
*
*/
public class DrawRunning implements Runnable {
private List<AnimationDraw> animationDraws;//所有需要画动画的集合
private List<AnimationDraw> buffers;//缓存前台传入需要展示的动画
private SurfaceHolder surfaceHolder;
private boolean running;
public DrawRunning(SurfaceHolder surfaceHolder) {
this.surfaceHolder = surfaceHolder;
animationDraws = new ArrayList<AnimationDraw>();
buffers = new ArrayList<AnimationDraw>();
running = true;
}
@Override
public void run() {
// TODO Auto-generated method stub
while (running) {
synchronized (surfaceHolder) {
Canvas canvas = null;
try {
canvas = surfaceHolder.lockCanvas(null);
doDraw(canvas);
} finally {
if (null != canvas) {
surfaceHolder.unlockCanvasAndPost(canvas);
}// if
}// try
}// syn
}// while
}
private void doDraw(Canvas canvas) {
synchronized(this) {
//检查缓存中是否有需要加入的动画
if( !buffers.isEmpty() ) {
animationDraws.addAll(buffers);//加入animationDraws
buffers.clear();//清空缓存
}//if
}//syn
if( animationDraws.isEmpty() ) {
return;//如果animationDraws里面是空的那就不用画了
}//if
//---这里开始绘画
Iterator<AnimationDraw> bombIt = animationDraws.iterator();
while (bombIt.hasNext()) {
AnimationDraw bomb = bombIt.next();
Bitmap nextFrame = bomb.nextFrame();
if (null == nextFrame) {
//下一Frame为null，说明动画序列已经结束
//该动画已经完成，从动画集合中删除
bombIt.remove();
continue;//while
}// if
canvas.drawBitmap(nextFrame, bomb.getX(), bomb.getY(), null);
}// while
}
public void addAnimationDraw(AnimationDraw bomb) {
synchronized(this) {
//尽量减少这个的同步响应时间，因为这个方法是前台响应的
//多0.1秒都会直接反应到用户感知
buffers.add(bomb);//将需要显示动画的内容加入到缓存
}//syn
}
public void stopDrawing() {
running = false;
}
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.view.SurfaceHolder;

/**
 * 绘画线程
 * 
 * @author vlinux
 * 
 */
public class DrawRunning implements Runnable {

	private List<AnimationDraw> animationDraws;//所有需要画动画的集合
	private List<AnimationDraw> buffers;//缓存前台传入需要展示的动画
	private SurfaceHolder surfaceHolder;
	private boolean running;

	public DrawRunning(SurfaceHolder surfaceHolder) {
		this.surfaceHolder = surfaceHolder;
		animationDraws = new ArrayList<AnimationDraw>();
		buffers = new ArrayList<AnimationDraw>();
		running = true;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (running) {
			synchronized (surfaceHolder) {
				Canvas canvas = null;
				try {
					canvas = surfaceHolder.lockCanvas(null);
					doDraw(canvas);
				} finally {
					if (null != canvas) {
						surfaceHolder.unlockCanvasAndPost(canvas);
					}// if
				}// try
			}// syn
		}// while
	}

	private void doDraw(Canvas canvas) {
		synchronized(this) {
			//检查缓存中是否有需要加入的动画
			if( !buffers.isEmpty() ) {
				animationDraws.addAll(buffers);//加入animationDraws
				buffers.clear();//清空缓存
			}//if
		}//syn
		if( animationDraws.isEmpty() ) {
			return;//如果animationDraws里面是空的那就不用画了
		}//if
		//---这里开始绘画
		Iterator<AnimationDraw> bombIt = animationDraws.iterator();
		while (bombIt.hasNext()) {
			AnimationDraw bomb = bombIt.next();
			Bitmap nextFrame = bomb.nextFrame();
			if (null == nextFrame) {
				//下一Frame为null，说明动画序列已经结束
				//该动画已经完成，从动画集合中删除
				bombIt.remove();
				continue;//while
			}// if
			canvas.drawBitmap(nextFrame, bomb.getX(), bomb.getY(), null);
		}// while
	}

	public void addAnimationDraw(AnimationDraw bomb) {
		synchronized(this) {
			//尽量减少这个的同步响应时间，因为这个方法是前台响应的
			//多0.1秒都会直接反应到用户感知
			buffers.add(bomb);//将需要显示动画的内容加入到缓存
		}//syn
	}

	public void stopDrawing() {
		running = false;
	}

}

值得注意的是，我用了一个缓存和两个synchronized来提高前台的响应以及确保对集合类、SurfaceHolder的正确操作。

例子可以见附件。

PlayerDemo.tar.gz (57.8 KB)
描述: 例子2
下载次数: 425

TouchBombDemo.tar.gz (680.9 KB)
描述: 例子3
下载次数: 490

本文链接

[转]Android API学习 SoundPool 和 MediaPlayer

2012-02-03T01:20:00Z

本文转自：http://dev.10086.cn/cmdn/wiki/index.php?doc-view-5522.html

Android平台中关于音频播放有以下两种方式：

1. SoundPool —— 适合短促且对反应速度比较高的情况(游戏音效或按键声等)

2. MediaPlayer —— 适合比较长且对时间要求不高的情况

-------------------------------------------------------------------------------------------

SoundPool

1. 创建一个SoundPool

public SoundPool(int maxStream, int streamType, int srcQuality)

maxStream —— 同时播放的流的最大数量

streamType —— 流的类型，一般为STREAM_MUSIC(具体在AudioManager类中列出)

srcQuality —— 采样率转化质量，当前无效果，使用0作为默认值

eg.

SoundPool soundPool = new SoundPool(3, AudioManager.STREAM_MUSIC, 0);

创建了一个最多支持3个流同时播放的，类型标记为音乐的SoundPool。

2. 加载音频资源

可以通过四种途径来记载一个音频资源：

int load(AssetFileDescriptor afd, int priority)

通过一个AssetFileDescriptor对象

int load(Context context, int resId, int priority)

通过一个资源ID

int load(String path, int priority)

通过指定的路径加载

int load(FileDescriptor fd, long offset, long length, int priority)

通过FileDescriptor加载

*API中指出，其中的priority参数目前没有效果，建议设置为1。

一个SoundPool能同时管理多个音频，所以可以通过多次调用load函数来记载，如果记载成功将返回一个非0的soundID ，用于播放时指定特定的音频。

eg.

int soundID1 = soundPool.load(this, R.raw.sound1, 1);

if(soundID1 ==0){

// 记载失败

}else{

// 加载成功

}

int soundID2 = soundPool.load(this, R.raw.sound2, 1);

...

这里加载了两个流，并分别记录了返回的soundID 。

需要注意的是，

流的加载过程是一个将音频解压为原始16位PCM数据的过程，由一个后台线程来进行处理异步，所以初始化后不能立即播放，需要等待一点时间。

3. 播放控制

有以下几个函数可用于控制播放：

final int play(int soundID, float leftVolume, float rightVolume, int priority, int loop, float rate)

播放指定音频的音效，并返回一个streamID 。

priority —— 流的优先级，值越大优先级高，影响当同时播放数量超出了最大支持数时SoundPool对该流的处理;

loop —— 循环播放的次数，0为值播放一次，-1为无限循环，其他值为播放loop+1次(例如，3为一共播放4次).

rate —— 播放的速率，范围0.5-2.0(0.5为一半速率，1.0为正常速率，2.0为两倍速率)

final void pause(int streamID)

暂停指定播放流的音效(streamID 应通过play()返回)。

final void resume(int streamID)

继续播放指定播放流的音效(streamID 应通过play()返回)。

final void stop(int streamID)

终止指定播放流的音效(streamID 应通过play()返回)。

这里需要注意的是，

1.play()函数传递的是一个load()返回的soundID——指向一个被记载的音频资源，如果播放成功则返回一个非0的streamID——指向一个成功播放的流 ;同一个soundID 可以通过多次调用play()而获得多个不同的streamID (只要不超出同时播放的最大数量);

2.pause()、resume()和stop()是针对播放流操作的，传递的是play()返回的streamID ;

3.play()中的priority参数，只在同时播放的流的数量超过了预先设定的最大数量是起作用，管理器将自动终止优先级低的播放流。如果存在多个同样优先级的流，再进一步根据其创建事件来处理，新创建的流的年龄是最小的，将被终止;

4.无论如何，程序退出时，手动终止播放并释放资源是必要的。

eg.

//这里对soundID1的音效进行播放——优先级为0(最低)，无限循环，正常速率。

int streamID = soundPool.play(soundID1 , 1.0, 1.0, 0, -1, 1.0);

if(streamID ==0){

// 播放失败

}else{

// 播放成功

}

...

// 暂停soundID1的播放

soundPool.pause(streamID );

...

// 恢复soundID1的播放

soundPool.resume(streamID );

...

// 终止播放，记住循环为-1时必须手动停止

soundPool.stop(streamID );

*API中指出，即使使用无效的soundID /streamID (操作失败或指向无效的资源)来调用相关函数也不会导致错误，这样能减轻逻辑的处理。

4. 更多属性设置

其实就是paly()中的一些参数的独立设置：

final void setLoop(int streamID, int loop)

设置指定播放流的循环.

final void setVolume(int streamID, float leftVolume, float rightVolume)

设置指定播放流的音量.

final void setPriority(int streamID, int priority)

设置指定播放流的优先级，上面已说明priority的作用.

final void setRate(int streamID, float rate)

设置指定播放流的速率，0.5-2.0.

5. 释放资源

可操作的函数有：

final boolean unload(int soundID)

卸载一个指定的音频资源.

final void release()

释放SoundPool中的所有音频资源.

-汇总-

一个SoundPool可以：

1.管理多个音频资源，通过load()函数，成功则返回非0的soundID;

2.同时播放多个音频，通过play()函数，成功则返回非0的streamID;

3.pause()、resume()和stop()等操作是针对streamID(播放流)的;

4.当设置为无限循环时，需要手动调用stop()来终止播放;

5.播放流的优先级(play()中的priority参数)，只在同时播放数超过设定的最大数时起作用;

6.程序中不用考虑(play触发的)播放流的生命周期，无效的soundID/streamID不会导致程序错误。

-------------------------------------------------------------------------------------------

MediaPlayer

你可以通过new或便捷的静态create函数组来创建一个MediaPlayer对象。

两种方式的比较：

new MediaPlayer()

1.成功调用后，MediaPlayer将处于Idle状态;

2.setDataSource提供了对String(path)、Uri和FileDescriptor格式的资源路径的支持;

3.后续需要手动调用prepare()才能进行播放。

MediaPlayer.create(...)

1.成功调用后，MediaPlayer将处于Prepared状态;

2.create提供了对int(resID)和Uri格式的资源路径的支持;

3.无需(也不能)再次调用prepare()就能直接播放。
　要点：

1.如果由于错误的操作mp.setDataSource("/sdcard/test.mp3"); // 直接传URL也是可以的，将自动处理缓冲

} catch (IllegalArgumentException e) {

e.printStackTrace();

} catch (IllegalStateException e) {

// 如果在非Idle状态下调用setDataSource就会导致该异常

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

// 设置必要的监听器

mp.setOnPreparedListener(new OnPreparedListener(){

@Override

public void onPrepared(MediaPlayer mp) {

// 这时能确保player处于Prepared状态，触发start是最合适的

mp.start();

}

});

mp.setOnCompletionListener(new OnCompletionListener() {

@Override

public void onCompletion(MediaPlayer mp) {

// 正常播放结束，可以触发播放下一首

}

});

mp.setOnErrorListener(new OnErrorListener() {

@Override

public boolean onError(MediaPlayer mp, int what, intextra) {

// 操作错误或其他原因导致的错误会在这里被通知

return true;

}

});

// 连接并加载资源

try {

mp.prepare();

// mp.prepareAsync() 这也是可以的，这是异步处理，上面的是同步处理，实际加载完毕以OnPreparedListener.onPrepared()为准。

} catch (IllegalStateException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

// mp.start(); // 建议在OnPreparedListener.onPrepared()回调中触发该函数，特别是使用异步加载时

/**

* ... 你的其他操作 ...

// 终止播放并释放资源

try{

mp.stop(); // 这是必要的，如果你设置了循环播放，否则程序退出了音乐仍在后台继续播...

mp.release();

}catch(IllegalStateException e){

e.printStackTrace();

}

// 通过new创建后的player处于Idle状态

导致MediaPlayer处于Error状态，可通过reset()函数来使其恢复到Idle状态，再重新执行setDataSource等初始化操作(ps:如果是通过create函数绑定资源ID创建的就郁闷了...);

2.API中指出虽然reset后的MediaPlayer就像相当于新new的一样，但存在微妙的差异的：

在这两种情况下播放器处于Idle状态，此时调用getCurrentPosition(), getDuration(),getVideoHeight(),getVideoWidth(), setAudioStreamType(int),setLooping(boolean), setVolume(float, float), pause(), start(), stop(),seekTo(int), prepare() 或 prepareAsync() 等函数都属与编程错误。当在MediaPlayer刚创建后调用这些函数，用户指定的OnErrorListener.onError() 回调函数不会被internal player engine(内部播放引擎)调用，并且播放器的状态依然未变;但如果是在调用reset() 函数之后，用户指定的OnErrorListener.onError() 回调函数将会被internal player engine(内部播放引擎)调用，并且播放器的状态将转变为Error(错误)状态。

3.使用完毕后应该立即调用release()函数来释放资源，如果操作成功，MediaPlayer对象将处于End状态，此时无法再进行任何操作，除非重新创建MediaPlayer对象。

更多的细节通过一个用new方式来创建的示例说明:

Java代码

// 通过new创建后的player处于Idle状态

MediaPlayer mp = new MediaPlayer();

if(mp==null){

// new创建有可能会返回null值，检测是好的习惯

return;

}

// 设置资源路径，成功执行的话player将处于Initialized状态

try {

MediaPlayer mp = new MediaPlayer();

if(mp==null){

// new创建有可能会返回null值，检测是好的习惯

return;

}

// 设置资源路径，成功执行的话player将处于Initialized状态

try {

mp.setDataSource("/sdcard/test.mp3"); // 直接传URL也是可以的，将自动处理缓冲

} catch (IllegalArgumentException e) {

e.printStackTrace();

} catch (IllegalStateException e) {

// 如果在非Idle状态下调用setDataSource就会导致该异常

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

// 设置必要的监听器

mp.setOnPreparedListener(new OnPreparedListener(){

@Override

public void onPrepared(MediaPlayer mp) {

// 这时能确保player处于Prepared状态，触发start是最合适的

mp.start();

}

});

mp.setOnCompletionListener(new OnCompletionListener() {

@Override

public void onCompletion(MediaPlayer mp) {

// 正常播放结束，可以触发播放下一首

}

});

mp.setOnErrorListener(new OnErrorListener() {

@Override

public boolean onError(MediaPlayer mp, int what, intextra) {

// 操作错误或其他原因导致的错误会在这里被通知

return true;

}

});

// 连接并加载资源

try {

mp.prepare();

// mp.prepareAsync() 这也是可以的，这是异步处理，上面的是同步处理，实际加载完毕以OnPreparedListener.onPrepared()为准。

} catch (IllegalStateException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

// mp.start(); // 建议在OnPreparedListener.onPrepared()回调中触发该函数，特别是使用异步加载时

/**

* ... 你的其他操作 ...

// 终止播放并释放资源

try{

mp.stop(); // 这是必要的，如果你设置了循环播放，否则程序退出了音乐仍在后台继续播...

mp.release();

}catch(IllegalStateException e){

e.printStackTrace();

}

播放控制上基本与SoundPool相同有：

start()、pause()、stop()、seekTo()、setLooping()...

需要注意的是，循环播放设置上与SoundPool不同，不能指定确定的循环次数，而是一个布尔值，指定是否循环播放...

更多的函数使用请查阅API文档。

本文链接

[转]WebGL All in One 全傻瓜简介

2012-02-02T03:24:00Z

本文转自：http://www.hiwebgl.com/?p=628

本文是基于Opera开发团队的一篇文章翻译修改而成的，建议第一次接触WebGL概念的朋友阅读本文，可以对WebGL技术有一个整体的了解。这不是一个WebGL教程，只相当于WebGL的百科条目（实际上目前中文维基百科和百度百科对WebGL的介绍都不够好）。

什么是WebGL？

WebGL是一套JavaScript API，允许开发者在浏览器中直接嵌入支持硬件加速的互动3D图形。下面是一个WebGL应用于网页中的视频，来源于WebGL教程的第10课，你可以看到简单的全3D的类似于Doom的游戏，而且完全是在浏览器中实现的，无需任何插件。

作为一项开放的web标准，WebGL是由Khronos Group开发的，Google、Apple、Mozilla、Opera等公司和组织都是其中的成员，即这一标准的制定者和积极倡导者。

WebGL是作为HTML5中的 <canvas>标签的一个特殊的上下文（experimental-webgl）实现在浏览器中的，因此WebGL也可以与所有DOM接口完全整合到一起。WebGL API是基于OpenGL ES 2.0的，是OpenGL ES 2.0的子集，所以WebGL可以运行于许多不同的硬件设备之上，例如桌面电脑、智能手机、平板电脑和智能电视。你可以在Khronos的网站上找到WebGL的规范全文。

我如何才能运行WebGL？

要运行WebGL，你必须有一个支持它的浏览器。例如：

Google Chrome 9及以上版本
Mozilla Firefox 4以及上版本
Safari 5.1及以上版本（仅限于Mac OS X操作系统，不包括Windows操作系统；所有情况下必须强制开启WebGL支持，请参考下文）
Opera Next 即Opera 12 alpha及以上版本
你会发现IE并不支持WebGL，不过你可以通过下载并安装IEWebGL这个插件，或者Google Chrome Framework来运行一些WebGL应用。

同时，你还需要一块好的显卡，并安装了最新的显卡驱动；这只是刚刚能够运行WebGL的要求，如果想要在一些复杂的应用中保证显示效果，那你需要一块更好的显卡。

如果你的显卡非常老旧，或者是板载的集成显卡，那么你需要在浏览器中强制开启WebGL支持；另外因为其他的一些原因（比如你的操作系统是Windows XP），在正常安装以上浏览器之后还是不能运行WebGL，那你最好也强制开启WebGL支持。开启方法如下：

Chrome浏览器

我们需要为Chrome加入一些启动参数，以下具体操作步骤以Windows操作系统为例，请Linux用户自行设置。

Chrome浏览器的用户请找到Chrome浏览器的快捷方式，如果没有就创建一个快捷方式（右键点击chrome.exe，选择“创建快捷方式”或者“发送到”→“桌面快捷方式”），右键点击快捷方式，选择属性。
在目标框内，双引号的后边，加入以下内容

--enable-webgl --ignore-gpu-blacklist --allow-file-access-from-files

点击确定。

设置完成的后的快捷方式属性窗口看起来应当是这样的，请注意其中的“目标”文本框：

关闭目前开启的所有Chrome窗口，然后用此快捷方式启动Chrome浏览器。

其中

--enable-webgl

的意思是开启WebGL支持；

--ignore-gpu-blacklist

的意思是忽略GPU黑名单，也就是说有一些显卡GPU因为过于陈旧等原因，不建议运行WebGL，这个参数可以让浏览器忽略这个黑名单，强制运行WebGL；

--allow-file-access-from-files

的意思是允许从本地载入资源，如果你不是WebGL的开发者，不需要开发调试WebGL，只是想要看一下WebGL的Demo，那你可以不添加这个参数。

Firefox浏览器

Firefox的用户请在浏览器的地址栏输入“about:config”，回车
在过滤器（filter）中搜索“webgl”
将webgl.force-enabled设置为true
将webgl.disabled设置为false
在过滤器（filter）中搜索“security.fileuri.strict_origin_policy”
将security.fileuri.strict_origin_policy设置为false
关闭目前开启的所有Firefox窗口，然后重新启动Firefox。

其中前两个设置是强制开启WebGL支持，最后一个security.fileuri.strict_origin_policy的设置是允许从本地载入资源，如果你不是WebGL的开发者，不需要开发调试WebGL，只是想要看一下WebGL的Demo，那你可以不设置此项。

Safari浏览器

在菜单中找到“属性”→“高级”，选中“显示开发菜单”，然后到“开发”菜单，选中“开启WebGL”

如何判断我目前的浏览器是否支持WebGL？

请访问http://doesmybrowsersupportwebgl.com/。

如果显示Yay，说明你的浏览器已经支持WebGL了。
如果显示Nay，说明你的浏览器目前还不能运行WebGL。

你也可以在我们网站的Demo栏目里，选择几个Demo运行一下，或者运行一些我们教程中的一些Demo。

WebGL可以用来做什么？

WebGL允许开发者在浏览器中实现实时的3D互动图形。WebGL可以应用于互动音乐电视、游戏、数据可视化、艺术、3D设计环境、3D空间建模、3D物体建模、绘制数学函数和创建物理模拟。

WebGL的工作原理是什么？

因为是被设计成直接工作在显卡端的，所以WebGL比目前其他的典型的web技术都要更加复杂。总的来说，它是相当的低等级的。这也正是它为什么能够如此迅速的完成大量的计算，并实现复杂的实时3D渲染的原因。

你不需要完全理解WebGL内在的工作原理。因为有很多第三方WebGL图形库可以帮你完成一些复杂的操作。但是如果你想成为一个高级开发者，充分利用WebGL的各种高级特性，那建议你最好还是深入了解一下其中的内涵。

在WebGL中编程，通常的目标都是想要渲染某种场景。这其中包括多重并发的绘制工作，称之为绘制调用（draw call），这些调用都是在GPU端通过一个叫做渲染管线（Rendering Pipeline）的处理流程来实现的。

在WebGL中，和其他大多数实时3D图形系统一样，三角形是用于绘制模型的最基本的元素。因此，在WebGL中需要通过使用JavaScript来生成绘制信息，这些绘制信息包括指定在什么位置绘制三角形、如何绘制三角形、这些三角形的外观长的什么样子（颜色、形状、纹理等等）。然后将这些信息传递给到GPU端，GPU进行处理，最后再返回绘制结果。

下面我们来看看渲染管线的具体流程。

渲染管线

以下部分节选自Joe Groff的文章《现代OpenGL简介 – 第一章：图形管线》

渲染管线的处理流程开始于建立顶点数组（Vertex Array）。这些数组包括了顶点属性（例如顶点在3D空间中的位置）和顶点纹理信息、颜色信息和如何接受光照（顶点法线）。这些顶点数组和其中包含的数据都是在JavaScript中建立的，建立的方法有以下几种：

自己编写JavaScript代码建立
加载并解析一个描述3D模型的文件（例如.obj文件）
使用第三方图形库内置封装好的几何体形状

然后顶点数组里的数据会被填充到一个或多个顶点缓冲（Vertex Buffer）中，并传递到GPU端。在向GPU提交渲染工作的时候，我们还需要提供一个额外的数组用于描述顶点数组中元素的索引。这个顶点索引数组会在稍后控制顶点如何被装配到三角形中。

好了，GPU开始从顶点缓冲中读取顶点信息，并在顶点着色器（Vertex Shader）中处理这些信息。顶点着色器是一个程序，用于读取顶点属性，并输出一个新的属性集合。顶点着色器最基本的功能是计算顶点在屏幕空间中的位置。但它也会为每个顶点生成其他属性，比如颜色或纹理坐标。你可以编写代码自定义顶点着色器，也可以使用第三方图形库提供的顶点着色器。

然后，GPU会连接这些顶点来形成三角形。这里就用到了顶点索引数组，GPU会根据顶点索引的描述，将这些顶点按照指定顺序每3个分成一组，形成一个三角形。

然后光栅器（Rasterizer）会作用于每个三角形，切出这些三角形并忽略形状之外的其他部分，然后将当前剩余的可见部分打碎，填充到像素大小的片元（Fragment）中。对于其他顶点属性（比如颜色和纹理），顶点着色器会在光栅化之后的三角形表面上，为一个顶点和另一个顶点之间的部分做线性插值，为每一个片元（也就是像素）产生一个平滑的渐变值。举例来说，如果顶点着色器为每个顶点分配了一个颜色值，那么光栅器将会混合这些颜色，并在像素化的表面生成一个新的合适的渐变色。关于本段内容更详细的讲解，请参考我们教程的第2课。

这些生成的像素大小的片元之后会被传递到片元着色器（Fragment Shader）中。片元着色器将会输出每个像素的颜色和深度值，用于在帧缓冲（Frame Buffer）中进行绘制。通常情况下，片元着色器的操作包括纹理映射和光照。因为片元着色器会为每个像素进行独立绘制，这就可以实现很多相当复杂的特殊效果；但也正是因为这样，片元着色器也成为图形管线中和性能最为相关的部分。和顶点着色器一样，你可以编写代码自定义片元着色器，也可以使用第三方图形库提供的片元着色器。

最后，帧缓冲（Frame Buffer）是渲染输出的最终目的地。帧缓冲是一个2D图像，但又不仅仅是一个2D图像这么简单。除了一个或多个颜色缓冲区之外，帧缓冲还包含深度缓冲区（Depth Buffer）和/或模板缓冲区（Stencil Buffer），这两个都是在最终绘制到帧缓冲之前可选的过滤片元的方式，深度检测会忽略被前面已经绘制的物体挡住的后面的物体，模板检测会使用模板缓冲区中绘制的形状约束帧缓冲中的可绘制区域，将渲染工作“模板化”。经过这两层过滤之后依然幸存的片元，它们的颜色值会与在它们覆盖之下的颜色值进行α混合。最终的颜色值、深度值、模板值会写入相应的缓冲区。帧缓冲的输出结果也可以用作纹理输入到其他渲染中去（即渲染到纹理，可以参考教程第16课）。

我如何开始学习开发WebGL？

首先你需要有一个支持WebGL的浏览器。然后，你可以在你喜欢的JavaScript开发环境中编写代码。

要学习WebGL，最好有编写JavaScript、OpenGL或OpenGL ES的经验和基础，还需要少量的HTML5知识。如果你是一个网络前端工程师，那可能你的JavaScript经验已经很充足了，但是却没有接触过计算机图形学，那也没有关系，实际上你可以越过OpenGL和OpenGL ES，直接从WebGL切入，作为你学习计算机图形学的开始。

教程方面推荐Giles编写的WebGL教程，我们的网站上有这一教程的指定中文版本，这一教程的大部分课程都是从大名鼎鼎的Nehe的OpenGL教程改编的，从浅入深，相当的通俗易懂。如果学习过程中有什么疑问，可以加入我们的QQ群提问，也可以在论坛发帖提问。

如果不是出于学习目的，而是要开发一个正式的商用项目，那么我们建议你在了解了WebGL的工作原理和其他计算机图形学的知识之后，使用第三方图形库进行开发。如果你阅读了上面的章节之后，你会发现直接使用原生的WebGL API开发项目会非常非常非常让人头疼。不像其他的web API，原生的WebGL是非常低等级的。WebGL标准的开发者这么做的目的是为了保证WebGL充分的灵活性和适用于所有应用的可用性，同时希望第三方图形库的开发者在这之后可以为WebGL添加一个简单便捷开发层。

目前有很多WebGL的第三方图形库，其中大多都是基于WebGL来迅速创建3D环境中的元素的，这些元素包括场景、相机、光源、环境光、内置的几何体形状、材质、纹理和雾化以及粒子效果。每个图形库都提供了差不多的元素类型，但可用性如何依赖于不同图形库的本身的开发质量。另外因为WebGL可以互动，所以很多图形库也封装了处理交互事件的接口。最后，很多图形库都提供了一些成型的顶点着色器和片元着色器代码。这么说很难说清楚，当你开始试着用一下各种图形库的时候，你就会发现使用图形库而不是原生WebGL AP的便捷性了。

你可以在WebGL Public Wiki的User Contributions页面上找到一个列有大部分图形库的清单。

本文链接

博客园_Love in coding...

[转]html5之Canvas坐标变换应用-时钟实例

[转]利用 Ant 和 Eclipse 有效地提高部署工作效率

[转]Eclipse之ANT使用

[转]搭建Windows下Java Web开发环境

[转]修改visual studio 2010 HelpLibrary（MSDN）的路径

[转]Android.mk的用法和基础

[转]Android JNI使用方法

[转]Android中的Frame动画

[转]Android API学习 SoundPool 和 MediaPlayer

[转]WebGL All in One 全傻瓜简介

Safari浏览器 在菜单中找到“属性”→“高级”，选中“显示开发菜单”，然后到“开发”菜单，选中“开启WebGL”

WebGL可以用来做什么？ WebGL允许开发者在浏览器中实现实时的3D互动图形。WebGL可以应用于互动音乐电视、游戏、数据可视化、艺术、3D设计环境、3D空间建模、3D物体建模、绘制数学函数和创建物理模拟。

Safari浏览器

在菜单中找到“属性”→“高级”，选中“显示开发菜单”，然后到“开发”菜单，选中“开启WebGL”

WebGL可以用来做什么？

WebGL允许开发者在浏览器中实现实时的3D互动图形。WebGL可以应用于互动音乐电视、游戏、数据可视化、艺术、3D设计环境、3D空间建模、3D物体建模、绘制数学函数和创建物理模拟。