iOS：通过让本地代码拦截JavaScript中调用的 window.location=”gap://Class.method/args”命令，来实现从JavaScript到本地代码之间的通信。在本地 代码拦截该命令后，解析获取的参数，然后调用对应的类、方法并传递参数。对应的，使用 UIWebView.stringByEvaluatingJavaScriptFromString来实现本地代码调用JavaScript。

Android：通 过拦截JavaScript的prompt命令实现从JavaScript到本地代码的通信。JavaScript prompt命令默认会弹出对话框，而PhoneGap的Android本地代码会拦截该对话框，并进一步取得JavaScript数据。相应 的，Android上的PhoneGap内部，使用Java实现了一个HTTP服务器，通过持久性的XHR连接，JavaScript可以不断轮询内部 XHR服务器存储的信息，从而实现了从Java到JavaScript方向的通信。

BlackBerry 4.x：JavaScript 与本地代码之间的唯一通信方式是通过document.cookie实现的。JavaScript设定Cookie，本地代码从Cookie中获取信息。 对应的，本地代码也可以设定Cookie，允许JavaScript从Cookie中获取本地代码信息。

BlackBerry WebWorks：新 的BlackBerry WebWorks SDK更好地支持了Java与JavaScript之间的交互通信。通过ScriptEngine.addExtension，Java对象可以被暴露给 JavaScript，而对应的Java可以使用ScriptEngine.executeScript来调用JavaScript。

Windows Phone 7：在Windows Phone 7中，JavaScript通过window.external.Notify可以将信息发送给本地代码。而相应的，WebBrowser.InvokeScript允许本地代码调用JavaScript。

在Android的设计中，资源的访问或者网络连接，要得到这些服务都需要声明其访问权限，否则将无法正常工作。在Android中这样的权限有很多种，这里将各类访问权限一一罗列出来，供大家使用时参考之用。

android.permission.EXPAND_STATUS_BAR
允许一个程序扩展收缩在状态栏,android开发网提示应该是一个类似Windows Mobile中的托盘程序

android.permission.FACTORY_TEST
作为一个工厂测试程序，运行在root用户

android.permission.FLASHLIGHT
访问闪光灯,android开发网提示HTC Dream不包含闪光灯

android.permission.FORCE_BACK
允许程序强行一个后退操作是否在顶层activities

android.permission.FOTA_UPDATE
暂时不了解这是做什么使用的，android开发网分析可能是一个预留权限.

android.permission.GET_ACCOUNTS
访问一个帐户列表在Accounts Service中

android.permission.GET_PACKAGE_SIZE
允许一个程序获取任何package占用空间容量

android.permission.GET_TASKS
允许一个程序获取信息有关当前或最近运行的任务，一个缩略的任务状态，是否活动等等

android.permission.HARDWARE_TEST
允许访问硬件

android.permission.INJECT_EVENTS
允许一个程序截获用户事件如按键、触摸、轨迹球等等到一个时间流，android 开发网提醒算是hook技术吧

android.permission.INSTALL_PACKAGES
允许一个程序安装packages

android.permission.INTERNAL_SYSTEM_WINDOW
允许打开窗口使用系统用户界面

android.permission.ACCESS_CHECKIN_PROPERTIES
允许读写访问“properties”表在checkin数据库中，改值可以修改上传。

android.permission.ACCESS_COARSE_LOCATION
允许一个程序访问CellID或WiFi热点来获取粗略的位置

android.permission.ACCESS_FINE_LOCATION
允许一个程序访问精良位置(如GPS)

android.permission.WRITE_CONTACTS
允许程序写入但不读取用户联系人数据

android.permission.WRITE_GSERVICES
允许程序修改Google服务地图

android.permission.WRITE_OWNER_DATA
允许一个程序写入但不读取所有者数据

android.permission.WRITE_SETTINGS
允许程序读取或写入系统设置

android.permission.WRITE_SMS
允许程序写短信

android.permission.WRITE_SYNC_SETTINGS
允许程序写入同步设置

android.permission.ACCESS_LOCATION_EXTRA_COMMANDS
允许应用程序访问额外的位置提供命令

android.permission.ACCESS_MOCK_LOCATION
允许程序创建模拟位置提供用于测试

android.permission.ACCESS_NETWORK_STATE
允许程序访问有关GSM网络信息

android.permission.ACCESS_SURFACE_FLINGER
允许程序使用SurfaceFlinger底层特性

android.permission.ACCESS_WIFI_STATE
允许程序访问Wi-Fi网络状态信息

android.permission.ADD_SYSTEM_SERVICE
允许程序发布系统级服务

android.permission.BATTERY_STATS
允许程序更新手机电池统计信息

android.permission.BLUETOOTH
允许程序连接到已配对的蓝牙设备

android.permission.BLUETOOTH_ADMIN
允许程序发现和配对蓝牙设备

android.permission.BROADCAST_PACKAGE_REMOVED
允许程序广播一个提示消息在一个应用程序包已经移除后

android.permission.BROADCAST_STICKY
允许一个程序广播常用intents

android.permission.CALL_PHONE
允许一个程序初始化一个电话拨号不需通过拨号用户界面需要用户确认

android.permission.DELETE_CACHE_FILES
允许程序删除缓存文件

android.permission.DELETE_PACKAGES
允许一个程序删除包

android.permission.DEVICE_POWER
允许访问底层电源管理

android.permission.DIAGNOSTIC
允许程序RW诊断资源

android.permission.DISABLE_KEYGUARD
允许程序禁用键盘锁

android.permission.DUMP
允许程序返回状态抓取信息从系统服务

android.permission.CALL_PRIVILEGED
允许一个程序拨打任何号码，包含紧急号码无需通过拨号用户界面需要用户确认

android.permission.CAMERA
请求访问使用照相设备

android.permission.CHANGE_COMPONENT_ENABLED_STATE
允许一个程序是否改变一个组件或其他的启用或禁用

android.permission.CHANGE_CONFIGURATION
允许一个程序修改当前设置，如本地化

android.permission.CHANGE_NETWORK_STATE
允许程序改变网络连接状态

android.permission.CHANGE_WIFI_STATE
允许程序改变Wi-Fi连接状态

android.permission.CLEAR_APP_CACHE
允许一个程序清楚缓存从所有安装的程序在设备中

android.permission.CLEAR_APP_USER_DATA
允许一个程序清除用户设置

android.permission.CONTROL_LOCATION_UPDATES
允许启用禁止位置更新提示从无线模块

android.permission.REBOOT
请求能够重新启动设备

android.permission.RECEIVE_BOOT_COMPLETED
允许一个程序接收到 ACTION_BOOT_COMPLETED广播在系统完成启动

android.permission.RECEIVE_MMS
允许一个程序监控将收到MMS彩信,记录或处理

android.permission.RECEIVE_SMS
允许程序监控一个将收到短信息，记录或处理

android.permission.RECEIVE_WAP_PUSH
允许程序监控将收到WAP PUSH信息

android.permission.RECORD_AUDIO
允许程序录制音频

android.permission.REORDER_TASKS
允许程序改变Z轴排列任务

android.permission.RESTART_PACKAGES
允许程序重新启动其他程序

android.permission.SEND_SMS
允许程序发送SMS短信

android.permission.INTERNET
允许程序打开网络套接字

android.permission.MANAGE_APP_TOKENS
允许程序管理(创建、催后、 z- order默认向z轴推移)程序引用在窗口管理器中

android.permission.MASTER_CLEAR目前还没有明确的解释，android开发网分析可能是清除一切数据，类似硬格机

android.permission.MODIFY_AUDIO_SETTINGS
允许程序修改全局音频设置

android.permission.MODIFY_PHONE_STATE
允许修改话机状态，如电源，人机接口等

android.permission.MOUNT_UNMOUNT_FILESYSTEMS
允许挂载和反挂载文件系统可移动存储

android.permission.PERSISTENT_ACTIVITY
允许一个程序设置他的activities显示

android.permission.PROCESS_OUTGOING_CALLS
允许程序监视、修改有关播出电话

android.permission.READ_CALENDAR
允许程序读取用户日历数据

android.permission.READ_CONTACTS
允许程序读取用户联系人数据

android.permission.READ_FRAME_BUFFER
允许程序屏幕波或和更多常规的访问帧缓冲数据

android.permission.READ_INPUT_STATE
允许程序返回当前按键状态

android.permission.READ_LOGS
允许程序读取底层系统日志文件

android.permission.READ_OWNER_DATA
允许程序读取所有者数据

android.permission.READ_SMS
允许程序读取短信息

android.permission.READ_SYNC_SETTINGS
允许程序读取同步设置

android.permission.READ_SYNC_STATS
允许程序读取同步状态

android.permission.SET_ACTIVITY_WATCHER
允许程序监控或控制activities已经启动全局系统中

android.permission.SET_ALWAYS_FINISH
允许程序控制是否活动间接完成在处于后台时

android.permission.SET_ANIMATION_SCALE
修改全局信息比例

android.permission.SET_DEBUG_APP
配置一个程序用于调试

android.permission.SET_ORIENTATION
允许底层访问设置屏幕方向和实际旋转

android.permission.SET_PREFERRED_APPLICATIONS
允许一个程序修改列表参数PackageManager.addPackageToPreferred() 和PackageManager.removePackageFromPreferred()方法

android.permission.SET_PROCESS_FOREGROUND
允许程序当前运行程序强行到前台

android.permission.SET_PROCESS_LIMIT
允许设置最大的运行进程数量

android.permission.SET_TIME_ZONE
允许程序设置时间区域

android.permission.SET_WALLPAPER
允许程序设置壁纸

android.permission.SET_WALLPAPER_HINTS
允许程序设置壁纸hits

android.permission.SIGNAL_PERSISTENT_PROCESSES
允许程序请求发送信号到所有显示的进程中

android.permission.STATUS_BAR
允许程序打开、关闭或禁用状态栏及图标Allows an application to open, close, or disable the status bar and its icons.

android.permission.SUBSCRIBED_FEEDS_READ
允许一个程序访问订阅RSS Feed内容提供

android.permission.SUBSCRIBED_FEEDS_WRITE
系统暂时保留改设置,android开发网认为未来版本会加入该功能。

android.permission.SYSTEM_ALERT_WINDOW
允许一个程序打开窗口使用 TYPE_SYSTEM_ALERT，显示在其他所有程序的顶层

android.permission.VIBRATE
允许访问振动设备

android.permission.WAKE_LOCK
允许使用PowerManager的 WakeLocks保持进程在休眠时从屏幕消失

android.permission.WRITE_APN_SETTINGS
允许程序写入API设置

android.permission.WRITE_CALENDAR
允许一个程序写入但不读取用户日历数据

可以看出Android中对资源以及服务的访问都非常严格，另外，在程序打包成APK的时候也需要对软件进行签名。

1.SIN2IMG    

　　用于固件ftf中system.sin的解包   

　　下载地址: SIN2IMG.rar  

　　使用方法:将固件ftf文件用rar打开，解压出system.sin文件，将该文件于SIN2IMG.exe放在同一个文件夹里面，比如说 X:\下，进入CMD，用cd命令进入X:\目录，输入SIN2IMG.exe system.sin system.img稍等一会，system.img就解包出来了。

2.unyaffs     

　　用于system.img文件的解包     

　　下载地址:  Unyaffs.rar  

　　使用方法:将上一步解包出来的system.img文件与下载好的unayffs.exe文件放在同一个文件夹里面，比如说X:\下，进入 CMD，用cd命令进入X:\目录，输入unyaffs.exe system.img稍等一会，system.img中的内容即可解包出来，包含有rom的全部程序和其他内容。

3.Cygwin  

　　Htc厨房，适用于win环境下自制rom(非linux下使用的版本)，包括预root、创建刷机脚本、App2SD、开机脚本设定等以及rom打包签名。     

　　下载地址:http://u.115.com/file/bhzeovtf ( 已修复不能解压问题 )       

　　使用方法:解压下载好的rar文件，比如解压到X:\目录下。进入X:\Cygwin目录，找到Cygwin.bat文件，右键选择编辑,看到 这一行:chdir d:\cygwin\bin，将其改为chdir X:\cygwin\bin，然后进入X:\Cygwin\home，将user目录改名为你当前操作系统用户的名字（即登录windows时候显示的用 户名），然后返回上级目录双击Cygwin.bat即可打开厨房

4.Rom-Sign     

　　rom签名工具    

　　下载地址: Rom-Sign.rar  

　　使用方法:解压到X:\目录下，将需要签名的rom包(zip包)改名为update.zip，然后双击Sign.bat，生成的update_sign.zip就是签名好的rom。

　　5.APKtool     

　　反编译和回编译以及签名apk工具(如何修改框架、布局、资源文件请自行学习)     

　　下载地址: 1) Apktool_v1.rar这版画面比较亲和适合小白使用                     

　　2) APKtoolv132.rar 这版比较给力，使用说明程序已经很直白了，就不多说了

6.Xtemp     

　　dex解包和打包工具       

　　下载地址: Xtemp.rar  

　　使用方法:将需要解包的.dex文件放置于Xtemp目录下，将.dex文件拖动至dex.bat文件，即可出现批处理窗口，然后选择1解包即 可。解压后是一个完整的文件夹，打包的时候将文件夹拖动至dex.bat文件，即可出现批处理窗口，选择2打包即可完成打包，之后生成打包好的.dex文 件

7.APK manager     

　　批量处理APK工具       

　　下载地址: Apk Manager.rar  

　　使用方法:程序本身已经写的很清楚了，不再过多解释

8.draw9patch     

　　用于索引png文件修改和打包工具    

　　下载地址: 9png.rar  

　　使用方法:先用PS等软件处理图片，然后再用9png来处理，最后用X那个软件打包。

9.Java JDK 

　　Java环境安装程序，这个必须装，不然以上以下的程序有可能运行不了。     

　　下载地址:http://u.115.com/file/bhze9xyf

10.Android-sdk

　　安卓SDK这个就不说了，下了选择你需要的API下载       

　　下载地址:http://u.115.com/file/clg28r43

11.eclipse   

　　最新的Eclipse JAVA编译环境        

　　下载地址:http://u.115.com/file/bhzeezng

12.ADT       

　　下载地址:http://u.115.com/file/bhze92e2

13.Repo:

1 mkdir -p ~/bin 
2 curl "http://php.webtutor.pl/en/wp-content/uploads/2011/09/repo"> ~/bin/repo 
3 chmod a+x ~/bin/repo

14.ROM源代码

CM7完整源码:

1 mkdir -p ~/android/system
2 cd ~/android/system/
3 repo init -u git://github.com/CyanogenMod/android.git -b gingerbread
4 repo sync

原因七：应用程序需要引用第三方提供商自定义的框架（比如，三星的/system/framework目录下有twframework.jar、twframework-res.apk，这个就是三星的UI框架)

Java代码  

1. public class CacheThreadPool {  
2.     public static void main(String[] args) {  
3.         ExecutorService exec=Executors.newCachedThreadPool();  
4.         for(int i=0;i<5;i++)  
5.             exec.execute(new LiftOff());  
6.         exec.shutdown();//并不是终止线程的运行，而是禁止在这个Executor中添加新的任务  
7.     }  
8. }  

Java代码  

1. public interface ExecutorService extends Executor {  
2.   
3.     void shutdown();  
4.   
5.     List<Runnable> shutdownNow();  
6.   
7.     boolean isShutdown();  
8.   
9.     boolean isTerminated();  
10.   
11.     boolean awaitTermination(long timeout, TimeUnit unit)  
12.   
13.     <T> Future<T> submit(Callable<T> task);  
14.   
15.     <T> Future<T> submit(Runnable task, T result);  
16.   
17.     Future<?> submit(Runnable task);  
18.   
19.     <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)  
20.   
21.     <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)  
22.   
23.     <T> T invokeAny(Collection<? extends Callable<T>> tasks)  
24.   
25.     <T> T invokeAny(Collection<? extends Callable<T>> tasks,  
26.                     long timeout, TimeUnit unit)  
27. }  

Java代码  

1. void execute(Runnable command)  

        Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package. This class supports the following kinds of methods:
       
• Methods that create and return an ExecutorService set up with commonly useful configuration settings.
       
• Methods that create and return a ScheduledExecutorService set up with commonly useful configuration settings.
       
• Methods that create and return a "wrapped" ExecutorService, that disables reconfiguration by making implementation-specific methods inaccessible.
       
• Methods that create and return a ThreadFactory that sets newly created threads to a known state.
       
• Methods that create and return a Callable out of other closure-like forms, so they can be used in execution methods requiring Callable.
       

Java代码  

1. public static ExecutorService newCachedThreadPool() {  
2.         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,  
3.                                       60L, TimeUnit.SECONDS,  
4.                                       new SynchronousQueue<Runnable>());  
5.     }  

Java代码  

1. public class ThreadPoolExecutor extends AbstractExecutorService {  
2.     ..........  
3.     private final BlockingQueue<Runnable> workQueue;//这个变量在下面会提到  
4.     ..........  
5. }  

Java代码  

1. public class ThreadPoolExecutor extends AbstractExecutorService {  
2.     ..........  
3.     public void execute(Runnable command) {  
4.         if (command == null)  
5.             throw new NullPointerException();  
6.         if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {  
7.             if (runState == RUNNING && workQueue.offer(command)) {  
8.                 if (runState != RUNNING || poolSize == 0)  
9.                     ensureQueuedTaskHandled(command);  
10.             }  
11.             else if (!addIfUnderMaximumPoolSize(command))  
12.                 reject(command); // is shutdown or saturated  
13.         }  
14.     }  
15.     ..........  
16. }  

Java代码  

1. public class ThreadPoolExecutor extends AbstractExecutorService {  
2.     ..........  
3.     private void ensureQueuedTaskHandled(Runnable command) {  
4.         final ReentrantLock mainLock = this.mainLock;  
5.         mainLock.lock();  
6.         boolean reject = false;  
7.         Thread t = null;  
8.         try {  
9.             int state = runState;  
10.             if (state != RUNNING && workQueue.remove(command))  
11.                 reject = true;  
12.             else if (state < STOP &&  
13.                      poolSize < Math.max(corePoolSize, 1) &&  
14.                      !workQueue.isEmpty())  
15.                 t = addThread(null);  
16.         } finally {  
17.             mainLock.unlock();  
18.         }  
19.         if (reject)  
20.             reject(command);  
21.         else if (t != null)  
22.             t.start();  
23.     }  
24.     ..........  
25. }  

Java代码  

1. public class ThreadPoolExecutor extends AbstractExecutorService {  
2.     ..........  
3.     private Thread addThread(Runnable firstTask) {  
4.         Worker w = new Worker(firstTask);  
5.         Thread t = threadFactory.newThread(w);  
6.         if (t != null) {  
7.             w.thread = t;  
8.             workers.add(w);  
9.             int nt = ++poolSize;  
10.             if (nt > largestPoolSize)  
11.                 largestPoolSize = nt;  
12.         }  
13.         return t;  
14.     }  
15.     ..........  
16. }  

Java代码  

1. public class ThreadPoolExecutor extends AbstractExecutorService {  
2.     ..........  
3.     private final class Worker implements Runnable {  
4.         ..........  
5.         Worker(Runnable firstTask) {  
6.             this.firstTask = firstTask;  
7.         }  
8.   
9.         private Runnable firstTask;  
10.         ..........  
11.   
12.         public void run() {  
13.             try {  
14.                 Runnable task = firstTask;  
15.                 firstTask = null;  
16.                 while (task != null || (task = getTask()) != null) {  
17.                     runTask(task);  
18.                     task = null;  
19.                 }  
20.             } finally {  
21.                 workerDone(this);  
22.             }  
23.         }  
24.     }  
25.   
26.     Runnable getTask() {  
27.         for (;;) {  
28.             try {  
29.                 int state = runState;  
30.                 if (state > SHUTDOWN)  
31.                     return null;  
32.                 Runnable r;  
33.                 if (state == SHUTDOWN)  // Help drain queue  
34.                     r = workQueue.poll();  
35.                 else if (poolSize > corePoolSize || allowCoreThreadTimeOut)  
36.                     r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);  
37.                 else  
38.                     r = workQueue.take();  
39.                 if (r != null)  
40.                     return r;  
41.                 if (workerCanExit()) {  
42.                     if (runState >= SHUTDOWN) // Wake up others  
43.                         interruptIdleWorkers();  
44.                     return null;  
45.                 }  
46.                 // Else retry  
47.             } catch (InterruptedException ie) {  
48.                 // On interruption, re-check runState  
49.             }  
50.         }  
51.     }  
52.     }  
53.     ..........  
54. }  

Java代码  

1. public class Executors {  
2.     ..........  
3.     static class DefaultThreadFactory implements ThreadFactory {  
4.         ..........  
5.         public Thread newThread(Runnable r) {  
6.             Thread t = new Thread(group, r,  
7.                                   namePrefix + threadNumber.getAndIncrement(),  
8.                                   0);  
9.             if (t.isDaemon())  
10.                 t.setDaemon(false);  
11.             if (t.getPriority() != Thread.NORM_PRIORITY)  
12.                 t.setPriority(Thread.NORM_PRIORITY);  
13.             return t;  
14.         }  
15.         ..........  
16.     }  
17.     ..........  
18. }  

转自: http://www.189works.com/article-58560-1.html

一、缘由

其实说白了就是研究androidpn这个开源项目，只因我的本科毕业设计的题目就是“移动环境下push技术开发”，所以起这个作为本篇博文的题目。其实我本来是想等我的毕业设计答辩结束后，再总结，再分享的，可是最近群里很多人整个环境都不会配，所以我就先写一篇环境的配置吧。

当然我起初也是在各位前辈的基础上学习的，关于androidpn网上的资料还是很多的，大家自己看。这里只贴出两个我认为比较好的链接：
Android推送通知指南：http://blog.csdn.net/joshua_yu/article/details/6563587
用androidpn来实现推送（Jclick）：http://www.iteye.com/topic/1117043?page=13

刚开始的时候，我就是用的Jclick修改后的tomcat版本，在这个基础上一点一点的修改的，我的更新日志，后来交流的人多了，我就建了一个QQ群（210555217），群共享里面有各种版本（有用JSON的、有用SSH的、以及增加离线消息和回执功能的等等）。我今天就拿小强共享的版本来说明。可以在群共享下载，也可以在本文后面的链接下载。


二、Windows下androidpn环境的配置

在配置之前，请关闭或者删除你工作空间里面跟androidpn相关的其他工程。严格按照下面步骤来搞，否则你出现问题，我也不知道怎么处理的。

2.1、客户端配置

把 解压后的的“androidpn-client”导入Eclipse，导入后整个工程的目录如下，然后打开 “androidpn.properties”，修改“xmppHost”，如果你是用模拟器测试的话，改成“10.0.2.2”，如果是真机测试的话改 成你的电脑的IP。

2.2、服务器端的配置

首先在MyEclispe里面配置Tomcat，到apache官网下个纯的tomcat，不要是什么和apache整合的，就单单是tomcat。然后在本地磁盘解压。把tomcat集成到MyEclipse。按照下图操作。

然后在Server视图里面启动Tomcat。

看启动日志。

启动成功后，打来浏览器，输入：http://localhost:8080/， 如果出现Tomcat的主页，就说明的tomcat配置成功了。然后关闭Tomcat。

把解压后的服务器端代码（Androidpn）导入MyEclipse。导入后的项目结构如下图所示。在数据库里面新建一个名为“android”的数据库，再修改jdbc.properties这个文件，关键是红框标记的几处，改成你的MySql对应的值。

如果你不是用的MySql，就用相应的数据库jar包替换mysql的jar包，然后再修改jdbc.properties。其他数据库对应的写法如下。
------SQL Server 2005------
# JDBC Configuration
jdbcDriverClassName=com.microsoft.jdbc.sqlserver.SQLServerDriver
jdbcUrl=jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=android
hibernate.dialect=org.hibernate.dialect.SQLServerDialect
jdbcUsername=sa
jdbcPassword=sql

------SQL Server 2008------
jdbcDriverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver
jdbcUrl=jdbc:sqlserver://localhost:1433;DatabaseName=android;integratedSecurity=false
hibernate.dialect=org.hibernate.dialect.SQLServerDialect
jdbcUsername=sa
jdbcPassword=sql

修改好了之后，部署到Tomcat上，部署的过程中注意下图的选择。之后启动Tomcat，然后在浏览器里面输入：http://localhost:8080/Androidpn，正常情况下是可以出现Androidpn的首页。

三、测试

在模拟器或真机上运行客户端程序，会出现下图的界面。

同时MyEclipse的控制台会打印很多log。

过一会服务器的Web页面的Users列表和Sessions列表里面都会出现你的记录。

然后你就可以推送了。

客户端收到信息后的显示界面如下。

四、Linux下androidpn环境的配置

其实和上述的步骤一样，只是你把上述的Tomcat根目录下的webapps目录下的“Androidpn.war”拷贝到Linux下面的Tomcat的对应目录即可，至于Linux下怎么配置java以及tomcat的环境，请自己网上搜索。

项目放好之后，到tomcat的bin目录下，运行：./startup.sh 来启动tomcat，启动之后，运行：netstat -antupl 看下图的端口是否处于监听状态。

如果是的话，现在你就可以启动客户端了。

要看tomcat的log的话，进入tomcat的logs目录运行：tail -f ./catalina.out

好了，如果你按照上述的步骤还是不行的话，加入QQ群（210555217）提问，或者在http://phonepush.sinaapp.com/这个论坛提问。

选择图片后 onActivityResult中的代码如下：

网上找到的,HTC One X,三星i9000 cm9 4.0.4测试通过,在此记录一下，大伙需要的话就拿去吧..

1. Android 2.3(不包括)以下，通过获取aidl远程服务接口TelephoneyManager来调用它的answerRingingCall方法(ps: 关于此方法具体做法，由于时间关系，我这里就不详细说啦，大家Google一下吧)

2. Android 2.3(包括)以上，如果照样使用TelephoneyManager获取到的answerRingingCall方法的话，就会抛没有 android.permission.MODIFY_PHONE_STATE权限异常，其实你已经配了这个权限的了，但是不好意思，你的App不是系统 软件，没有系统签名，所以还是不能调用，除非，你root了你的手机，把你的app装到系统软件里面去，所以这里使用另外一种方法实现自动接听这个行为 了，详细如下:

刚开始我用这段代码的，发现三星机型可以，但HTC(如: G10 , One X)不行，

后来又google到了这段代码，经过测试，完全好使..

　　SQLite提供了ALTER TABLE命令，允许用户重命名或添加新的字段到已有表中，但是不能从表中删除字段。

　　并且只能在表的末尾添加字段，比如,为 Subscription添加两个字段：　　　　

1 ALTER TABLE Subscription ADD COLUMN Activation BLOB;
2 ALTER TABLE Subscription ADD COLUMN Key BLOB;

　　另外，如果遇到复杂的修改操作，比如在修改的同时，需要进行数据的转移，那么可以采取在一个事务中执行如下语句来实现修改表的需求。

　　1. 将表名改为临时表

ALTER TABLE Subscription RENAME TO __temp__Subscription;

　　2. 创建新表

CREATE TABLE Subscription (OrderId VARCHAR(32) PRIMARY KEY ,UserName VARCHAR(32) NOT NULL ,ProductId VARCHAR(16) NOT NULL);

　　3. 导入数据　　

INSERT INTO Subscription SELECT OrderId, “”, ProductId FROM __temp__Subscription;

　　或者　　

INSERT INTO Subscription() SELECT OrderId, “”, ProductId FROM __temp__Subscription;

　　* 注意 双引号”” 是用来补充原来不存在的数据的
　　4. 删除临时表　　

DROP TABLE __temp__Subscription;

　　通过以上四个步骤，就可以完成旧数据库结构向新数据库结构的迁移，并且其中还可以保证数据不会应为升级而流失。

　　当然，如果遇到减少字段的情况，也可以通过创建临时表的方式来实现。

    这是我最近两个星期面临的一个比较棘手的Bug，目前国内外都没有大牛提供很好的解决方式。这里，我今天花了大半天时间来解决这个问题。

     之所以出现这种情况，主要是当文本框获取到焦点后，键盘自动弹出，会执行WebView的displaySoftKeyboard 方法，这个方法会把缩小的网页恢复到正常情况（也就是说缩小的网页放大），但是我目前的项目都是不允许页面缩放的，所以一旦页面放大后就无法恢复。 这里感谢国外的一个朋友的帖子回复

http://stackoverflow.com/questions/3702805/is-there-a-way-to-disable-the-zoom-feature-on-input-fields-in-webview/7214199#7214199 。

不多说，直接上代码，如果想知道原因，看我后续的blog。 <!--EndFragment-->

解决原理：

通过反射，拿到WebView的一个私有属性mDefaultScale，并在WebView失去焦点的时候，修改它的值，已达到网页不放大的效果。

     view.setInitialScale（？？？）； //？？？代表随便多少，小于一百才会有我说的这个bug。

   解决方案如下：

Java代码  

1. videoNavigation_WV.setOnFocusChangeListener(new View.OnFocusChangeListener() {  
2.     @Override  
3.     public void onFocusChange(View v, boolean hasFocus) {  
4.         if(hasFocus)  
5.         {  
6.             try {  
7.                 Field defaultScale = WebView.class.getDeclaredField("mDefaultScale");  
8.                 defaultScale.setAccessible(true);  
9.                 //WebViewSettingUtil.getInitScaleValue(VideoNavigationActivity.this, false )/100.0f 是我的程序的一个方法，可以用float 的scale替代  
10.                 defaultScale.setFloat(videoNavigation_WV , WebViewSettingUtil.getInitScaleValue(VideoNavigationActivity.this, false )/100.0f);  
11.             } catch (SecurityException e) {  
12.                 e.printStackTrace();  
13.             } catch (IllegalArgumentException e) {  
14.                 e.printStackTrace();  
15.             } catch (IllegalAccessException e) {  
16.                 e.printStackTrace();  
17.             } catch (NoSuchFieldException e) {  
18.                 e.printStackTrace();  
19.             }   
20.         }  
21.     }  
22. });  

    大家如果想利用我这段代码，我这里面的defaultScale.setFloat(WebView,float)， 这个float值是你初始化的时候的scale值。跟你的CSS body值有一定的关系。假如body值 是1920*1080 而你现在是显示在1280*720的屏幕上，那么这个scale 的float值就是0.666667。就是你的现在的缩放页面与正常情况先显示的大小的比（缩放比），大家可以用页面第一次加载的时候通过 getScale()值获取。

    代码还有很多需要优化的地方，比如反射拿属性，其实只要做一次，设置可以做多次，这里只是一个Demo，觉得代码垃圾的话我发个改好的工程给你。

   有木有做android TV 的 ，加群87154410，欢迎欢迎。 博客刚开始写，希望大家支持。

写都比较简略，大家可以提建议，欢迎留言

另外一个问题就是加载速度，如果应用中图片加载速度很慢的话，那么用户同样会等到崩溃。

那么如何处理好图片资源的获取和管理呢?

异步下载

本地缓存

异步下载

大家都知道，在android应用中UI线程5秒没响应的话就会抛出无响应异常，对于远程获取大的资源来说，这种异常还是很容易就会抛出来的，那么怎么避免这种问题的产生。在android中提供两种方法来做这件事情：

启动一个新的线程来获取资源，完成后通过Handler机制发送消息，并在UI线程中处理消息，从而达到在异步线程中获取图片，然后通过Handler Message来更新UI线程的过程。

使用android中提供的AsyncTask来完成。

具体的做法这里就不介绍了，查下API就可以了，或者是google、baidu下。这里主要来说本地缓存。

本地缓存

对于图片资源来说，你不可能让应用每次获取的时候都重新到远程去下载(ListView)，这样会浪费资源，但是你又不能让所有图片资源都放到内存 中去(虽然这样加载会比较快)，因为图片资源往往会占用很大的内存空间，容易导致OOM。那么如果下载下来的图片保存到SDCard中，下次直接从 SDCard上去获取呢?这也是一种做法，我看了下，还是有不少应用采用这种方式的。采用LRU等一些算法可以保证sdcard被占用的空间只有一小部 分，这样既保证了图片的加载、节省了流量、又使SDCard的空间只占用了一小部分。另外一种做法是资源直接保存在内存中，然后设置过期时间和LRU规 则。

sdcard保存：

在sdcard上开辟一定的空间，需要先判断sdcard上剩余空间是否足够，如果足够的话就可以开辟一些空间，比如10M

当需要获取图片时，就先从sdcard上的目录中去找，如果找到的话，使用该图片，并更新图片最后被使用的时间。如果找不到，通过URL去download

去服务器端下载图片，如果下载成功了，放入到sdcard上，并使用，如果失败了，应该有重试机制。比如3次。

下载成功后保存到sdcard上，需要先判断10M空间是否已经用完，如果没有用完就保存，如果空间不足就根据LRU规则删除一些最近没有被用户的资源。

关键代码：

保存图片到SD卡上

private void saveBmpToSd(Bitmap bm, Stringurl) { 
        if (bm == null) { 
            Log.w(TAG, " trying to savenull bitmap"); 
            return; 
        } 
         //判断sdcard上的空间 
        if (FREE_SD_SPACE_NEEDED_TO_CACHE >freeSpaceOnSd()) { 
            Log.w(TAG, "Low free space onsd, do not cache"); 
            return; 
        } 
        String filename =convertUrlToFileName(url); 
        String dir = getDirectory(filename); 
        File file = new File(dir +"/" + filename); 
        try { 
            file.createNewFile(); 
            OutputStream outStream = newFileOutputStream(file); 
           bm.compress(Bitmap.CompressFormat.JPEG, 100, outStream); 
            outStream.flush(); 
            outStream.close(); 
            Log.i(TAG, "Image saved tosd"); 
        } catch (FileNotFoundException e) { 
            Log.w(TAG,"FileNotFoundException"); 
        } catch (IOException e) { 
            Log.w(TAG,"IOException"); 
        } 
    } 

计算sdcard上的空间：

/** 
 * 计算sdcard上的剩余空间 
 * @return 
 */ 
private int freeSpaceOnSd() { 
    StatFs stat = newStatFs(Environment.getExternalStorageDirectory() .getPath()); 
    double sdFreeMB = ((double)stat.getAvailableBlocks() * (double) stat.getBlockSize()) / MB; 
    return (int) sdFreeMB; 
} 

修改文件的最后修改时间

/** 
 * 修改文件的最后修改时间 
 * @param dir 
 * @param fileName 
 */ 
private void updateFileTime(String dir,String fileName) { 
    File file = new File(dir,fileName);        
    long newModifiedTime =System.currentTimeMillis(); 
    file.setLastModified(newModifiedTime); 
} 

本地缓存优化

/** 
 *计算存储目录下的文件大小，当文件总大小大于规定的CACHE_SIZE或者sdcard剩余空间小于FREE_SD_SPACE_NEEDED_TO_CACHE的规定 
 * 那么删除40%最近没有被使用的文件 
 * @param dirPath 
 * @param filename 
 */ 
private void removeCache(String dirPath) { 
    File dir = new File(dirPath); 
    File[] files = dir.listFiles(); 
    if (files == null) { 
        return; 
    } 
    int dirSize = 0; 
    for (int i = 0; i < files.length;i++) { 
        if(files[i].getName().contains(WHOLESALE_CONV)) { 
            dirSize += files[i].length(); 
        } 
    } 
    if (dirSize > CACHE_SIZE * MB ||FREE_SD_SPACE_NEEDED_TO_CACHE > freeSpaceOnSd()) { 
        int removeFactor = (int) ((0.4 *files.length) + 1); 
 
        Arrays.sort(files, newFileLastModifSort()); 
 
        Log.i(TAG, "Clear some expiredcache files "); 
 
        for (int i = 0; i <removeFactor; i++) { 
 
            if(files[i].getName().contains(WHOLESALE_CONV)) { 
 
                files[i].delete();              
 
            } 
 
        } 
 
    } 
 
} 
/** 
 * 删除过期文件 
 * @param dirPath 
 * @param filename 
 */ 
private void removeExpiredCache(StringdirPath, String filename) { 
 
    File file = new File(dirPath,filename); 
 
    if (System.currentTimeMillis() -file.lastModified() > mTimeDiff) { 
 
        Log.i(TAG, "Clear some expiredcache files "); 
 
        file.delete(); 
 
    } 
 
} 

文件使用时间排序

/** 
 * TODO 根据文件的最后修改时间进行排序 * 
 */ 
classFileLastModifSort implements Comparator<File>{ 
    public int compare(File arg0, File arg1) { 
        if (arg0.lastModified() >arg1.lastModified()) { 
            return 1; 
        } else if (arg0.lastModified() ==arg1.lastModified()) { 
            return 0; 
        } else { 
            return -1; 
        } 
    } 
} 

内存保存：

在内存中保存的话，只能保存一定的量，而不能一直往里面放，需要设置数据的过期时间、LRU等算法。这里有一个方法是把常用的数据放到一个缓存中 (A)，不常用的放到另外一个缓存中(B)。当要获取数据时先从A中去获取，如果A中不存在那么再去B中获取。B中的数据主要是A中LRU出来的数据，这 里的内存回收主要针对B内存，从而保持A中的数据可以有效的被命中。

先定义A缓存：

private final HashMap<String, Bitmap>mHardBitmapCache = new LinkedHashMap<String, Bitmap>(HARD_CACHE_CAPACITY/ 2, 0.75f, true) { 
        @Override 
        protected booleanremoveEldestEntry(LinkedHashMap.Entry<String, Bitmap> eldest) { 
            if (size() >HARD_CACHE_CAPACITY) { 
               //当map的size大于30时，把最近不常用的key放到mSoftBitmapCache中，从而保证mHardBitmapCache的效率 
               mSoftBitmapCache.put(eldest.getKey(), newSoftReference<Bitmap>(eldest.getValue())); 
                return true; 
            } else 
                return false; 
        } 
    }; 

再定于B缓存：

/** 
    *当mHardBitmapCache的key大于30的时候，会根据LRU算法把最近没有被使用的key放入到这个缓存中。 
    *Bitmap使用了SoftReference，当内存空间不足时，此cache中的bitmap会被垃圾回收掉 
    */ 
   private final staticConcurrentHashMap<String, SoftReference<Bitmap>> mSoftBitmapCache =new ConcurrentHashMap<String,SoftReference<Bitmap>>(HARD_CACHE_CAPACITY / 2); 

从缓存中获取数据：

/** 
     * 从缓存中获取图片 
     */ 
    private Bitmap getBitmapFromCache(Stringurl) { 
        // 先从mHardBitmapCache缓存中获取 
        synchronized (mHardBitmapCache) { 
            final Bitmap bitmap =mHardBitmapCache.get(url); 
            if (bitmap != null) { 
                //如果找到的话，把元素移到linkedhashmap的最前面，从而保证在LRU算法中是最后被删除 
                mHardBitmapCache.remove(url); 
                mHardBitmapCache.put(url,bitmap); 
                return bitmap; 
            } 
        } 
        //如果mHardBitmapCache中找不到，到mSoftBitmapCache中找 
        SoftReference<Bitmap>bitmapReference = mSoftBitmapCache.get(url); 
        if (bitmapReference != null) { 
            final Bitmap bitmap =bitmapReference.get(); 
            if (bitmap != null) { 
                return bitmap; 
            } else { 
                mSoftBitmapCache.remove(url); 
            } 
        } 
        return null; 
    } 

如果缓存中不存在，那么就只能去服务器端去下载：

/** 
     * 异步下载图片 
     */ 
    class ImageDownloaderTask extendsAsyncTask<String, Void, Bitmap> { 
        private static final int IO_BUFFER_SIZE= 4 * 1024; 
        private String url; 
        private finalWeakReference<ImageView> imageViewReference; 
        public ImageDownloaderTask(ImageViewimageView) { 
            imageViewReference = newWeakReference<ImageView>(imageView); 
        } 
 
       @Override 
        protected BitmapdoInBackground(String... params) { 
            final AndroidHttpClient client =AndroidHttpClient.newInstance("Android"); 
            url = params[0]; 
            final HttpGet getRequest = newHttpGet(url); 
            try { 
                HttpResponse response =client.execute(getRequest); 
                final int statusCode =response.getStatusLine().getStatusCode(); 
                if (statusCode !=HttpStatus.SC_OK) { 
                    Log.w(TAG, "从" +url + "中下载图片时出错!,错误码:" + statusCode); 
                    return null; 
                } 
                final HttpEntity entity =response.getEntity(); 
                if (entity != null) { 
                    InputStream inputStream =null; 
                    OutputStream outputStream =null; 
                    try { 
                        inputStream =entity.getContent(); 
                        finalByteArrayOutputStream dataStream = new ByteArrayOutputStream(); 
                        outputStream = newBufferedOutputStream(dataStream, IO_BUFFER_SIZE); 
                        copy(inputStream,outputStream); 
                        outputStream.flush(); 
                        final byte[] data =dataStream.toByteArray(); 
                        final Bitmap bitmap =BitmapFactory.decodeByteArray(data, 0, data.length); 
                        return bitmap; 
                    } finally { 
                        if (inputStream !=null) { 
                           inputStream.close(); 
                        } 
                        if (outputStream !=null) { 
                           outputStream.close(); 
                        } 
                       entity.consumeContent(); 
                    } 
                } 
            } catch (IOException e) { 
                getRequest.abort(); 
                Log.w(TAG, "I/O errorwhile retrieving bitmap from " + url, e); 
            } catch (IllegalStateException e) { 
                getRequest.abort(); 
                Log.w(TAG, "Incorrect URL:" + url); 
            } catch (Exception e) { 
                getRequest.abort(); 
                Log.w(TAG, "Error whileretrieving bitmap from " + url, e); 
            } finally { 
                if (client != null) { 
                    client.close(); 
                } 
            } 
            return null; 
        } 

这是两种做法，还有一些应用在下载的时候使用了线程池和消息队列MQ，对于图片下载的效率要更好一些。有兴趣的同学可以看下。

总结

对于远程图片等相对比较大的资源一定要在异步线程中去获取本地做缓存

今天学习android自定义组件:docs/guide/topics/ui/custom-components.html

其中有两个对布局界面影响很的方法,onDraw(),和onMeasure().

onDraw()比较好理解.onMeasure()就比较难理解一些,也更复杂些 ,引用文档中的说法就是:

onMeasure() is a little more involved.

实现onMeasure()方法基本需要完成下面三个方面的事情(最终结果是你自己写相应代码得出测量值并调用view的一个方法进行设置,告诉给你的view安排位置大小的父容器你要多大的空间.):

1.传递进来的参数,widthMeasureSpec,和heightMeasureSpec是你对你应该得出来的测量值的限制.

The overidden onMeasure() method is called with width and height measure specifications(widthMeasureSpec and heightMeasureSpec parameters,both are integer codes representing dimensions) which should be treated as requirements for the restrictions on the width and height measurements you should produce.

虽然你也可以选择你设置的尺寸超过传递进来的声明.但是这样的话,父容器可以选择,如clipping,scrolling,或者抛出异常,或者(也许是用新的声明参数)再次调用onMeasure()

Your component's onMeasure() method should calculate a measurement width and height which will be required to render the component.it should try to stay within the specified passed in.although it can choose to exceed them(in this case,the parent can choose what to do,including clipping,scrolling,throwing an excption,or asking the onMeasure to try again,perhaps with different measurement specifications).

Once the width and height are calculated,the setMeasureDimension(int width,int height) method must be called with the calculated measurements.Failure to do this will result in an exceptiion being thrown

在Android提提供的一个自定义View示例中(在API demos 中的 view/LabelView)可以看到一个重写onMeasure()方法的

实例,也比较好理解.

直接看measureWidth()

首先看到的是参数,分别代表宽度和高度的MeasureSpec

android2.2文档中对于MeasureSpec中的说明是:

一个MeasureSpec封装了从父容器传递给子容器的布局需求.

每一个MeasureSpec代表了一个宽度,或者高度的说明.

一个MeasureSpec是一个大小跟模式的组合值.一共有三种模式.

A MeasureSpec encapsulates the layout requirements passed from parent to child Each MeasureSpec represents a requirement for either the width or the height.A MeasureSpec is compsized of a size and a mode.There are three possible modes:

UNSPECIFIED The parent has not imposed any constraint on the child.It can be whatever size it wants

 父容器已经为子容器设置了尺寸,子容器应当服从这些边界,不论子容器想要多大的空间.

EXACTLY The parent has determined and exact size for the child.The child is going to be given those bounds regardless of how big it wants to be.

 子容器可以是声明大小内的任意大小.

AT_MOST The child can be as large as it wants up to the specified size

将size和mode打包或者解包为一个整型.

MeasureSpecs are implemented as ints to reduce object allocation.This class is provided to pack and unpack the size,mode tuple into the int

MeasureSpec类代码如下 :(注释已经被我删除了,因为在上面说明了.)

我无聊的将他们的十进制值打印出来了:

mode_shift=30,mode_mask=-1073741824,UNSPECIFIED=0,EXACTLY=1073741824,AT_MOST=-2147483648

然后觉得也应该将他们的二进制值打印出来,如下:

mode_shift=11110, // 30

mode_mask=11000000000000000000000000000000,

UNSPECIFIED=0, 

EXACTLY=1000000000000000000000000000000, 

AT_MOST=10000000000000000000000000000000

而把MODE_SHIFF就看成30.那为什么是二进制 的11呢?

呢,因为只有三各模式,如果有四种模式就是111了因为111三个位才可以有四种组合对吧.

我们这样来看,

UNSPECIFIED=00000000000000000000000000000000, 

      EXACTLY=01000000000000000000000000000000, 

    AT_MOST=10000000000000000000000000000000

也就是说,0,1,2

对应   00,01,10

当跟11想与时  00 &11 还是得到 00,11&01 -> 01,10&

我觉得到了这个份上相信,看我博客的也都理解了.

 return (measureSpec & ~MODE_MASK);应该是 return (measureSpec & (~MODE_MASK));

Android应用启动时，焦点直接在EditText上，输入法直接打开，影响界面美观。

导致进入画面入就打开输入法，影响界面美观。

默认焦点的顺序是：从上倒下 从左到右第一个可以输入的控件作为焦点 可以使用：

btSearch.setFocusable(true);

btSearch.requestFocus();

btSearch.setFocusableInTouchMode(true);

也可以：

在EditText前面放置一个看不到的LinearLayout，让他率先获取焦点： 

<LinearLayout android:focusable="true" android:focusableInTouchMode="true" android:layout_width="0px" android:layout_height="0px"/>