中文 » 高校博客大奖赛 http://software.intel.com/zh-cn/blogs Mon, 28 May 2012 14:23:20 +0000 en hourly 1 http://wordpress.org/?v=3.1.3 移动Web应用程序开发 高性能JavaScript篇 (三) JavaScript 加载解析和部署 http://software.intel.com/zh-cn/blogs/2012/05/10/web-javascript-javascript-3/ http://software.intel.com/zh-cn/blogs/2012/05/10/web-javascript-javascript-3/#comments Thu, 10 May 2012 15:53:27 +0000 Dawei Cheng 程大伟 (Intel) http://software.intel.com/zh-cn/blogs/2012/05/10/web-javascript-javascript-3/ 介绍 

本系列博客将主要介绍如今大红大紫的移动Web应用程序开发最重要的三个工具：HTML5，JavaScript， CSS3。博文也分为三个大部分：

1. 众望所归的HTML5将主要介绍HTML5的前世今生，主要功能和API以及相关Demo，Demo的代码都可以在文章附件中下载到；

2. 高性能JavaScript将主要介绍如何让JavaScript更流畅，JavaScript debug和分析工具，可以说，没有JavaScript就不可能有互联网的今天，更不可能有移动互联网的明天，编写高性能的JavaScript至关重要；

3. 变化万千的CSS3将主要介绍如今异常强大的CSS3，结合HTML5编写动态的Web应用。熟练使用异常Fashion & Cool & 炫的CSS3将使Web应用增色不少。

本篇是高性能JavaScript介绍的第三篇，将给大家结合实例例子及分析工具介绍在加载JavaScript代码时，如何编程可以让Web应用或者网页更加高效。

相关文章 

移动Web应用程序开发 高性能JavaScript篇 (一) JavaScript 性能瓶颈

移动Web应用程序开发 高性能JavaScript篇 (二) JavaScript 性能分析工具

加载JavaScript

当Browser在遇到<script>标签的时候，整个页面会因为脚本解析、运行而出现等待，不论实际load的JavaScript代码是内联的还是包含在不相干的外部文件中。页面会因为JavaScript文件的下载，解析而停止，等待脚本完成了才能继续。所以对比以下两段代码看谁能高效：

代码片段一

<html>
	<head>
		<title>Script Example</title>
		<-- Example of inefficient script positioning -->
		<script type="text/javascript" src="file1.js"></script>
		<script type="text/javascript" src="file2.js"></script>
		<script type="text/javascript" src="file3.js"></script>
		<link rel="stylesheet" type="text/css" href="styles.css">
	</head>
	<body>
		<p>Hello world!</p>
	</body>
</html>

代码片段二

<html>
	<head>
		<title>Script Example</title>
		<link rel="stylesheet" type="text/css" href="styles.css">
	</head>
	<body>
		<p>Hello world!</p>
		<-- Example of recommend script positioning -->
		<script type="text/javascript" src="file1.js"></script>
		<script type="text/javascript" src="file2.js"></script>
		<script type="text/javascript" src="file3.js"></script>
	</body>
</html>

很显然，代码片段二更高效。因为页面显示部分和JavaScript脚本没有直接的关系，所以完全可以先把界面渲染了再去load脚本。三个JS脚本加载时间我们可以从Chrome分析工具中获得，如下图所示：

将脚本成组加载

由于每个<script>标签在下载时都会阻塞页面解析的过程，所以限制页面<script>总数也可以改善性能。所以成组加载JavaScript脚本可以提升页面整体性能，这个规则不仅对内联脚本有效，对外部脚本同样适用。

原因是在于每个HTTP 请求都会产生额外的性能负担，下载一个100KB的脚本远比下载4个25KB的脚本要快。

下面我们用两个demo来证明一下：demo源代码可在本文结尾处下载。

代码片段一：

<html>
	<head>
		<title>Script Example</title>
		<link rel="stylesheet" type="text/css" href="styles.css">
	</head>
	<body>
		<p>Hello world!</p>
		<-- Example of not recommended script positioning -->
		<script type="text/javascript" src="
		http://yui.yahooapis.com/combo?2.7.0/build/yahoo/yahoo-min.js">
		</script>
		<script type="text/javascript" src="
		http://yui.yahooapis.com/combo?2.7.0/build/event/event-min.js ">
		</script>
	</body>

代码片段二：

<html>
	<head>
		<title>Script Example</title>
		<link rel="stylesheet" type="text/css" href="styles.css">
	</head>
	<body>
		<p>Hello world!</p>
		<-- Example of recommended script positioning -->
		<script type="text/javascript" src="

http://yui.yahooapis.com/combo?2.7.0/build/yahoo/yahoo-min.js&

		2.7.0/build/event/event-min.js "></script>
	</body>

两段代码运行后，分别用Chrome开发者工具里面的TimeLine进行分析结果如下图：代码片段二要更加高效。

动态加载脚本

文件对象模型（DOM）允许用户使用JavaScript创建HTML文档中几乎全部的元素和内容。<script>元素也不例外。所以，使用DOM可以动态的在JavaScript动创建，移动，删除脚本文件，这样可以比较JavaScript在加载时对UI页面的阻塞。

参见代码片段：

<script >
	var script = document.createElement("script")
	script.type = "text/javascript";
	//Firefox, Opera, Chrome, Safari 3+
	script.onload = function(){
		alert("Script loaded!");
	};
	script.src = "file1.js";
	document.getElementsByTagName("head")[0].appendChild(script);
</script>

运行后使用TimeLine分析如下图所示：可以看出JavaScript的加载并没有阻塞UI页面。

XHR脚本

另外一种非阻塞方式加载脚本的方法就是将XMLHttpRequest（XHR）对象加入到页面中。这种方式首先需要创建一个XHR对象，然后下载JavaScript文件，再使用一个动态的<script>元素将JavaScript代码加入到页面里面。

具体参加代码示例：

var xhr = new XMLHttpRequest();
xhr.open("get", "file1.js", true);
xhr.onreadystatechange = function(){
    if (xhr.readyState == 4){
        if (xhr.status >= 200 && xhr.status < 300 || xhr.status == 304){
	var script = document.createElement("script");
	script.type = "text/javascript";
	script.text = xhr.responseText;
	document.body.appendChild(script);
        }
    }
};
xhr.send(null);

部署JavaScript

为了让客户端Web应用更加高效和便捷，不仅仅在客户端编程时可以高效地使用JavaScript，同样在Server端可以通过以下途径来使Web页面的加载更高快速。

1. 尽可能地合并JavaScript文件，降低HTTP请求数量

2. 压缩JavaScript文件，缩小下载文件的大小，可以使用gzip的方式进行压缩。

3. 通过设定合适的HTTP 回复头文件来使客户端缓存一些大的JavaScript文件。一旦脚本被缓存，则用户下次打开时，可以显著降低加下载和解析时间。

4. 对于服务范围很广的公司，可以考虑使用CDN（Content Delivery Network）来部署JavaScript文件。

源代码下载地址： 下载

参考文章：High performance JavaScript O'Reilly Yahoo Press

在下一篇文章中将给大家介绍在JavaScript编程的过程中，如何通过一些编程技巧来提升Web应用的性能，缩短其处理时间。

相关文章

移动Web应用程序开发 高性能JavaScript篇 (一) JavaScript 性能瓶颈

移动Web应用程序开发 高性能JavaScript篇 (二) JavaScript 性能分析工具

]]> http://software.intel.com/zh-cn/blogs/2012/05/10/web-javascript-javascript-3/feed/ 0 HTML5之Web Storage http://software.intel.com/zh-cn/blogs/2011/12/26/html5web-storage/ http://software.intel.com/zh-cn/blogs/2011/12/26/html5web-storage/#comments Mon, 26 Dec 2011 04:00:27 +0000 章政 http://software.intel.com/zh-cn/blogs/2011/12/26/html5web-storage/ WebStorage的出现是为了弥补cookie的不足,cookie一方面是容量小，4k/8k，存几个电子邮件都不够，二来是全局的，容易被误用，盗用。
在HTML5中网络存储按照生命周期分为2种，一种是基于会话(session),这种存储周期只是当前会话，当网页[注1]被关被后，或者被转到其他网站后，存储也就被销毁；

sessionStorage.varName = “生成新变量”;
sessionStorage.varName = “变量操作”;
delete sessionStorage.varName;  //删除变量

另外一种是本地存储，当网页下次被打开的时候，你仍然可以访问上次打开该网页时存储的数据，比如本地存储的网站用户名就可以使用这种方式。
用法和基于会话的存储一样，只是前缀名改成了localStorage

localStorage.varName = “生成新变量”;
localStorage.varName = “变量操作”;
delete localStorage.varName;  //删除变量

从上面可以看出web storage其实也只是解决了轻量级的数据存储问题，如果是大量的数据查询，比如商品列表，还是得靠数据库,HTML5中有Web Database来支持这一操作，基本操作和SQL一致。
注1：现在的浏览器基本都支持多窗口了，一个窗口对应一个网页
注2：官方参考

]]> http://software.intel.com/zh-cn/blogs/2011/12/26/html5web-storage/feed/ 0 android多媒体-----AsyncPlayer http://software.intel.com/zh-cn/blogs/2011/12/16/android-asyncplayer/ http://software.intel.com/zh-cn/blogs/2011/12/16/android-asyncplayer/#comments Fri, 16 Dec 2011 03:58:46 +0000 blacklee http://software.intel.com/zh-cn/blogs/2011/12/16/android-asyncplayer/ AsyncPlayer是android实现异步音乐播放的一个类，它将要播放的媒体文件封装成内部类Command
private static final class Command {
int code; //PLAY = 1 ,STOP = 2
Context context; //上下文
Uri uri; //文件uri
boolean looping; //是否循环
int stream; //audio stream type
long requestTime;
//......
}
}
为了实现多个音乐播放，所有command都加在了 LinkedList中
当调用play或者stop方法的时候，会根据参数封装成一个command对象，启动一个thread,thread中会把LinkedList的第一个command弹出，根据command的code去判断是要播放还是停止，播放调用startSound（）方法，停止则释放所有资源，当LinkedList中没有command，线程便停止。

]]> http://software.intel.com/zh-cn/blogs/2011/12/16/android-asyncplayer/feed/ 0 java多线程 sleep()和wait()的区别 http://software.intel.com/zh-cn/blogs/2011/12/16/java-sleepwait/ http://software.intel.com/zh-cn/blogs/2011/12/16/java-sleepwait/#comments Fri, 16 Dec 2011 03:58:16 +0000 octobershiner http://software.intel.com/zh-cn/blogs/2011/12/16/java-sleepwait/ 接触了一些多线程的东西，还是从java入手吧。

相信看这篇文章的朋友都已经知道进程和线程的区别，也都知道了为什么要使用多线程了。

这两个方法主要来源是，sleep用于线程控制，而wait用于线程间的通信，与wait配套的方法还有notify和notifyAll.

区别一：

sleep是Thread类的方法，是线程用来 控制自身流程的，比如有一个要报时的线程，每一秒中打印出一个时间，那么我就需要在print方法前面加上一个sleep让自己每隔一秒执行一次。就像个闹钟一样。

wait是Object类的方法，用来线程间的通信，这个方法会使当前拥有该对象锁的进程等待知道其他线程调用notify方法时再醒来，不过你也可以给他指定一个时间，自动醒来。这个方法主要是用走不同线程之间的调度的。

区别二 ：

关于锁的释放 ，在这里假设大家已经知道了锁的概念及其意义。调用sleep方法不会释放锁（自己的感觉是sleep方法本来就是和锁没有关系的，因为他是一个线程用于管理自己的方法，不涉及线程通信）

JDK 7 中的解释：

“public static void sleep(long millis)

throws InterruptedException
Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds, subject to the precision and accuracy of system timers and schedulers.The thread does not lose ownership of any monitors.

public final void wait() throws InterruptedException
Causes the current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object. In other words, this method behaves exactly as if it simply performs the call wait(0).The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method the notifyAll method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.“
调用wait方法会释放当前线程的锁（其实线程间的通信是靠对象来管理的，所有操作一个对象的线程是这个对象通过自己的wait方法来管理的，就好像这个对象是电视机，三个人是三个线程，那么电视机的遥控器就是这个锁，假如现在A拿着遥控器，电视机调用wait方法，那么A就交出自己的遥控器，由jVM虚拟机调度，遥控器该交给谁。）【我想到一个好玩的例子：如果A拿遥控器的期间，他可以用自己的sleep每隔十分钟调一次电视台，而在他调台休息的十分钟期间，遥控器还在他的手上~】

区别三：

使用区域

由于wait函数的特殊意义，所以他是应该放在同步语句块中的，这样才有意义 。

注意：两个方法都需要抛出异常

个人见解：有sleep和wait的第二个区别，引起了我对Java线程机制的一个疑问，目前还没有看过JDk这方面的源码（其实看了，是木有看懂），线程的同步管理，是不是由对象在调度，如果是对象在调度，那么JDK 1.5新引入的ReentrantLock机制就比synchronized关键字更值得提倡。因为他更能反映出这么一个机制来。好多人不能理解wait和sleep的区别，我认为就是因为synchronized关键字的影响。当然自己还不懂JAVA的线程具体实现，留作疑问以后有时间继续研究吧

这个小专题貌似是学长学姐们经常面面试的题目，感谢他们的经验分享~

]]> http://software.intel.com/zh-cn/blogs/2011/12/16/java-sleepwait/feed/ 0 设计模式学习----观察者模式（事件监听实现） http://software.intel.com/zh-cn/blogs/2011/12/16/400009402/ http://software.intel.com/zh-cn/blogs/2011/12/16/400009402/#comments Fri, 16 Dec 2011 03:57:52 +0000 octobershiner http://software.intel.com/zh-cn/blogs/2011/12/16/400009402/ 今天分享一个设计模式----观察者模式，其实这种设计模式，我们早就接触过，做过GUI编程的同学肯定会知道，事件的注册监听等机制，其实这个机制的实现就是利用了观察者模式。
可能在程序中，我们需要在某些数据变化时，其他的类做出一些响应，我们总不能开一个线程，每隔一段时间就去检测数据有没有发生变化吧，那样效率很低，我们更希望那些具有变化属性的类能够主动将自己的变化推送给，希望检测这些变化的其他类。正如我们去医院排队，不能隔两分钟就去问大夫“轮到我了吗”，而是坐在那里等大夫的通知，大家都接收到一个名字信号，叫到谁谁就去~ 而观察者就是这样一种模式，大夫的名单就是被观察者，也叫做一个 主题。每一个病人就是一个观察者。因而，观察者模式也叫做 发布订阅模式（相信使用google reader的朋友更容易理解）。
下面 是一副来自维基百科的结构图

可以看出来，观察者模式，是一种一对多的关系，即多个观察者监听一个主题。
下面用一段代码给大家解释 观察者模式，通过这个例子，大家也可以看到一个缩水版的 事件监听机制的实现~我自己编写了一个交通灯的例子，应该比较形象
首先创建一个主题接口，他声明了一个被观察者应该具有的基本方法，包括添加观察者，删除观察者，通知
package observerpattern;

/**
*
* @author liyang
* 2011 08 2
* 主题的接口 定义标准的方法
*/
public interface Subject {
public void addListener(Listener listener);
public void deleteListener(Listener listener);
public void notifyListener();

}
接下来我们用一个类实现这个接口，所创建的类也就是我们具体要观察的对象了

package observerpattern;

import java.util.ArrayList;

/**
*
* @author liyang
* 2011 08 2
* SE.HIT
* 实现主题的类，相当于图中的ConcretSubject A
*/
public class Lights implements Subject{

private ArrayList lights; //collection 用于保存 观察者的集合
private String whichLight;
private String currentLight = "green"; //记录当前 交通灯的状态
private int time; //记录交通灯持续的时间

public Lights(){
lights = new ArrayList();
}
//实现 添加一个观察者的操作
@Override
public void addListener(Listener listener){
lights.add(listener);
}
//实现删除一个观察者的操作
@Override
public void deleteListener(Listener listener){
int index = lights.indexOf(listener);
if( index != -1){
lights.remove(index);
}
}
//实现通知的机制 ，通知每一个观察者
public void notifyListener(){
int size = lights.size();
for(int i = 0; i < size; i++){
Listener listener = (Listener)lights.get(i);
listener.updateSignal(whichLight,time);
}
}
//更新主题状态数据的方法
public void setLight(String whichlight,int time){
this.whichLight = whichlight;
this.time = time;
//检查状态是否发生了变化
check();
this.currentLight = whichLight;
}
//实现检查状态的函数
private void check(){
if(! this.currentLight.equals(this.whichLight)){
notifyListener();
}
}
}

里面涉及了一些arrayList的东西，不清楚的同学可以好好了解一下arraylist，他里面有个Fail Fast机制，从中你可以学习到更为精彩的装饰器模式，在这里不多解释了，我博客中有一篇相关的总结
下面我们编写一个 观察者的接口，他声明观察者对通知做出的反应的方法
package observerpattern;

/**
* @author liyang
* 2011 08 2
* 定义观察者接口 声明更新方法
*/
public interface Listener {
public void updateSignal(String whichLight,int time);
}

最后就是编写 观察者了，本例子中我们拥有三个观察者，分别观察红黄绿等是否被打开，然后各自做出相应的通知
package observerpattern;
/**
*
* @author liyang
* 2011 08 02
* SE.HIT
* 实现红色交通灯的观察者类，相当于图中国的ConcretObserver类
*/
public class RedLightListener implements Listener{
@Override
//模拟接收通知，更新状态
public void updateSignal(String whichLight, int time){
if(whichLight.equals("red")){
System.out.println("红灯亮了，禁止通行");
System.out.println("持续时间： "+time);
}
}

}

package observerpattern;
/**
*
* @author liyang
* 2011 08 02
* SE.HIT
* 实现黄色交通灯的观察者类
*/
public class YellowLightListener implements Listener{
@Override
//模拟接收通知，更新状态
public void updateSignal(String whichLight,int time){
if(whichLight.equals("yellow")){
System.out.println("黄灯亮了，请稍等");
System.out.println("持续时间： "+ time);
}
}

}

package observerpattern;

/**
*
* @author liyang
* 2011 08 02
* SE.HIT
* 实现绿色交通灯的观察者类
*/
public class GreenLightListener implements Listener{
@Override
//模拟接收通知，更新状态
public void updateSignal(String whichLight,int time){
if(whichLight.equals("green")){
System.out.println("绿灯亮了，请通过");
System.out.println("持续时间： "+time);
}
}

}

最后就是一个演示的main了
package observerpattern;

/**
*
* @author liyang
* 2011 08 02
* SE.HIT
* 演示设计模式---观察者模式的demo
*/
public class ObserverPattern {

public static void main(String[] args) {
// TODO code application logic here
//创建主题，被监听对象，通常是一个自身状态属性可变的类
Lights lights = new Lights();

//创建三个观察者实例
YellowLightListener yellow = new YellowLightListener();
GreenLightListener green = new GreenLightListener();
RedLightListener red = new RedLightListener();
//向主题注册三个观察者，监听变化
lights.addListener(green);
lights.addListener(red);
lights.addListener(yellow);
//手动的改变交通灯的状态
lights.setLight("red",30);
lights.setLight("yellow", 10);
lights.setLight("green", 20);
}
}
最后的输出结果为
run：
红灯亮了，禁止通行
持续时间： 30
黄灯亮了，请稍等
持续时间： 10
绿灯亮了，请通过
持续时间： 20
成功生成（总时间：0 秒）

这就是一个比较完整的观察者模式的例子，大家应该很熟悉，我们平时addListener的时候就是在添加 观察者的~

]]> http://software.intel.com/zh-cn/blogs/2011/12/16/400009402/feed/ 0 8款浏览器对HTML5支持评测 http://software.intel.com/zh-cn/blogs/2011/12/16/8html5/ http://software.intel.com/zh-cn/blogs/2011/12/16/8html5/#comments Fri, 16 Dec 2011 03:56:28 +0000 MR.G http://software.intel.com/zh-cn/blogs/2011/12/16/8html5/ HTML的上一个版本诞生于1999年，从那以后，Web世界就发生了巨变，而现在的HTML5炒得火热朝天，势头之猛犹有再次创造Web历史变革的趋势。HTML5仍处于完善之中，然而，现在大部分浏览器已经开始具备对HTML5的支持了，当然，各大浏览器的开发还在继续，将来应该会全面支持HTML5的，现在我选择了8款浏览器（中外各四款），对其支持HTML5的程度进行了测试，测试内容来自html5test网站。感兴趣的人可以去测试一下！！

当然每个浏览器的好坏不是仅凭这个就可以定义的，并且即使浏览器的功能再强大，界面再漂亮，也不一定就是你心目中最好的浏览器，因为我觉得浏览器的使用涉及到一个习惯问题，用习惯了自然就觉得好了，根本不会去考虑它功能是否强大。另外现实生活中我们使用浏览器，虽然其功能十分强大，十分完善，但是并不是每个人都能完全用到所有功能的。

所以，我做这个测试是没有感情色彩的，只是测试哈！！！至于哪个浏览器好，哪个浏览器差，各位看官自己点评吧！！

我测试的8款浏览器分别是（国外）Chrome 15.0.874，IE 9.0.8112，Firefox 8.0.1，Opera 11.52

（国内）360浏览器 4.0.3.8，搜狗浏览器 3.1.0.3688，遨游浏览器v3.2.2.1000，QQ浏览器 6.8(10793)

这8款浏览器不出意外应该都是现在的最新版本！！！

首先贴上我的硬件（QQ管家测的）：

现在来看看8款浏览器的总分（顺序就是我上边列的顺序哈，不代表排名顺序）：

1。Chrome

2。IE 9

3。Firefox

4。Opera （我看到别人测的是Opera12的分数为325，我是昨天从Opera官网下的啊，怎么会不是最新版的？？？）

5。360浏览器

6。搜狗浏览器

7。遨游浏览器

8。QQ浏览器

这么看来还是Chrome小胜啊！嗯，搜狗浏览器在对HTML5的支持上也很给力的！QQ浏览器有点没跟上节奏啊！！！！

下面让我们详细看看这8种浏览器对HTML5的支持情况：

OK！大概就是这样了，还是Chrome对HTML5支持的好一些，虽然国外的浏览器都大部分支持了HTML5，但国内的浏览器也不甘落后啊，搜狗和遨游还是很给力的！

HTML5还在发展完善，我相信在不久的将来，各个浏览器都会全面支持HTML5的。让我们静观其变吧！！

]]> http://software.intel.com/zh-cn/blogs/2011/12/16/8html5/feed/ 0 android 获取手机GSM/CDMA信号信息 http://software.intel.com/zh-cn/blogs/2011/12/16/android-gsmcdma/ http://software.intel.com/zh-cn/blogs/2011/12/16/android-gsmcdma/#comments Fri, 16 Dec 2011 03:55:45 +0000 wangxinasy http://software.intel.com/zh-cn/blogs/2011/12/16/android-gsmcdma/ 在Android中我们常用的轻松获取WIFI信号列表，那如何获取CDMA或者GSM的手机信号呢？
系统提供了TelephonyManager类，此类非常丰富，基本你所需要的手机信息都能获取到，那下面就来看看我们所需要的CDMA与GSM信号是如何获取的吧。

private TelephonyManager telephonyManager;
private PhoneStateListener phoneStateListener;
首先声明两个变量

在onCreate()方法中初始化变量
InitPhoneStateListener();
telephonyManager = (TelephonyManager) this.ctx.getSystemService(Context.TELEPHONY_SERVICE);
telephonyManager.listen(phoneStateListener, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS);
telephonyManager.listen(phoneStateListener,PhoneStateListener.LISTEN_CELL_LOCATION);
if(telephonyManager.getCellLocation()!=null){
//获取当前基站信息
phoneStateListener.onCellLocationChanged(telephonyManager.getCellLocation());
}

/** 初始化PhoneStateListener */
private void InitPhoneStateListener() {
phoneStateListener = new PhoneStateListener() {
@Override
public void onCellLocationChanged(CellLocation location) {
// TODO Auto-generated method stub
if (location instanceof GsmCellLocation) {// gsm网络
phoneType = 1;
GsmCell gsmCell = new GsmCell();
gsmCell.lac = ((GsmCellLocation) location).getLac();
gsmCell.cid = ((GsmCellLocation) location).getCid();
/** 获取mcc，mnc */
String mccMnc=telephonyManager.getNetworkOperator();
if(mccMnc!=null&&mccMnc.length()>=5){
gsmCell.mcc = mccMnc.substring(0, 3);
gsmCell.mnc = mccMnc.substring(3, 5);
}
gsmCell.signal=lastSignal;
gsmCell.time = System.currentTimeMillis();
if (gsmCell.lac != -1 && gsmCell.cid != -1) {
gsmCells.add(0, gsmCell);
// Collections.sort(gsmCells);
// /**最多保存近3个基站信息*/
// if (gsmCells.size() >3)
// gsmCells.remove(3);
}
//获取相邻基站信息
List neighboringList=telephonyManager.getNeighboringCellInfo();
for(NeighboringCellInfo ni:neighboringList){
GsmCell gb = new GsmCell();
gb.mnc=mccMnc.substring(3, 5);
gb.lac=ni.getLac();
gb.cid=ni.getCid();
gb.signal=-133+2*ni.getRssi();
gb.time=System.currentTimeMillis();
gsmCells.add(gb);
}
} else {// 其他CDMA等网络
try {
Class cdmaClass = Class.forName("android.telephony.cdma.CdmaCellLocation");
phoneType = 2;
CdmaCellLocation cdma = (CdmaCellLocation) location;
CdmaCell cdmaCell = new CdmaCell();
cdmaCell.stationId = cdma.getBaseStationId() >= 0 ?
cdma.getBaseStationId(): cdmaCell.stationId;
cdmaCell.networkId = cdma.getNetworkId() >= 0 ? cdma
.getNetworkId() : cdmaCell.networkId;
cdmaCell.systemId = cdma.getSystemId() >= 0 ? cdma
.getSystemId() : cdmaCell.systemId;
/** 获取mcc，mnc */
String mccMnc=telephonyManager.getNetworkOperator();
if(mccMnc!=null&&mccMnc.length()>=5){
cdmaCell.mcc = mccMnc.substring(0, 3);
cdmaCell.mnc = mccMnc.substring(3, 5);
}
cdmaCell.signal=lastSignal;
cdmaCell.time = System.currentTimeMillis();
int lat = cdma.getBaseStationLatitude();
int lon = cdma.getBaseStationLongitude();
if (lat <Integer.MAX_VALUE&& lon <Integer.MAX_VALUE) {
cdmaCell.lat = lat;
cdmaCell.lon = lon;
}
if (cdmaCell.stationId != -1&& cdmaCell.networkId != -1&& cdmaCell.systemId != -1) {
cdmaCells.add(0, cdmaCell);
}
List neighboringList=telephonyManager.getNeighboringCellInfo();
for(NeighboringCellInfo ni:neighboringList){
CdmaCell cdmaBean = new CdmaCell();
cdmaBean.systemId=cdmaCell.systemId;
cdmaBean.lac=ni.getLac();
cdmaBean.cellid=ni.getCid();
cdmaBean.signal=-113+2*ni.getRssi();
cdmaCells.add(cdmaBean);
}
} catch (ClassNotFoundException classnotfoundexception) {
}
}// end CDMA网络
super.onCellLocationChanged(location);
}// end onCellLocationChanged

@Override
public void onServiceStateChanged(ServiceState serviceState) {
// TODO Auto-generated method stub
super.onServiceStateChanged(serviceState);
}
@Override
public void onSignalStrengthsChanged(SignalStrength signalStrength) {
// TODO Auto-generated method stub
int asu=signalStrength.getGsmSignalStrength();
lastSignal=-113+2*asu; //信号强度
super.onSignalStrengthsChanged(signalStrength);
}
};
}// end InitPhoneStateListener
其实很简单，只要写好了监听类，一切信号都可以获取得到。
这样，我们很轻松的就获取到了手机信号及周围基站的信号强度了，当然，需要的读取手机状态等的权限就在这里不说了。

作者：sojex
Email:w.sojex@gmail.com

]]> http://software.intel.com/zh-cn/blogs/2011/12/16/android-gsmcdma/feed/ 0 动态规划算法 http://software.intel.com/zh-cn/blogs/2011/11/29/400009261/ http://software.intel.com/zh-cn/blogs/2011/11/29/400009261/#comments Tue, 29 Nov 2011 05:56:18 +0000 liuyueyi http://software.intel.com/zh-cn/blogs/2011/11/29/400009261/ 动态规划是运筹学的一个分支，是求解决策过程最优化的数学方法，在解决实际问题中经常被使用。
然而它本身或许不是很好理解，这里做一下本人对它的理解。
动态规划三要素：阶段，状态，决策
1、阶段是对整个过程的自然划分
2、状态表示每个阶段开始时过程所处的自然状况
3、当一个阶段的状态确定后，可以作出各种选择从而演变到下一阶段的某个状态，这种选择手段称为决策
找出此类问题的关键：
1、能够用动态规划来求解（这是基本前提）
利用最优性原理来进行判断（这里不做解释）
2、获得状态转移方程（这是重点）
可以看做动态规划求解实际问题的时候，就是来获得当某阶段的状态和决策为已知，下阶段的状态可以通过该阶段来表示出来，而且它们之间满足一个状态转移方程：X[k+1]=T[k](X[k],U[k](X[k]))
3、根据题目要求对决策过程中产生的中间状态进行选取（如0/1背包问题中要求不超过重量上限的情况下获得最大效益，这里面获得大效益便是一个限制条件，可以用来在中间决策中产生的状态中进行选择

这里总结一下一般思路：
拿到多阶段决策最优化问题后，第一步要判断这个问题是否可以用动态规划解决，如果不能就要考虑搜索或贪心了。当确定问题可以用动态规划后，就要用下面介绍的方法解决问题了：
（1）模型匹配法：
最先考虑的就是这个方法了。挖掘问题的本质，如果发现问题是自己熟悉的某个基本的模型，就直接套用，但要小心其中的一些小的变动，现在考题办都是基本模型的变形套用时要小心条件，三思而后行。这些基本模型在先面的分类中将一一介绍。
（2）三要素法
仔细分析问题尝试着确定动态规划的三要素，不同问题的却定方向不同：
先确定阶段的问题：数塔问题，和走路问题
先确定状态的问题：大多数都是先确定状态的。
先确定决策的问题：背包问题
（3）寻找规律、拼凑法：
这个方法很简单，耐心推几组数据后，看他们的规律，总结规律间的共性，这里一般可以比较容易的得到状态转移方程，也就是确定下一阶段与前一阶段之间的联系
（4）边界条件法
找到问题的边界条件，然后考虑边界条件与它的领接状态之间的关系。这个方法也很起效。
（5）放宽约束和增加约束
这个思想是在陈启锋的论文里看到的，具体内容就是给问题增加一些条件或删除一些条件使问题变的清晰。

]]> http://software.intel.com/zh-cn/blogs/2011/11/29/400009261/feed/ 0 HTML5之Worker Thread http://software.intel.com/zh-cn/blogs/2011/11/22/html5worker-thread/ http://software.intel.com/zh-cn/blogs/2011/11/22/html5worker-thread/#comments Tue, 22 Nov 2011 08:33:18 +0000 章政 http://software.intel.com/zh-cn/blogs/2011/11/22/html5worker-thread/ 传统网页中嵌入的JSP语言都是执行在UI的上下文中，一般来说这种JSP处理的都是简单逻辑，没啥问题，随着Web复杂度越来高，JSP能处理的事情也越来越复杂，如果JSP计算量比较大的话，这就会导致UI页面假死。HTML5中的WorkerThread可以缓解这个问题，Worker Thread通过UI thread创建一个新的线程来进行计算，消息和结果通过Web Message来进行通讯，由于这种异步性，UI便可以较为流畅地响应新到来的事件。
调用过程如下：
1.新的工作线程执行体放在一个单独的JS文件中，比如worker.js.

self.onmessage = function(event){
        //do the real compute ---begin
        //
        //do the real compute ---end
        //post message back to UI thread
	self.postMessage(XXXX);
};

2.在UI的执行线程中生成一个worker对象，worker对象的构造函数参数就是worker.js

var worker = new Worker("worker.js");

3.下面就可以发送消息让worker干活了

worker.postMessage("perise");

4.活干完了给UI发送消息,也就是第一步中的

self.postMessage(XXXX);

5.UI进行响应

worker.onmessage = function(event){
                        //update UI here
			};

Notes:
*在Chrome中调试的时候会出现SECURITY_ERR: DOM Exception 18，传说是Webkit的bug,没有细究，可以通过搭建一个本地的HTTP服务器来解决，把HTML文件放到本地服务器上就可以绕开这个安全问题了，我使用的是WAMP。
*也许是为了控制Worker Thread的复杂度，Chrome的Worker Thread中不能再生成新的worker thread，其实这个很容易绕开，发送一个消息到UI中，让UI生成新的Worker Thread就好,Firefox可以支持subworker,但Chrome是可以支持sharework，这种shareworker可以共享JS文件里面的全局数据。

]]> http://software.intel.com/zh-cn/blogs/2011/11/22/html5worker-thread/feed/ 0 OpenCL 1.2 发布啦 http://software.intel.com/zh-cn/blogs/2011/11/17/opencl-12/ http://software.intel.com/zh-cn/blogs/2011/11/17/opencl-12/#comments Thu, 17 Nov 2011 06:46:17 +0000 章政 http://software.intel.com/zh-cn/blogs/2011/11/17/opencl-12/ Khronos发布了OpenCL的更新版OpenCL 1.2
相对于1.1来说，没有太多的变化，保持了前向兼容。

The new OpenCL 1.2 specification released on November 15th 2011, provides enhanced performance and functionality in response to requests from the developer community – while retaining backwards compatibility with OpenCL 1.0 and 1.1. New features in OpenCL 1.2 include seamless sharing of media and surfaces with DirectX® 9 and 11, enhanced image support, custom devices and kernels, device partitioning and separate compilation and linking of objects.

具体参考文档见OpenCL老巢
关于OpenCL未来的发展方向，可能会演化出2个版本，一个版本是朝上发展，API对于程序员更为友好。目前无论是OpenCL还是CUDA，对程序员都是不太友好，写出一个高性能的并行程序，需要了解太多硬件的细节和调试；另一个方向就是向下了，OpenCL的中间码，相当于汇编，能更细粒度的操作硬件,在这个层次上，程序员可以充分挖掘某款硬件的性能，当然前提是程序员需要对硬件有足够的了解。技术再好，不能为大众服务也是白搭，搭上WEB这趟车，马上就能大众化，OpenCL也没有落后，Web版本的OpenCL(WebCL)也在紧锣密鼓制定当中。具体可以参考OpenCL主席的访谈。如果以后浏览器都能支持WebCL加速的话，用JSP/ASP这种脚本语言也可以轻松完成搞性能计算了，其实我觉得这个比较有吸引力，空闲的机器，打开某个网页就可以把自己的计算能力贡献出来，这样以后可以轻松通过浏览器来搭建个人高性能计算网络，神马超算中心都是浮云。

]]> http://software.intel.com/zh-cn/blogs/2011/11/17/opencl-12/feed/ 0