1、在update.txt中，记录应用最新的 版本、下载地址。如：https://scimence.gitee.io/CallShielder/update.txt 

2、在安卓应用中检测到版本变动时，下载应用、并提示更新。

示例：

String ConfigUrl = "https://scimence.gitee.io/CallShielder/update.txt";	// 服务端最新版本配置信息
String curVersion = "20190401";											// 当前版本信息
AppUpdate.CheckUpdate(this, ConfigUrl, curVersion);						// 检测版本自动更新

 下载 

3、AndroidManifest.xml中添加权限

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.INTERNET" />

AppUpdate.jar 实现源码：

package com.sc.update;

import java.io.File;

import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Environment;
import android.widget.Toast;

import com.sc.update.DownloadTool.CallBack;
import com.sc.update.ThreadTool.ThreadPram;

/** 应用自更新：
 * 1、修改ConfigUrl为：待更新应用对应的update.txt地址；
 * 2、在curVersion记录当前应用版本信息；
 * 3、在应用启动时，调用检测更新：AppUpdate.CheckUpdate(this, "", ""); 
 *  */
public class AppUpdate
{	
	//	update.txt中配置应用的最新：版本信息、下载地址
	//	version(20190401)
	//	url(https://scimence.gitee.io/CallShielder/CallShielder.apk)

	static String mConfigUrl = "https://scimence.gitee.io/CallShielder/update.txt";
	static String mCurVersion = "20190401";
	static String msg = "";
	
	/** 应用版本检测，自动更新 */
	public static void CheckUpdate(final Context context, String ConfigUrl, String CurVersion)
	{
		if(ConfigUrl != null && !ConfigUrl.equals("")) mConfigUrl = ConfigUrl;
		if(CurVersion != null && !CurVersion.equals("")) mCurVersion = CurVersion;
		
		ThreadTool.RunInCachedThread(new ThreadPram()
		{
			@Override
			public void Function()
			{
				String configData = WebTool.GetString(mConfigUrl);			// 获取版本配置文件中的信息
				String version = getNodeData(configData, "version", true);	// 版本信息
				String url = getNodeData(configData, "url", true);			// 最新版apk地址
				msg = getNodeData(configData, "msg", true);					// 更新安装时，提示信息
				
				if(!url.equals("") && !mCurVersion.equals(version))	 // 若当前版本非最新版
				{
					Download(context, url);
				}
			}
		});
	}
	
	/**
	 * 从自定义格式的数据data中，获取key对应的节点数据
	 * RegisterPrice(1)RegisterPrice
	 */
    public static String getNodeData(String data, String key, boolean finalNode)
    {
        try
        {
            String S = key + "(", E = ")" + (finalNode ? "" : key);
            int indexS = data.indexOf(S) + S.length();
            int indexE = data.indexOf(E, indexS);

            return data.substring(indexS, indexE);
        }
        catch (Exception ex) { return data; }
    }
    
	/** 下载并自动提示安装 */
	public static void Download(final Context context, String url)
	{
		String apkName = url.substring(url.lastIndexOf("/") + 1);	// 解析apk文件名称
		final String filePath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/sc/apps/" + apkName;
		
		CallBack call = new CallBack()
		{
			@Override
			public void F()
			{
				Install(context, filePath);					// 下载完成后，执行安装
			}
		};
		
		DownloadTool.DownloadFile(url, filePath, call);    	// 从网络下载文件到本地
	}
	
	/** 安装apk包 */
	public static void Install(final Context context, final String filePath)
	{
		ThreadTool.RunInMainThread(new ThreadPram()
		{
			@Override
			public void Function()
			{
				Toast.makeText(context, "检测到新版本！" + msg, Toast.LENGTH_SHORT).show();
				
				File apkFile = new File(filePath);
				Uri data = Uri.fromFile(apkFile);
				
				Intent intent = new Intent();
		        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
		        intent.setAction(android.content.Intent.ACTION_VIEW);
		        intent.setDataAndType(data, "application/vnd.android.package-archive");
		        context.startActivity(intent);
			}
		});
		
	}
}

package com.sc.update;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.concurrent.Executors;

/** 调用前需添加权限  <uses-permission android:name="android.permission.INTERNET" />*/
public class DownloadTool
{
	/** 获取指定网络文件url，保存至本地文件路径filePath */
	public static void DownloadFile(final String url, final String filePath, final CallBack call)
	{
		ConfirmFile(filePath);
		
		Executors.newCachedThreadPool().execute(new Runnable()
		{
			@Override
			public void run()
			{
				try
				{
					URL webUrl = new URL(url);
					URLConnection con = webUrl.openConnection();	// 打开连接
					InputStream in = con.getInputStream();			// 获取InputStream
					
					File f = new File(filePath);					// 创建文件输出流
					FileOutputStream fo = new FileOutputStream(f);
					
					byte[] buffer = new byte[1024 * 1024];
					int len = 0;
					while( (len = in.read(buffer)) > 0)		// 读取文件
					{
						fo.write(buffer, 0, len); 			// 写入文件
					}
					
					in.close();
					
					fo.flush();
					fo.close();
					
					if(call != null) call.F();	// 下载完成，执行回调
				}
				catch (Exception e)
				{
					e.printStackTrace();
				}
			}
		});
	}
	
	/** 创建目录和文件 */
	public static void ConfirmFile(String filePath)
	{
		try
		{
			File f = new File(filePath);
			File parent = f.getParentFile();
			
			if (!parent.exists()) parent.mkdirs();
			if (!f.exists()) f.createNewFile();
		}
		catch (Exception ex)
		{	
			ex.printStackTrace();
		}
	}
	
	// 回调处理逻辑
	public static abstract class CallBack
	{
		public abstract void F();
	}
	
}

package com.sc.update;



import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.HashMap;

import org.json.JSONObject;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;

import com.sc.update.ThreadTool.ThreadPram;


/** WebTool.java: 网页信息获取，可在主线程中调用
* 
* 1、byte[] 	GetBytes(final String url)
* 2、String 	GetString(String dataUrl)
* 3、JSONObject 	GetJSONObject(String jsonUrl)
* 4、Bitmap 	GetBitmap(String imgUrl)
* 5、Drawable 	GetDrawable(String imgUrl)
* 
* ----- 2018-6-7 上午11:00:03 scimence */
public class WebTool
{
	// 缓存Drawable图像
	private static HashMap<String, Drawable> DrawableDic = new HashMap<String, Drawable>();
	
	/** 从网络上下载图片,转为Drawable */
	public static Drawable GetDrawable(String imgUrl)
	{
		Drawable drawable = null;
		
		if (DrawableDic.containsKey(imgUrl))
			drawable = DrawableDic.get(imgUrl);	// 从缓存读取图像
		else
		{
			Bitmap bmp = GetBitmap(imgUrl);						// 从服务器端下载图像
			if (bmp != null) drawable = Bitmap2Drawable(bmp);			// 转化为Drawable
			if (drawable != null) DrawableDic.put(imgUrl, drawable);		// 记录图像
		}
		
		return drawable;
	}
	
	/** 从网络上下载图片资源 */
	public static Bitmap GetBitmap(String imgUrl)
	{
		Bitmap bmp = null;
		try
		{
			byte[] data = GetBytes(imgUrl);								// 下载数据
			bmp = BitmapFactory.decodeByteArray(data, 0, data.length);	// 载入Bitmap
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
		return bmp;
	}
	
	/** Bitmap转化为Drawable */
	public static Drawable Bitmap2Drawable(Bitmap bitmap)
	{
		BitmapDrawable drawable = new BitmapDrawable(bitmap);
		return drawable;
	}
	
	/** Drawable转化为Bitmap */
	public static Bitmap Drawable2Bitmap(Drawable drawable)
	{
		BitmapDrawable bitDrawable = (BitmapDrawable) drawable;
		return bitDrawable.getBitmap();
	}
	
	
	/** 获取指定网址的数据 */
	public static String GetString(String dataUrl)
	{
		String Str = "";
		try
		{
			byte[] data = GetBytes(dataUrl);	// 下载数据
			Str = new String(data);				// 转化为字符串
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
		return Str;
	}

	/** 获取指定网址的数据为JSON */
	public static JSONObject GetJSONObject(String jsonUrl)
	{
		String webData = WebTool.GetString(jsonUrl);
		JSONObject webJson = null;
		try
		{
			webJson = new JSONObject(webData);
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
		}
		return webJson;
	}
	
	
	
	// ------------------------
	// 网络数据载入
	// ------------------------
	
	static HashMap<Long, byte[]> GetBytesDic = new HashMap<Long, byte[]>();
	
	/** 获取指定网址的数据，函数可在任意线程中执行，包括主线程 */
	public static byte[] GetBytes(final String url)
	{
		final long KEY = System.currentTimeMillis();
		if (!GetBytesDic.containsKey(KEY)) GetBytesDic.put(KEY, null);
		
		// 在非主线程中执行网络请求，获取数据
		ThreadTool.RunInCachedThread(new ThreadPram()
		{
			@Override
			public void Function()
			{
				byte[] data = GetBytes_process(url);
				GetBytesDic.put(KEY, data);
			}
		});
		
		// 等待异步线程中的网络请求逻辑执行完成
		while (GetBytesDic.get(KEY) == null) 	// 未获取到数据则
		{
			if (System.currentTimeMillis() > KEY + 1000 * 3) break;	// 超出3秒则终止
			Sleep(50); // 延时等待异步线程逻辑执行完成
		}
		
		byte[] data = GetBytesDic.get(KEY);
		GetBytesDic.remove(KEY);
		
		return data;
	}
	
	/** 获取指定网址的数据 */
	public static byte[] GetBytes_process(String url)
	{
		byte[] data = new byte[0];
		try
		{
			URL webUrl = new URL(url);
			URLConnection con = webUrl.openConnection();	// 打开连接
			InputStream in = con.getInputStream();			// 获取InputStream
			
			data = InputStreamToByte(in);					// 读取输入流数据
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
		return data;
	}

	/** InputStream -> Byte */
	public static final byte[] InputStreamToByte(InputStream in)
	{
		byte[] bytes = {};
		
		try
		{
			ByteArrayOutputStream byteOutStream = new ByteArrayOutputStream();
			byte[] data = new byte[1024];
			int count = 0;
			while ((count = in.read(data, 0, 1024)) > 0)
			{
				byteOutStream.write(data, 0, count);
			}
			
			bytes = byteOutStream.toByteArray();
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
		}
		return bytes;
	}
	
	/** 当前线程延时毫秒 */
	private static void Sleep(long timeMillion)
	{
		try
		{
			Thread.sleep(timeMillion);
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
	}
	
}

package com.sc.update;

import java.util.concurrent.Executors;
import android.os.Handler;
import android.os.Looper;

/** 线程辅助处理类，用于在主线程和其他线程中执行逻辑 */
public class ThreadTool
{
	// 调用示例
	public static void Example()
	{
		ThreadTool.RunInMainThread(new ThreadPram()
		{
			@Override
			public void Function()
			{
				// TODO Auto-generated method stub
				// 在主线程执行逻辑
			}
		});
	}
	
	//---------------------------------------------
	
	/** 线程辅助处理类对象参数 */
	public static abstract class ThreadPram
	{
		/** 需要在线程中执行的逻辑 */
		public abstract void Function();
	}
	
	/** 在主线程执行Function —— UI界面相关控件逻辑需在主线程中执行 */
	public static void RunInMainThread(final ThreadPram param)
	{
		getMainHandler().post(new Runnable()
		{
			@Override
			public void run()
			{
				param.Function();
			}
		});
	}
	
	/** 在主线程中延时delayMillis毫秒，执行Function —— UI界面相关控件逻辑需在主线程中执行 */
	public static void RunInMainThread(final ThreadPram param, long delayMillis)
	{
		getMainHandler().postDelayed(new Runnable()
		{
			@Override
			public void run()
			{
				param.Function();
			}
		}, delayMillis);
	}
	
	/** 在其他线程执行Function —— 网络请求需在主线程之外的其他线程执行 */
	public static void RunInCachedThread(final ThreadPram param)
	{
		Executors.newCachedThreadPool().execute(new Runnable()
		{
			@Override
			public void run()
			{	
				param.Function();
			}
		});
	}
	
	/** 当前线程是否为主线程 */
	public static boolean isUiThread()
	{
		return Thread.currentThread() == Looper.getMainLooper().getThread();
	}
	
	/** 获取主线程Handler */
	public static Handler getMainHandler()
	{
		return new Handler(Looper.getMainLooper());
	}
	
	/** 获取当前线程Handler */
	public static Handler getCurrentHandler()
	{
		return new Handler(Looper.myLooper());
	}
	
}