用手机查询北京实时路况

我想读这篇文章的朋友应该是被标题所吸引的， 毕竟手机已经成为我们日常生活中不可缺少的一部分， 除了很小的孩子和老人外， 基本上是每个人必备的装备^_^。 我们每天与自己的手机形影不离， 如果能通过手机来了解出行信息， 那将极大的方便我们的生活。 没错， 通过手机是可以得到实时的路况信息的。 下面我来详细说明一下。

上周我无意间发现北京公安交通管理局的网站提供了实时的路况信息。

http://210.73.74.215/realroad/

而且实时更新， 所以马上就产生了一个灵感， 能不能把这个通过手机来访问呢。 (其实这个网站是完全可以通过手机内置的浏览器访问的), 于是我准备通过手机上的JAVA程序来实现这个功能。

思路很简单， 这个网站的所有路况信息都是以图片的形式展现的。 我首先的出发点是不通过任何的代理服务器来处理， 也就是说直接用手机来访问URL实现。 不过我发现网站默认的图片格式都是JPG的， 好在现在的大部分手机还是支持这个格式的。 好， 我们现在创建一个工程。

项目名就叫trafficinfo吧， 包含两个类和一个接口。

Main: 继承自MIDlet, 程序的入口点与界面实现。
Network: 负责网络连接
NetworkListener:  一个联网过程的反馈接口。 我稍后解释它。

1. import javax.microedition.lcdui.Command;
2. import javax.microedition.lcdui.CommandListener;
3. import javax.microedition.lcdui.Display;
4. import javax.microedition.lcdui.Displayable;
5. import javax.microedition.lcdui.Form;
6. import javax.microedition.lcdui.Gauge;
7. import javax.microedition.lcdui.Image;
8. import javax.microedition.lcdui.List;
9. import javax.microedition.midlet.MIDlet;
10. import javax.microedition.midlet.MIDletStateChangeException;
13. public class Main extends MIDlet implements CommandListener, NetworkListener {
14.     
15.     private String[] locations = 
16.             {"西直门", "雍和宫", "东直门", 
17.             "朝阳门", "建国门", "左安门", 
18.             "永定门", "广安门", "菜户营",             
19.             "六里桥", "莲花桥", "蓟门桥", 
20.             "马甸桥", "洋桥", "航天桥", 
21.             "紫竹桥", "长虹桥", "三元桥", 
22.             "玉泉营桥", "分钟寺桥", "双井桥",
23.             "定慧桥", "五棵松", "学院桥"};   
24.     
25.     
26.     public static final String imgSuffix = ".jpg";
27.     
28.     private List list;
29.     
30.     private Form form;
31.     
32.     private Gauge process;
33.     
34.     private Command view = new Command("查看", Command.OK, 1);
35.     
36.     private Command exit = new Command("退出", Command.EXIT, 1);
37.     
38.     public Command back = new Command("菜单", Command.OK, 1);
39.     
40.     public Command backForm = new Command("地图", Command.OK, 1);
41.     
42.     private Command log = new Command("信息", Command.OK, 1);
43.     
44.     private static Main mainInstance;   
45.     
46.     
47.     public Main() {
48.         list = new List("选择区域", List.IMPLICIT, locations, null);
49.         list.addCommand(view);
50.         list.addCommand(exit);
51.         list.addCommand(log);
52.         list.setCommandListener(this);  
53.         
54.         form = new Form("");
55.         form.addCommand(back);
56.         form.addCommand(log);
57.         form.setCommandListener(this);
58.         
59.         process = new Gauge("下载中...", false, 100, 1);
60.         
61.         
62.         
63.         mainInstance = this;
64.         
65.         Display.getDisplay(this).setCurrent(list);
66.         
67.     }
68.     
69.     static Main getInstance() {
70.         return mainInstance;
71.     }
73.     protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
74.         // TODO Auto-generated method stub
76.     }
78.     protected void pauseApp() {
79.         // TODO Auto-generated method stub
81.     }
82.     
83.     private void exitApp() {
84.         try {
85.             destroyApp(false);
86.             notifyDestroyed();
87.         } catch (Exception e) {e.printStackTrace();}
88.     }
90.     protected void startApp() throws MIDletStateChangeException {
91.         // TODO Auto-generated method stub
92.         
93.     }
95.     public void commandAction(Command cmd, Displayable d) {
96.         // TODO Auto-generated method stub
97.         
98.         if (cmd == view) {
99.             int index = list.getSelectedIndex();
100.             
101.             Network net = new Network(index + 1, mainInstance);
102.             net.start();
103.                         
104.             form.setTitle(locations[index]);
105.             form.deleteAll();
106.             process.setValue(1);
107.             form.append(process);           
108.             Display.getDisplay(mainInstance).setCurrent(form);
110.         }
111.         
112.         if (cmd == exit) {
113.             exitApp();
114.         }
115.         
116.         if (cmd == back) {
117.             Display.getDisplay(mainInstance).setCurrent(list);
118.         }
119.         
120.         if (cmd == log) {
121.             Display.getDisplay(mainInstance).setCurrent(Logger.getInstance().getForm());
122.         }
123.         
124.         if (cmd == backForm) {          
125.             Display.getDisplay(mainInstance).setCurrent(form);
126.         }
127.         
128.     }
130.     public void connectProcess(int i, boolean b) {
131.         // TODO Auto-generated method stub
132.         if (b) {
133.             Display.getDisplay(mainInstance).setCurrent(form);
134.         } else {
135.             process.setValue(i);            
136.         }
137.     }
139.     public void inputImage(Image img) {
140.         // TODO Auto-generated method stub
141.         if (img != null) {
142.             form.deleteAll();
143.             form.append(img);           
144.         } else {
145.             System.out.println(" get img is null");
146.         }
147.     }
149.     public void errorInfo(String str) {
150.         // TODO Auto-generated method stub
151.         
152.     }
154. }

Main.java

1. import java.io.InputStream;
3. import javax.microedition.io.Connector;
4. import javax.microedition.io.HttpConnection;
5. import javax.microedition.lcdui.Image;
8. public class Network/* implements Runnable*/ {
10.     private int imgIndex;   
11.     
12.     private NetworkListener listener;
13.     
14.     private boolean done;   
15.     
16.     private HttpConnection hc;
17.     
18.     private HttpConnection urlConn;
19.     
20.     private HttpConnection mobileConn;
21.     
22.     private String urlKey;      
23.     
24.     private boolean getKeywordDone;
25.     
26.     private boolean getMobileInfoDone;
27.     
28.     private static final String mainurl = "http://210.73.74.215/realroad/submap.jsp";
29.     
30.     private String parsedURL;
31.     
32.     private static final String commiturl = "http://210.73.74.215/realroad/getimages.jsp?fileName=";
33.     
34.     Logger logger = Logger.getInstance();
35.     
36.     public Network(int index, NetworkListener nk) {
37.         imgIndex = index;
38.         listener = nk;  
39.         
40.     }
41.     
42.     
43.     
44.     public void start() {
45.         
46.         
47.         
48.         Thread getUrl = new Thread(new Runnable(){
49.             
50.             public void run() {
51.                 while (!getMobileInfoDone) {
52.                     
53.                 }
54.                 logger.put("Thread 1 continue");
55.                 try {
56.                     if (parsedURL == null) {
57.                         
58.                         
59.                         urlConn = (HttpConnection) Connector.open(mainurl, Connector.READ_WRITE);
60.                     } else {
61.                         
62.                         
63.                         urlConn = (HttpConnection) Connector.open(parsedURL, Connector.READ_WRITE);
64.                     }
65.                     
66.                     if (urlConn.getResponseCode() == 200) {
67.                         logger.put("200 ok");
68.                         InputStream is = urlConn.openInputStream();                         
69.                         if (is != null) {
70.                             
71.                             StringBuffer sb = new StringBuffer();
72.                             String temp = null;
73.                             int ch = 0;
74.                             int times = 0;
75.                             while ((ch = is.read()) != -1) {
76.                                 times++;
77.                                 sb.append((char)ch);
78.                                 
79.                                  temp = sb.toString();
80.                                 if (temp.endsWith(".jpg")) {
81.                                     logger.put("find key");
82.                                     String keyStr = temp.substring(temp.length() - 50, temp.length() - 4);
83.                                     int qa = keyStr.lastIndexOf('=');
84.                                     urlKey = keyStr.substring(qa + 1, keyStr.length() - 1);
85.                                     break;
86.                                 }
87.                             }
88.                             
89.                             
90.                         }
91.                     }
92.                         
93.                 } catch (Exception e) {
94.                     logger.put("Thread 1 #! " + e.getMessage());
95.                     e.printStackTrace();                    
96.                     
97.                 } finally {                 
98.                     try {
99.                         logger.put("to close thread 1");
100.                       urlConn.close();                  
101.                       getKeywordDone = true;
102.                       
103.                       if (urlKey != null) {
104.                           logger.put("URL Connection colosed! " + urlKey);
105.                       } else {
106.                           logger.put("urlKey is null");
107.                       }
108.                     } catch (Exception e) {
109.                         logger.put("Thread 1 ##! " + e.getMessage());
110.                         
111.                         e.printStackTrace(); }
112.                 }
113.                 
114.             }
115.         });
116.         
117.         
118.         
119.         Thread getImage = new Thread(new Runnable(){
120.             public void run() {
121.                 // TODO Auto-generated method stub
122.                 
123.                 while (!getKeywordDone) {
124.                     
125.                 }
126.                 logger.put("Thread 2 continue");
127.                 try {
128.                     logger.put("URL :: " + commiturl + urlKey + imgIndex + Main.imgSuffix);
129.                     hc = (HttpConnection)Connector.open(commiturl + urlKey + imgIndex + Main.imgSuffix,  Connector.READ_WRITE);
130.                     int rs = hc.getResponseCode();
131.                     if (rs == 200) {
132.                         logger.put("Thread 2 200 ok");
133.                         Thread download = new Thread(new Runnable(){
134.                             public void run() {
135.                                 try {
136.                                     InputStream is = hc.openInputStream();  
137.                                     
138.                                     if (is != null) {
139.                                         logger.put("Thread 2 inputstream not null");
140.                                         Image img = Image.createImage(is);                              
141.                                         listener.inputImage(img);
142.                                         done = true;
143.                                         logger.put("Thread 2 image done");
144.                                     }
145.                                 
146.                                 } catch (Exception e) { 
147.                                 logger.put("Thread 2 :" + e.getMessage());
148.                                 e.printStackTrace();
149.                                 }
150.                             }
151.                             
152.                         });
153.                         download.start();
154.                         int p = 1;
155.                         while (!done) {
156.                             
157.                             try {
158.                                 Thread.sleep(500L);
159.                                 listener.connectProcess(p, false);
160.                             } catch (Exception e) { e.printStackTrace(); };
161.                             
162.                             p++;
163.                         }
164.                         
165.                         if (done) {
166.                             listener.connectProcess(p, true);
167.                             
168.                         }
169.                         
170.                     } else {
171.                         logger.put("response code " + rs);
172.                     }
173.                 } catch (Exception e) {
174.                     logger.put("Thread 2 # :" + e.getMessage());
175.                     e.printStackTrace();
176.                     
177.                 } finally {
178.                     try {
179.                         hc.close();
180.                         logger.put("Thread 2 closed");
181.                     } catch (Exception e) { e.printStackTrace(); }
182.                 }
183.             }
184.             
185.             
186.         });
187.         
188.         getUrl.start();
189.         getImage.start();
190.     }
191.     
192.     
193. }

Network.java

 

1. import javax.microedition.lcdui.Image;
4. public interface NetworkListener {
6.     void connectProcess(int i, boolean b);
7.     void inputImage(Image img);
8.     void errorInfo(String str);
9.     
10. }

NetworkListener.java

 

 

以上是每个类的具体代码， 其实我还写了一个Log类， 负责在真机查看调试信息。 在真机上联网时，还是比较有帮助的。

核心的思路就是， 从List上选择一个地名后， 会传入相应的URL， 交给Network去联网。 然后建立连接后， 返回一张图片的数据， 通过OpenInputStream 来创建一副图片。 当连接建立后, NetworkListener接口就该发挥作用了， Network类可以通过这个就接口来传递联网的进度和状态。 也就会反应在界面上了。 等图片被创建后， 这样就可以看到跟网站上的图片一样的效果了。

这里有一点需要解释一下， 大家可以仔细看一下那个网站， 当每2分钟刷新一次的时候， 每幅图片的URL就变化了， 也就是说图片名字是自动生成的。 这个问题我是如何处理的呢？  我打开那个网页的源代码，仔细的研究了一下， 没发现什么好办法。 后来我想了一条比较笨的方法， 也就是当每次查询前， 我首先请求一下那个页面， 它会返回一个标准的HTML格式页面， 里面包含所有的图片的URL， 其实每张图片名字只有最后一位不同。 这样我就想了一个折中的办法， 我把返回的这个HTML页面的字符遍历一遍， 当第一次遇到.jpg结尾的字符后， 我就跳出来， 然后把签名的数字名称解析出来， 留做备用， 这样我通过从界面上传来的List的index, 就可以知道程序想要请求哪幅图， 只要把这串数字后加上这个index， 再加上.jpg的后缀， 前面加上完整的服务器请求地址，就是实际的图片路径了。

 

以下是在模拟器上的截图:

 

(主界面)

 

(下载界面)

 

 

(区域地图)

 

 

我记得以前郑钧的BLOG上有关于手机查看路况信息的文章， 是视频的。 所以这个相比于流媒体来说没有什么技术含量了。 呵呵。 路况图片上不同颜色表示不同的道路状况， 绿色表示畅通，黄色表示缓慢，红色表示拥堵，灰色则表示暂时无数据。

下面是打包的程序包的下载地址：

 

http://121.198.86.108/ebooks/trafficinfo.jar
http://121.198.86.108/ebooks/trafficinfo.jad

 

本程序在Nokia 6120上测试通过， 目前仅支持240 x 320 屏幕的真机。 仅仅是个测试版本， 如果真的想通过这条途径来查看路况， 我觉得还是需要一个代理服务器去中转的， 毕竟不是所有的手机都支持JPG格式的图片。