搜索
热搜： Python 编程 PHP vue dedecms
首页> 软件工程 > 软件更新 > 正文

Android软件自动更新

发布时间：2024-03-03 03:59:48 来源：互联网
.
所有好的手机应用程序都会有这项功能实现。所以我想做一个工具类UpdateManager java ，然后在activity中直接调用方法 checkUpdate

　　所有好的手机应用程序都会有这项功能实现。所以我想做一个工具类UpdateManager.java ，然后在activity中直接调用方法 checkUpdate() 检测是否有更新。这样就可以一劳永逸了O(∩_∩)O！

　　先说说软件自动更新做的好处：

　　1、开发者不需要每次都去各个市场平台发布新版本的软件，可以省去很多时间，金钱；

　　2、用户不需要去关注软件是否有更新，可以提高用户满意度。

　　再说说其实现原理，这里以流程图展现给大家：

看完之后，废话不多说，我们开始正式的开发了。

　　第一步，为了让软件知道最新的版本信息，我们需要在服务器端创建一个 app_version.xml 文件，放在服务器下，用于存放软件版本信息，代码如下：

1 <app>
2     <version>130</version>软件版本号
3     <name>appname_1.3.0</name>软件此版本的名称(这里如果不加后缀名“.apk”,则一定要在客户端中下载软件时加上)
4     <url>http://.......</url>软件下载地址
5 </app>

　　下面信息表示软件的版本信息，想信大家知道判断软件是否一样，比较的就是版本号 versionCode 吧。

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.tq365.android.activity"
    android:versionCode="120"
    android:versionName="1.2.0" >

 

第二步，创建工具类 UpdateManager.java ，负责软件更新功能模块，其中还用到了，两个自编工具类 HttpUtil.java（网络服务）、ParseXmlService.java（XML解析）代码如下：

代码里都有备注，欢迎有不懂或者有好的建议者留言交流。

HttpUtil.java 
  1 import java.io.IOException;
  2 import java.io.InputStream;
  3 import java.io.Serializable;
  4 import java.lang.reflect.Field;
  5 import java.util.ArrayList;
  6 import java.util.List;
  7 
  8 import org.apache.http.HttpEntity;
  9 import org.apache.http.HttpResponse;
 10 import org.apache.http.NameValuePair;
 11 import org.apache.http.ParseException;
 12 import org.apache.http.client.HttpClient;
 13 import org.apache.http.client.entity.UrlEncodedFormEntity;
 14 import org.apache.http.client.methods.HttpGet;
 15 import org.apache.http.client.methods.HttpPost;
 16 import org.apache.http.client.methods.HttpUriRequest;
 17 import org.apache.http.impl.client.DefaultHttpClient;
 18 import org.apache.http.message.BasicNameValuePair;
 19 import org.apache.http.util.EntityUtils;
 20 
 21 import android.util.Log;
 22 
 23 public class HttpUtil {
 24     private static final String TAG = "HttpUtil";
 25 
 26     public static final int METHOD_GET = 1;
 27     public static final int METHOD_POST = 2;
 28     public static final String BASE_URL = "http://....";
 29 
 30     /**
 31      * 远程访问服务器
 32      * 
 33      * @param uri
 34      * @param params
 35      *            参数
 36      * @param method
 37      *            访问方式get/post
 38      * @return HttpEntity
 39      * @throws IOException
 40      */
 41     public static HttpEntity getEntity(String uri,
 42             ArrayList<BasicNameValuePair> params, int method)
 43             throws IOException {
 44         HttpEntity entity = null;
 45         HttpClient client = new DefaultHttpClient();
 46         HttpUriRequest request = null;
 47         switch (method) {
 48         case METHOD_GET:
 49             StringBuffer sb = null;
 50             if (uri.indexOf("http")==0) {
 51                 sb = new StringBuffer(uri);
 52             }else {
 53                 sb = new StringBuffer(BASE_URL + uri);
 54             }
 55             if (params != null && !params.isEmpty()) {
 56                 sb.append("?");
 57                 for (BasicNameValuePair param : params) {
 58                     sb.append(param.getName()).append("=")
 59                             .append(param.getValue()).append("&");
 60                 }
 61                 sb.deleteCharAt(sb.length() - 1);
 62             }
 63             request = new HttpGet(sb.toString());
 64             break;
 65         case METHOD_POST:
 66             if (uri.indexOf("http")==0) {
 67                 request = new HttpPost(uri);
 68             }else {
 69                 request = new HttpPost(BASE_URL + uri);
 70             }
 71             if (params != null && !params.isEmpty()) {
 72                 UrlEncodedFormEntity reqEntity = new UrlEncodedFormEntity(params,"UTF-8");
 73                 ((HttpPost) request).setEntity(reqEntity);
 74             }
 75             break;
 76         }
 77         HttpResponse response = client.execute(request);
 78         if (response.getStatusLine().getStatusCode() == 200) {
 79             entity = response.getEntity();
 80         }
 81         return entity;
 82     }
 83 
 84     /**
 85      * 访问服务器，返回IO流
 86      * 
 87      * @param uri
 88      * @param params
 89      * @param method
 90      * @return InputStream
 91      * @throws IOException
 92      */
 93     public static InputStream getInputStream(String uri,
 94             ArrayList<BasicNameValuePair> params, int method)
 95             throws IOException {
 96         HttpEntity httpEntity = getEntity(uri, params, method);
 97         if (httpEntity == null) {
 98             return null;
 99         }
100         return httpEntity.getContent();
101     }
102 
103 }
ParseXmlService.java 
 1 import java.io.InputStream;
 2 import java.util.HashMap;
 3 
 4 import javax.xml.parsers.DocumentBuilder;
 5 import javax.xml.parsers.DocumentBuilderFactory;
 6 
 7 import org.w3c.dom.Document;
 8 import org.w3c.dom.Element;
 9 import org.w3c.dom.Node;
10 import org.w3c.dom.NodeList;
11 
12 public class ParseXmlService {
13 
14     /**
15      * 解析XML,软件版本信息
16      * @param inStream
17      * @return
18      * @throws Exception
19      */
20     public HashMap<String, String> parseXml(InputStream inStream)
21             throws Exception {
22         HashMap<String, String> hashMap = new HashMap<String, String>();
23 
24         // 实例化一个文档构建器工厂
25         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
26         // 通过文档构建器工厂获取一个文档构建器
27         DocumentBuilder builder = factory.newDocumentBuilder();
28         // 通过文档通过文档构建器构建一个文档实例
29         Document document = builder.parse(inStream);
30         // 获取XML文件根节点
31         Element root = document.getDocumentElement();
32         // 获得所有子节点
33         NodeList childNodes = root.getChildNodes();
34         for (int j = 0; j < childNodes.getLength(); j++) {
35             // 遍历子节点
36             Node childNode = (Node) childNodes.item(j);
37             if (childNode.getNodeType() == Node.ELEMENT_NODE) {
38                 Element childElement = (Element) childNode;
39                 // 版本号
40                 if ("version".equals(childElement.getNodeName())) {
41                     hashMap.put("version", childElement.getFirstChild().getNodeValue());
42                 }
43                 // 软件名称
44                 else if (("name".equals(childElement.getNodeName()))) {
45                     hashMap.put("name", childElement.getFirstChild().getNodeValue());
46                 }
47                 // 下载地址
48                 else if (("url".equals(childElement.getNodeName()))) {
49                     hashMap.put("url", childElement.getFirstChild().getNodeValue());
50                 }
51             }
52         }
53         return hashMap;
54     }
55 }
UpdateManager.java 
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;

import com.tq365.android.activity.R;

import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.DialogInterface.OnClickListener;
import android.content.pm.PackageManager.NameNotFoundException;
import android.net.Uri;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.ProgressBar;
import android.widget.Toast;

public class UpdateManager {

    private Context mContext;
    // 更新进度条
    private ProgressBar mUpdateProgressBar;
    // 记录进度条数量
    private int progress;
    // 保存解析的XML信息
    private HashMap<String, String> mHashMap;
    // 是否取消更新
    private boolean cancelUpdate = false;
    // 下载状态--下载中
    private static final int DOWNLOAD_ING = 1;
    // 下载状态--下载成功
    private static final int DOWNLOAD_SUCCESS = 2;
    // 下载状态--下载失败
    private static final int DOWNLOAD_FAIL = 3;
    // 下载保存路径
    private String mSavePath;
    //下载对话框
    private Dialog mDownloadDialog;
    
    private Handler mHandler;
    
    private boolean isLoop;
    

    public UpdateManager(Context context) {
        super();
        this.mContext = context;
        mHandler = new Handler(){

            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                case DOWNLOAD_ING:
                    mUpdateProgressBar.setProgress(progress);
                    break;
                case DOWNLOAD_SUCCESS:
                    //安装APK
                    installApk();
                    break;
                case DOWNLOAD_FAIL:
                    Toast.makeText(mContext, "文件下载失败！", Toast.LENGTH_LONG).show();
                    break;
                }
            }

        };
    }

    /**
     * 检测软件更新
     * 
     * @param isAuto
     *            为true:软件自动检测更新；false：用户手动检测更新。
     */
    public void checkUpdate(boolean isAuto) {
        try {
            if (isUpdate()) {
                // 显示提示对话框
                showNoticeDialog();
            } else if (!isAuto) {
                // 告诉用户已是最新版本，不需要更新。
                Toast.makeText(mContext, "您的软件已是最新版本，不需要更新！", Toast.LENGTH_SHORT).show();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 检测软件是否有更新
     * 
     * @return
     * @throws Exception 
     */
    private boolean isUpdate() throws Exception {
        //获取当前软件版本
        int versionCode = getVersionVode(mContext);
        //获取我们之前放在服务器端的app_version.xml的文件信息
        //Android 3.0（含）之后访问网络都不能在主线程中
        isLoop = true;
        new Thread(){

            @Override
            public void run() {
                try {
                    InputStream inStream = HttpUtil.getInputStream("apks/app_version.xml", null, HttpUtil.METHOD_GET);
                    //解析xml文件。由于XML文件较小，我们采用DOM方式进行解析
                    ParseXmlService service = new ParseXmlService();//这个类是自己写的解析XML的工具类
                    try {
                        mHashMap = service.parseXml(inStream);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }finally{
                        isLoop = false;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }.start();
        while (isLoop) {
            Thread.sleep(1000);
        }
        if (null != mHashMap) {
            int serviceCode = Integer.valueOf(mHashMap.get("version"));
            //判断版本号
            if (serviceCode > versionCode) {
                return true;
            }
        }
        return false;
    }

    /**
     * 获取软件当前版本号
     * 
     * @param context
     * @return
     */
    private int getVersionVode(Context context){
        int versionCode = 0;
        // 获取软件版本号，对应AndroidManifest.xml下android:versionCode
        try {
            versionCode = context.getPackageManager().getPackageInfo("com.tq365.android.activity", 0).versionCode;
        } catch (NameNotFoundException e) {
            e.printStackTrace();
        }
        return versionCode;
    }

    /**
     * 显示软件更新对话框
     */
    private void showNoticeDialog() {
        AlertDialog.Builder builder = new Builder(mContext);
        builder.setTitle("软件更新")
        .setMessage("软件有新版本，要更新吗？")
        .setPositiveButton("立即更新", new OnClickListener() {
            
            @Override
            public void onClick(DialogInterface dialog, int which) {
                dialog.dismiss();
                //显示软件下载对话框
                showDownloadDialog();
            }
        })
        .setNegativeButton("稍后再说", new OnClickListener() {
            
            @Override
            public void onClick(DialogInterface dialog, int which) {
                dialog.dismiss();
            }
        }).create().show();
    }

    /**
     * 显示软件下载对话框
     */
    private void showDownloadDialog() {
        AlertDialog.Builder builder = new Builder(mContext);
        builder.setTitle("正在更新");
        //给对话框增加进度条
        LayoutInflater inflater = LayoutInflater.from(mContext);
        View v = inflater.inflate(R.layout.update_progress, null);
        mUpdateProgressBar = (ProgressBar) v.findViewById(R.id.update_progressBar);
        mDownloadDialog = builder.setView(v)
        .setNegativeButton("取消更新", new OnClickListener() {
            
            @Override
            public void onClick(DialogInterface dialog, int which) {
                dialog.dismiss();
                //设置取消状态
                cancelUpdate = true;
            }
        }).create();
        mDownloadDialog.show();
        //下载APK文件
        downloadApk();
    }

    /**
     * 下载APK文件
     */
    private void downloadApk() {
        //启动下载APK线程
        new DownloadApkThread().start();
    }

    /**
     * 下载APK文件线程
     */
    private class DownloadApkThread extends Thread {

        @Override
        public void run() {
            try {
                // 判断SD卡是否存在，并且是否有读写权限
                if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                    // 获取SD卡路径
                    String sdPadth = Environment.getExternalStorageDirectory()+ "";
                    mSavePath = sdPadth + "/download";
                    URL url = new URL(mHashMap.get("url"));
                    // 创建连接
                    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                    conn.connect();
                    // 获取文件大小
                    int fileSize = conn.getContentLength();
                    // 创建输入流
                    InputStream inStream = conn.getInputStream();
                    File file = new File(mSavePath);
                    // 判断文件目录是否存在,不存在则创建该目录
                    if (!file.exists()) {
                        file.mkdir();
                    }
                    File apkFile = new File(mSavePath, mHashMap.get("name"));
                    FileOutputStream fos = new FileOutputStream(apkFile);
                    int count = 0;
                    // 缓存
                    byte[] b = new byte[1024];
                    do {
                        int numRead = inStream.read(b);
                        count += numRead;
                        // 计算进度条位置
                        progress = (int) (((float) count / fileSize) * 100);
                        // 更新进度
                        mHandler.sendEmptyMessage(DOWNLOAD_ING);
                        if (numRead <= 0) {// 下载完成
                            mHandler.sendEmptyMessage(DOWNLOAD_SUCCESS);
                            break;
                        }
                        // 写入文件
                        fos.write(b, 0, numRead);
                    } while (!cancelUpdate);
                }
            } catch (Exception e) {
                mHandler.sendEmptyMessage(DOWNLOAD_FAIL);
            } finally {
                mDownloadDialog.dismiss();
            }
        }
    }
    
    /**
     * 安装APK
     */
    private void installApk() {
        File apk = new File(mSavePath,mHashMap.get("name"));
        if (!apk.exists()) {
            return;
        }
        //通过Intent安装APK文件
        Intent intent = new Intent(Intent.ACTION_VIEW);
        intent.setDataAndType(Uri.parse("file://"+apk.toString()), "application/vnd.android.package-archive");
        mContext.startActivity(intent);
    }
}

 

 

 如果转载请尊重作者的劳动果实，附上http://www.cnblogs.com/small-bai/archive/2013/03/12/2955852.html。

 

 

以下您可能有感兴趣的文章:
标签： 软件更新 不需要 下载地址
关于好代码 | 联系方式 | 版权声明 | 合作赞助 | 网站地图