1、解析json数据

　　解析json的代码很简单

Java代码
  1. JSONObject jsonObject = new JSONObject(json);  
  2.                           
  3. //debug调试,解决问题  
  4. String versionName = jsonObject.getString("versionName");  
  5. mVersionDes = jsonObject.getString("versionDes");  
  6. String versionCode = jsonObject.getString("versionCode");  
  7. mDownloadUrl = jsonObject.getString("downloadUrl");  
  8. // 日志打印      
  9. Log.i(tag, versionName);  
  10. Log.i(tag, mVersionDes);  
  11. Log.i(tag, versionCode);  
  12. Log.i(tag, mDownloadUrl);  

　　2、使用消息机制发送不同类型消息

　　在获取服务器端json数据后，得到app的版本号，通过和客户端的版本号进行对比

Java代码
  1. //比对版本号(服务器版本号>本地版本号,提示用户更新)    
  2. if(mLocalVersionCode < Integer.parseInt(versionCode)) {    
  3.     //提示用户更新,弹出对话框(UI),消息机制    
  4.     msg.what = UPDATE_VERSION;    
  5.         
  6. } else {    
  7.     //进入应用程序主界面    
  8.     msg.what = ENTER_HOME;    
  9. }

　　可以使用android的消息机制发送不同类型消息，可以参考《Android消息机制入门》

　　首先新建Handler

Java代码
  1. private Handler mHandler = new Handler() {  
  2.     //  
  3.     public void handleMessage(android.os.Message msg) {  
  4.         switch (msg.what) {  
  5.         case UPDATE_VERSION:  
  6.             //弹出对话框,提示用户更新  
  7.             //showUpdateDialog();  
  8.             break;  
  9.         case ENTER_HOME:  
  10.             //进入应用程序主界面,activity跳转过程  
  11.             enterHome();  
  12.             break;  
  13.         case URL_ERROR:  
  14.             //ToastUtil.show(getApplicationContext(), "url异常");  
  15.             enterHome();  
  16.             break;  
  17.         case IO_ERROR:  
  18.             //ToastUtil.show(getApplicationContext(), "读取异常");  
  19.             enterHome();  
  20.             break;  
  21.         case JSON_ERROR:  
  22.             //ToastUtil.show(getApplicationContext(), "json解析异常");  
  23.             enterHome();  
  24.             break;  
  25.         default:  
  26.             break;  
  27.         }  
  28.     };  
  29. };  

　　在定义一些出现状态码和出现异常时候的错误码：

Java代码
  1. /** 
  2.  * 更新新版本的状态码 
  3.  */  
  4. protected static final int UPDATE_VERSION = 100;  
  5. /** 
  6.  * 进入应用程序主界面状态码 
  7.  */  
  8. protected static final int ENTER_HOME = 101;  
  9.   
  10. /** 
  11.  * url地址出错状态码 
  12.  */  
  13. protected static final int URL_ERROR = 102;  
  14. //以下是其他各种出错状态码  
  15. protected static final int IO_ERROR = 103;  
  16. protected static final int JSON_ERROR = 104;

　　接着实现enterHome()函数，作用：跳转到主界面

Java代码
  1. /** 
  2.  * 进入应用程序主界面 
  3.  */  
  4. protected void enterHome() {  
  5.     Intent intent = new Intent(this, HomeActivity.class);  
  6.     startActivity(intent);  
  7.     //在开启一个新的界面后,将导航界面关闭(导航界面只可见一次)  
  8.     finish();  
  9. }  

　　所以顺便新建一个HomeActivity.java

Java代码
  1. public class HomeActivity extends Activity {  
  2.     @Override  
  3.     protected void onCreate(Bundle savedInstanceState) {  
  4.         super.onCreate(savedInstanceState);  
  5.         setContentView(R.layout.activity_home);  
  6.     }  
  7. }  

　　当然还有一个activity_home.xml文件，随便加一点代码，先看到效果，后期再修改

XML/HTML代码
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent"  
  5.     android:orientation="vertical" >  
  6.   
  7.     <TextView  
  8.         android:text="HOMEACTIVITY"  
  9.         android:textSize="20sp"  
  10.         android:textColor="#000"  
  11.         android:layout_width="wrap_content"  
  12.         android:layout_height="wrap_content" />  
  13.   
  14. </LinearLayout>  

　　运行项目后发现，当没有版本更新的时候，splash界面停留的时间很短，于是可以将指定睡眠时间，当请求网络的时长超过4秒则不做处理，请求网络的时长小于4秒,强制让其睡眠满4秒钟。这样splash界面会停留一会，然后跳转到HomeActivity界面

Java代码
  1. //指定睡眠时间,请求网络的时长超过4秒则不做处理  
  2. //请求网络的时长小于4秒,强制让其睡眠满4秒钟  
  3. long endTime = System.currentTimeMillis();  
  4. if(endTime - startTime < 4000) {  
  5.     try {  
  6.         Thread.sleep(4000 - (endTime - startTime));  
  7.     } catch (Exception e) {  
  8.         // TODO Auto-generated catch block  
  9.         e.printStackTrace();  
  10.     }  
  11. }  
  12. mHandler.sendMessage(msg);  

       完整的代码如下：

Java代码
  1. package com.wuyudong.mobilesafe.activity;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.net.HttpURLConnection;  
  6. import java.net.MalformedURLException;  
  7. import java.net.URL;  
  8.   
  9. import org.json.JSONException;  
  10. import org.json.JSONObject;  
  11.   
  12. import com.wuyudong.mobilesafe.R;  
  13. import com.wuyudong.mobilesafe.Utils.StreamUtil;  
  14.   
  15. import android.os.Bundle;  
  16. import android.os.Handler;  
  17. import android.os.Message;  
  18. import android.app.Activity;  
  19. import android.content.Intent;  
  20. import android.content.pm.PackageInfo;  
  21. import android.content.pm.PackageManager;  
  22. import android.util.Log;  
  23. import android.widget.TextView;  
  24.   
  25. /** 
  26.  * @author wuyudong 
  27.  *  
  28.  */  
  29.   
  30. public class SplashActivity extends Activity {  
  31.   
  32.     protected static final String tag = "SplashActivity";  
  33.     /** 
  34.      * 更新新版本的状态码 
  35.      */  
  36.     protected static final int UPDATE_VERSION = 100;  
  37.     /** 
  38.      * 进入应用程序主界面状态码 
  39.      */  
  40.     protected static final int ENTER_HOME = 101;  
  41.       
  42.     /** 
  43.      * url地址出错状态码 
  44.      */  
  45.     protected static final int URL_ERROR = 102;  
  46.     //以下是其他各种出错状态码  
  47.     protected static final int IO_ERROR = 103;  
  48.     protected static final int JSON_ERROR = 104;  
  49.       
  50.     private TextView tv_version_name;  
  51.     private int mLocalVersionCode;  
  52.     private String mVersionDes;  
  53.     private String mDownloadUrl;  
  54.       
  55.     private Handler mHandler = new Handler() {  
  56.         //  
  57.         public void handleMessage(android.os.Message msg) {  
  58.             switch (msg.what) {  
  59.             case UPDATE_VERSION:  
  60.                 //弹出对话框,提示用户更新  
  61.                 //showUpdateDialog();  
  62.                 break;  
  63.             case ENTER_HOME:  
  64.                 //进入应用程序主界面,activity跳转过程  
  65.                 enterHome();  
  66.                 break;  
  67.             case URL_ERROR:  
  68.                 //ToastUtil.show(getApplicationContext(), "url异常");  
  69.                 enterHome();  
  70.                 break;  
  71.             case IO_ERROR:  
  72.                 //ToastUtil.show(getApplicationContext(), "读取异常");  
  73.                 enterHome();  
  74.                 break;  
  75.             case JSON_ERROR:  
  76.                 //ToastUtil.show(getApplicationContext(), "json解析异常");  
  77.                 enterHome();  
  78.                 break;  
  79.             default:  
  80.                 break;  
  81.             }  
  82.         };  
  83.     };  
  84.   
  85.     @Override  
  86.     protected void onCreate(Bundle savedInstanceState) {  
  87.         super.onCreate(savedInstanceState);  
  88.         // 去掉当前actinity的tittle  
  89.         // requestWindowFeature(Window.FEATURE_NO_TITLE);  
  90.         setContentView(R.layout.activity_splash);  
  91.   
  92.         // 初始化UI  
  93.         initUI();  
  94.         // 初始化数据  
  95.         initData();  
  96.   
  97.     }  
  98.   
  99.     /** 
  100.      * 进入应用程序主界面 
  101.      */  
  102.     protected void enterHome() {  
  103.         Intent intent = new Intent(this, HomeActivity.class);  
  104.         startActivity(intent);  
  105.         //在开启一个新的界面后,将导航界面关闭(导航界面只可见一次)  
  106.         finish();  
  107.     }  
  108.   
  109.     /** 
  110.      * 获取数据方法 
  111.      */  
  112.     private void initData() {  
  113.         // 1.应用版本名称  
  114.         tv_version_name.setText("版本名：" + getVersionName());  
  115.         // 检测（本地版本号与服务器版本号比对）是否有更新,如果有更新，提示用户下载  
  116.         // 2.获取本地版本号  
  117.         mLocalVersionCode = getVersionCode();  
  118.         // 3,获取服务器版本号(客户端发请求,服务端给响应,(json,xml))  
  119.         // http://www.oxxx.com/update74.json?key=value 返回200 请求成功,流的方式将数据读取下来  
  120.         // json中内容包含:  
  121.         /* 
  122.          * 更新版本的版本名称|新版本的描述信息|服务器版本号|新版本apk下载地址 
  123.          */  
  124.         checkVersion();  
  125.   
  126.     }  
  127.   
  128.     /** 
  129.      * 检测版本号 
  130.      */  
  131.     private void checkVersion() {  
  132.         new Thread() {  
  133.             public void run() {  
  134.                 // 发送请求获取数据,参数则为请求json的链接地址  
  135.                 // http://192.168.13.99:8080/update.json 测试阶段不是最优  
  136.                 // 仅限于模拟器访问电脑tomcat  
  137.                 Message msg = Message.obtain();  
  138.                 long startTime = System.currentTimeMillis();  
  139.   
  140.                 try {  
  141.                     // 1,封装url地址  
  142.                     URL url = new URL("http://169.254.178.87:8080/update.json");  
  143.                     // 2,开启一个链接  
  144.                     HttpURLConnection connection = (HttpURLConnection) url.openConnection();  
  145.                     // 3,设置常见请求参数(请求头)  
  146.                     // 请求超时  
  147.                     connection.setConnectTimeout(2000);  
  148.                     // 读取超时  
  149.                     connection.setReadTimeout(2000);  
  150.                       
  151.                     // 默认就是get请求方式  
  152.                     //connection.setRequestMethod("POST");  
  153.                       
  154.                     // 4,获取请求成功响应码  
  155.                     if(connection.getResponseCode() == 200) {  
  156.                         // 5,以流的形式,将数据获取下来  
  157.                         InputStream is = connection.getInputStream();  
  158.                         // 6,将流转换成字符串(工具类封装)  
  159.                         String json = StreamUtil.streamToString(is);  
  160.                         // 记得添加权限-->android.permission.INTERNET  
  161.                         Log.i(tag, json);      
  162.                           
  163.                         //7,json解析  
  164.                         JSONObject jsonObject = new JSONObject(json);  
  165.                           
  166.                         //debug调试,解决问题  
  167.                         String versionName = jsonObject.getString("versionName");  
  168.                         mVersionDes = jsonObject.getString("versionDes");  
  169.                         String versionCode = jsonObject.getString("versionCode");  
  170.                         mDownloadUrl = jsonObject.getString("downloadUrl");  
  171.                           
  172.                         // 日志打印      
  173.                         Log.i(tag, versionName);  
  174.                         Log.i(tag, mVersionDes);  
  175.                         Log.i(tag, versionCode);  
  176.                         Log.i(tag, mDownloadUrl);  
  177.                           
  178.                         //8,比对版本号(服务器版本号>本地版本号,提示用户更新)  
  179.                         if(mLocalVersionCode < Integer.parseInt(versionCode)) {  
  180.                             //提示用户更新,弹出对话框(UI),消息机制  
  181.                             msg.what = UPDATE_VERSION;  
  182.                               
  183.                         } else {  
  184.                             //进入应用程序主界面  
  185.                             msg.what = ENTER_HOME;  
  186.                         }  
  187.                     }  
  188.                       
  189.                 } catch (MalformedURLException e) {  
  190.                     e.printStackTrace();  
  191.                     msg.what = URL_ERROR;  
  192.                 } catch (IOException e) {  
  193.                     e.printStackTrace();  
  194.                     msg.what = IO_ERROR;  
  195.                 } catch (JSONException e) {  
  196.                     e.printStackTrace();  
  197.                     msg.what = JSON_ERROR;  
  198.                 } finally {  
  199.                     //指定睡眠时间,请求网络的时长超过4秒则不做处理  
  200.                     //请求网络的时长小于4秒,强制让其睡眠满4秒钟  
  201.                     long endTime = System.currentTimeMillis();  
  202.                     if(endTime - startTime < 4000) {  
  203.                         try {  
  204.                             Thread.sleep(4000 - (endTime - startTime));  
  205.                         } catch (Exception e) {  
  206.                             // TODO Auto-generated catch block  
  207.                             e.printStackTrace();  
  208.                         }  
  209.                     }  
  210.                     mHandler.sendMessage(msg);  
  211.                 }  
  212.             };  
  213.   
  214.         }.start();  
  215.     }  
  216.   
  217.     /** 
  218.      * 返回版本号的方法 
  219.      *  
  220.      * @return 非0代表成功 
  221.      */  
  222.     private int getVersionCode() {  
  223.   
  224.         // 1.管理者对象packageManager  
  225.         PackageManager pm = getPackageManager();  
  226.         // 2.从包的管理者对象中，获取指定包名的基本信息（版本名称，版本号）  
  227.         try {  
  228.             PackageInfo packageInfo = pm.getPackageInfo(getPackageName(), 0);  
  229.             // 3.获取版本名称  
  230.             return packageInfo.versionCode;  
  231.         } catch (Exception e) {  
  232.             e.printStackTrace();  
  233.         }  
  234.         return 0;  
  235.   
  236.     }  
  237.   
  238.     /** 
  239.      * 获取版本名称：清单文件中 
  240.      *  
  241.      * @return 应用版本名称 返回null代表有异常 
  242.      */  
  243.     private String getVersionName() {  
  244.         // 1.管理者对象packageManager  
  245.         PackageManager pm = getPackageManager();  
  246.         // 2.从包的管理者对象中，获取指定包名的基本信息（版本名称，版本号）  
  247.         try {  
  248.             PackageInfo packageInfo = pm.getPackageInfo(getPackageName(), 0);  
  249.             // 3.获取版本名称  
  250.             return packageInfo.versionName;  
  251.         } catch (Exception e) {  
  252.             e.printStackTrace();  
  253.         }  
  254.         return null;  
  255.   
  256.     }  
  257.   
  258.     /** 
  259.      * 初始化UI方法 alt+shift+j 
  260.      */  
  261.     private void initUI() {  
  262.   
  263.         tv_version_name = (TextView) findViewById(R.id.tv_version_name);  
  264.     }  
  265.   
  266. }
本文发布：Android开发网
本文地址：http://www.jizhuomi.com/android/example/625.html
2016年11月9日
发布:鸡啄米 分类:Android开发实例 浏览: 评论:0