主从式App实现静默更新及root权限扩展

最新推荐文章于 2024-06-26 13:54:53 发布
最新推荐文章于 2024-06-26 13:54:53 发布
阅读量2.3k 收藏 2
点赞数
分类专栏： Android 项目随记 文章标签： app静默安装 root
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012874222/article/details/50492177
版权

之前公司一个项目，项目需求为软件在后台自动更新，有新版本发布则自动下载并安装新版本。通过查阅了大量资料，了解了要想完成这件事情途径有两：

1，       app需要拥有系统级别的身份。这就需要在系统源码中获取到系统签名，然后对生成的app进行签名，完了之后才能安装运行在系统上执行静默操作；

2，      在已root系统上app获取到系统root权限，即可执行静默安装的操作。

由于公司的嵌入式设备已root，那么这里我直接选择了后者。

实现获取系统root权限并且进行静默安装的过程其实还是比较简单的，网上也有很多这方面的教程，我这里就简单的说下过程：

1， 检测设备是否root：

public boolean hasRooted() {
        if (hasRooted == null) {
            for (String path : Constants.SU_BINARY_DIRS) {
                File su = new File(path + "/su");
                if (su.exists()) {
                    hasRooted = true;
                    break;
                } else {
                    hasRooted = false;
                }
            }
        }
        return hasRooted;
    }

不同的设备su所在地址可能不一样，为了尽量适配所有的设备这里把所有可能的地址放在一个数组里面：

 public static final String[] SU_BINARY_DIRS = {
            "/system/bin", "/system/sbin", "/system/xbin",
            "/vendor/bin", "/sbin"
    };

2， 接着获取系统的root权限，将会弹出对话框让用户选择是否授予此应用root权限

public boolean grantPermission() {
        if (!hasGivenPermission) {
            hasGivenPermission = accessRoot();
            lastPermissionCheck = System.currentTimeMillis();
        } else {
            if (lastPermissionCheck < 0
                    || System.currentTimeMillis() - lastPermissionCheck > Constants.PERMISSION_EXPIRE_TIME) {
                hasGivenPermission = accessRoot();
                lastPermissionCheck = System.currentTimeMillis();
            }
        }
        return hasGivenPermission;
}

3，  接下来执行异步安装即可

runAsyncTask(new AsyncTask<Void, Void, Result>() {
           @Override
           protected void onPreExecute() {
               updateLog("Installing package " + apkPath + " ...........");
               super.onPreExecute();
           }

           @Override
           protected Result doInBackground(Void... params) {
               return RootManager.getInstance().installPackage(apkPath);
           }

           @Override
           protected void onPostExecute(Result result) {
               updateLog("Install " + apkPath + " " + result.getResult()
                       + " with the message " + result.getMessage());
               super.onPostExecute(result);
           }
       });

主要方法：

public Result installPackage(String apkPath, String installLocation) {

        RootUtils.checkUIThread();//如果是UIthread抛出异常

        final ResultBuilder builder = Result.newBuilder(); //运行结果集

        if (TextUtils.isEmpty(apkPath)) {
            return builder.setFailed().build();
        }

        String command = Constants.COMMAND_INSTALL;
        if (RootUtils.isNeedPathSDK()) { //4.0版本以上必须在命令前加上patch
            command = Constants.COMMAND_INSTALL_PATCH + command;
        }

        command = command + apkPath;

        if (TextUtils.isEmpty(installLocation)) {
            if (installLocation.equalsIgnoreCase("ex")) {  //安装至外置内存
                command = command + Constants.COMMAND_INSTALL_LOCATION_EXTERNAL;
            } else if (installLocation.equalsIgnoreCase("in")) { //安装至内置内存

                command = command + Constants.COMMAND_INSTALL_LOCATION_INTERNAL;
            }
        }

        final StringBuilder infoSb = new StringBuilder();
        Command commandImpl = new Command(command) {//装载命令

            @Override
            public void onUpdate(int id, String message) {
                infoSb.append(message + "\n");
            }

            @Override
            public void onFinished(int id) {
                String finalInfo = infoSb.toString();
                if (TextUtils.isEmpty(finalInfo)) {
                    builder.setInstallFailed();
                } else {
                    if (finalInfo.contains("success") || finalInfo.contains("Success")) {
                        builder.setInstallSuccess();
                    } else if (finalInfo.contains("failed") || finalInfo.contains("FAILED")) {
                        if (finalInfo.contains("FAILED_INSUFFICIENT_STORAGE")) {
                            builder.setInsallFailedNoSpace();
                        } else if (finalInfo.contains("FAILED_INCONSISTENT_CERTIFICATES")) {
                            builder.setInstallFailedWrongCer();
                        } else if (finalInfo.contains("FAILED_CONTAINER_ERROR")) {
                            builder.setInstallFailedWrongCer();
                        } else {
                            builder.setInstallFailed();
                        }

                    } else {
                        builder.setInstallFailed();
                    }
                }
            }

        };

        try {
            Shell.startRootShell().add(commandImpl).waitForFinish();  //执行
        } catch (InterruptedException e) {
            e.printStackTrace();
            builder.setCommandFailedInterrupted();
        } catch (IOException e) {
            e.printStackTrace();
            builder.setCommandFailed();
        } catch (TimeoutException e) {
            e.printStackTrace();
            builder.setCommandFailedTimeout();
        } catch (PermissionException e) {
            e.printStackTrace();
            builder.setCommandFailedDenied();
        }

        return builder.build();

    }

其实获取了系统的root不仅能执行静默安装，还能执行其他有趣的命令，以下是我收集总结的一些命令：


pm install –r       静默安装

-s       安装APP到SD-CARD

-f         安装APP至phone RAM

pm uninstall        静默卸载

"rm '" + apkPath +"'"      卸载系统app

screencap 　    系统截屏

ps 　进程是否运行

"pidof  "+进程名       通过进程名杀死一个进程

"kill  "+进程ID           通过进程ID杀死一个进程

"reboot -p"          关机

"reboot"              重启

"reboot recovery"             重启进入Recovery模式


执行命令方法：

public Result runCommand(String command) {
        final ResultBuilder builder = Result.newBuilder();
        if (TextUtils.isEmpty(command)) {
            return builder.setFailed().build();
        }

        final StringBuilder infoSb = new StringBuilder();
        Command commandImpl = new Command(command) {

            @Override
            public void onUpdate(int id, String message) {
                infoSb.append(message + "\n");
            }

            @Override
            public void onFinished(int id) {
                builder.setCustomMessage(infoSb.toString());
            }

        };

        try {
            Shell.startRootShell().add(commandImpl).waitForFinish();
        } catch (InterruptedException e) {
            e.printStackTrace();
            builder.setCommandFailedInterrupted();
        } catch (IOException e) {
            e.printStackTrace();
            builder.setCommandFailed();
        } catch (TimeoutException e) {
            e.printStackTrace();
            builder.setCommandFailedTimeout();
        } catch (PermissionException e) {
            e.printStackTrace();
            builder.setCommandFailedDenied();
        }
        return builder.build();
}

继续回到主题《静默安装》，你以为这样就完了，其实还没，这样做是能执行安装的操作，但是安装的不是本身，而是其他app，就是说静默安装执行者的执行对象不能是本身，既然如此，那就必须得借助外部的力量才能对自己完成更新，so,便引入了主、从APP的概念，这里我们把这个需要更新的app作为主APP，然后再添加一个从APP，让从APP对主APP执行一个安装更新的操作就行了，思略良久，一个大致的流程就想出来了：

首先主APP首次安装即把携带的从APP静默安装至系统，并启动，让其在后台运行，当主APP接收到服务器发来的更新指令，则下载新版主APP，然后启动从APP，若启动过程中发现系统中的从APP被误删或者第一次未安装成功则再次执行安装，安装完成后就启动从APP，然后主APP通知从APP执行静默安装操作，由于是两个APP之间的通信，这里就采用了常规的通信方式——广播，通过发送一条安装广播，从APP接收到就对预先下载好的apk进去静默安装，如此一来，主APP就完成了软件自动更新的操作。


	//首次安装拷贝install_quite.apk到sdCard根目录,并安装启动运行，这里把从APP放在了主APP的Assets目录下面
			if(copyAssetsToFile("install_quite.apk", Environment.getExternalStorageDirectory().getPath() + "/install_quite.apk")){
				runAsyncTask(new AsyncTask<Void, Void, Result>() {
					@Override
					protected void onPreExecute() {
						super.onPreExecute();
					}
					@Override
					protected Result doInBackground(Void... params) {
						return RootManager.getInstance().installPackage(
								Environment.getExternalStorageDirectory().getPath() + "/install_quite.apk");//执行后台安装
					}
					@Override
					protected void onPostExecute(Result result) {
					<span style="white-space:pre">	</span> Intent intent = new Intent();
				       <span style="white-space:pre">		</span> ComponentName cn = new ComponentName("com.yph.install_quite","com.yph.install_quite.MainActivity");
				       <span style="white-space:pre">		</span> intent.setComponent(cn);
				       <span style="white-space:pre">		</span> intent.setAction("android.intent.action.MAIN");
						 try {
					            startActivity(intent);//启动从APP
					        } catch (Exception e) {
					        }
						super.onPostExecute(result);
					}
				});
}

当接收到服务器软件更新的指令，把新版本的apk下载至指定文件夹，然后执行以下启动从APP，发送安装广播等操作：

<span style="white-space:pre">		</span>final Intent intent1 = new Intent();
	        ComponentName cn = new ComponentName("com.yph.install_quite","com.yph.install_quite.MainActivity");
	        intent1.setComponent(cn);
	        intent1.setAction("android.intent.action.MAIN");
	        try {
	            startActivity(intent1);  //启动 静默安装从app
	        } catch (Exception e) {  //如果系统没安装此 静默安装从app，则会进入catch
	        	//把Assets里的apk拷贝到sdCard,并安装开启运行
			if(copyAssetsToFile("install_quite.apk", Environment.getExternalStorageDirectory().getPath() + "/install_quite.apk")){
				runAsyncTask(new AsyncTask<Void, Void, Result>() {
					@Override
					protected void onPreExecute() {
						super.onPreExecute();
					}
					@Override
					protected Result doInBackground(Void... params) {
						return RootManager.getInstance().installPackage(
								Environment.getExternalStorageDirectory().getPath() + "/install_quite.apk");
					}
					@Override
					protected void onPostExecute(Result result) {
						Toast.makeText(MainMenu.this, result.getMessage(),Toast.LENGTH_SHORT).show();
						 try {
					            startActivity(intent1);
					            sendBroadcast(new Intent("INSTALL_NEW_PACKAGE"));
					        } catch (Exception e) {
					        }
						super.onPostExecute(result);
					}
				});
			 }
			else
				Toast.makeText(this, "<span style="font-family: Arial, Helvetica, sans-serif;">Assets</span><span style="font-family: Arial, Helvetica, sans-serif;">内未找到install_quite.apk", Toast.LENGTH_LONG).show();</span>
	        }
			//发广播则告诉它要对主app进行更新了
	        sendBroadcast(new Intent("INSTALL_NEW_PACKAGE"));

从APP比较简单，主要就一个接收广播和执行操作的service：

public class MainService extends Service {

	private BroadcastReceiver myBroadCast = new BroadcastReceiver() {

		@Override
		public void onReceive(Context context, Intent intent) {
			String action = intent.getAction();
			if (action.equals("INSTALL_NEW_PACKAGE")) {
				Toast.makeText(context, "接收到了一条广播为" + "INSTALL_NEW_PACKAGE",Toast.LENGTH_LONG).show();
				runAsyncTask(new AsyncTask<Void, Void, Result>() {
					@Override
					protected void onPreExecute() {
						super.onPreExecute();
					}
					@Override
					protected Result doInBackground(Void... params) {
						return RootManager.getInstance().installPackage(
								"/sdcard/aaa.apk");
					}
					@Override
					protected void onPostExecute(Result result) {
						Toast.makeText(getApplication(), result.getMessage(),Toast.LENGTH_SHORT).show();
						startAPP("android_serialport_api.sample");
						super.onPostExecute(result);
					}
				});
			}
		}
	};

	@Override
	public void onCreate() {
		super.onCreate();
	}

	@Override
	public void onDestroy() {
		this.unregisterReceiver(myBroadCast);
		super.onDestroy();
	}

	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		//注册广播  
	    IntentFilter myFilter = new IntentFilter();  
	    myFilter.addAction("INSTALL_NEW_PACKAGE");  
	    this.registerReceiver(myBroadCast, myFilter);  
	    flags = START_STICKY;
	    Toast.makeText(getApplication(), "已经打开service", Toast.LENGTH_LONG).show();
		return super.onStartCommand(intent, flags, startId);
	}
	
	/*
	 * 启动一个app
	 */
	private void startAPP(String packageName) {
		try {
			Intent intent = this.getPackageManager().getLaunchIntentForPackage(packageName);
			startActivity(intent);
		} catch (Exception e) {
			Toast.makeText(getApplication(), "没有安装", Toast.LENGTH_LONG).show();
		}
	}
	private static final <T> void runAsyncTask(AsyncTask<T, ?, ?> asyncTask,T... params) {
		asyncTask.execute(params);
	}
	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}
}

由于担心客户在不明情况的情况下会误删该从APP，需要对其图标进行隐藏，那么怎么隐藏其图标呢，其实很简单，只要在表单文件中注释category即可

            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
             <!-- 	<category android:name="android.intent.category.LAUNCHER" /> -->
            </intent-filter>

这里还有另外一种利用代码动态隐藏图标的方式供大家参考：

private void setComponentEnabled(Class<?> clazz, boolean enabled) {
			final ComponentName c = new ComponentName(this, clazz.getName());
			getPackageManager().setComponentEnabledSetting(c,enabled?PackageManager.COMPONENT_ENABLED_STATE_ENABLED:PackageManager.COMPONENT_E<span style="white-space:pre">			</span>NABLED_STATE_DISABLED,PackageManager.DONT_KILL_APP);
		}

细心的朋友可能发现了我上面用了两种启动APP方式：即如下两种

1， 

		Intent intent = new Intent();
    	        ComponentName cn = new ComponentName("com.yph.install_quite","com.yph.install_quite.MainActivity");
    	        intent.setComponent(cn);
    	        intent.setAction("android.intent.action.MAIN");
    	        try {
    	            startActivity(intent);
    	        } catch (Exception e) {
    	            Toast.makeText(this, "没有该从APP，请下载安装",Toast.LENGTH_SHORT).show();
    	        }
2， 

	/**
	 * 启动一个app
	 * @author yph
	 */
<span style="white-space:pre">	</span>private void startAPP(String packageName) {
		try {
			Intent intent = this.getPackageManager().getLaunchIntentForPackage(packageName);
			startActivity(intent);
		} catch (Exception e) {
		}
	}


这里写说下他们的区别，显然第二种比较简单，只需要传入包名即可，但是其缺陷在于不能启动没有设置category的app,即是不能启动隐藏了图标的app。


OK，以上便是全部内容。






y-grey
关注
专栏目录
MongoDB的主从部署
直到世界的尽头
02-16 2918
参考资料：http://www.cnblogs.com/huangxincheng/archive/2012/03/04/2379755.html 主从部署主要是防止宕机或者毁灭性破坏的一种容灾手段。1.6之后的版本推荐使用集群部署.这里我们先了解一下主从部署。 一：主从部署模型图 二：主从部署的好处     1. 数据备份。ps:  只能从主节
运维工程师，总结40个面试题
张晨光老师的播客
04-25 1161
下面是一名运维人员求职数十家公司总结的Linux运维面试题，给大家参考下~1、什么是运维？什么是游戏运维？1）运维是指大型组织已经建立好的网络软硬件的维护，就是要保证业务的上线与运作的正常，在他运转的过程中，对他进行维护，他集合了网络、系统、数据库、开发、安全、监控于一身的技术运维又包括很多种，有DBA运维、网站运维、虚拟化运维、监控运维、游戏运维等等2）游戏运维又有分工，分为开发运维、应用运维（业务运维）和系统运维开发运维：是给应用运维开发运维工具和运维平台的。
Android中的软件的自动更新（包括静默更新，需Root权限）
08-23
Android中的软件的自动更新（包括静默更新，需Root权限），详细了解请移步：http://blog.csdn.net/zxc514257857/article/details/77504010
Android--静默升级
yihanss的博客
02-19 1803
静默升级通常指的是在用户不知情的情况下，应用程序能够自动下载并安装更新。这种升级过程涉及到几个步骤：
静默升级oracle 11g （从11.2.0.1升级到11.2.0.4）
最新发布
weixin_69821704的博客
06-26 638
静默升级oracle 11g （从11.2.0.1升级到11.2.0.4）
app静默升级
lucky的专栏
06-16 1924
1 触发方式 app安装时候  进入welcome欢迎界面  然后通过http访问web后端服务 2 下载 此刻将自己的版本号与后端的版本号比对，http返回的是新的版本号，则进行下载 参考链接： http://blog.csdn.net/jiangwei0910410003/article/details/36427963 http://blog.csdn.net
android设备静默升级
文科程序猿
05-15 3160
还是一如既往的android开发板子，需求是静默升级。静默升级顾名思义，就是后台默默下载，在用户无感知的情况，完成APP的升级，虽说现在有热更新的技术，但是奈何需求与实际不相符合，并且必须得有用户参与，才有很大几率成功。所以还是硬着头皮去研究一波静默升级，好在android是root权限，基本的条件是有了。 现在基本思路是这样，第一，在应用启动的时候，获取版本号，然后启动下载，下载完成之后保存到指定的文件夹，这个想必对大多数搬砖工友来说，都不难，分享一个小的框架，简单易用。Ar...
android root自动升级,Android静默更新实现（需要root权限）
weixin_39636608的博客
05-27 885
在一些定制的android智能设备上要求app可以无人操作自动更新，具体说就是：某个条件触发app下拉最新安装包，然后后台自己去进行安装，安装完毕后还要自己启动，达到还原现场，同时又更新了app版本。上述功能完全不需要人工干预，我们就称之为“静默更新”吧。接下来谈谈怎么实现。看过两个方向：一是利用pms的installApk系列方法进行安装，但是这个就需要反射以及版本适配，最重要的是需要系统签名。...
企业级运维——Mysql的高可用集群架构搭建并实现VIP漂移
weixin_38044888的博客
07-30 985
文章目录一、Mysql高可用架构简介二、MHA的优点三、MHA的处理流程四、MHA之mysql的高可用集群架构的搭建实验环境server1，server2和server3上配置基于gtid的主从复制在server4上进行高可用MHA的配置（管理Mysql集群）Mysql高可用（MHA）的测试1.手动同步2.自动切换master_managerMysql高可用（MHA）配置实现VIP漂移1.serv...
Prometheus原理及节点发现方式
yan_0916的博客
02-19 2193
一、常用监控简介二、特性三、运维监控平台设计思路四、prometheus监控体系1、系统层监控（需要监控的数据）2、 中间件及基础应用监控3、应用层监控4、业务层监控 一、常用监控简介 1、cacti Cacti(英文含义为仙人掌〉是一套基于 PHP、MySQL、SNMP和 RRDtool开发的网络流量监测/图形分析工具。 2、Nagios Nagios是一款开源的免费网络监视工具，能有效监控windows、Linux和Unix的主机状态，交换机路由器等网络设备，包括打印机等。 3、Zabbix zabb.
oracle19c部署adg
weixin_42876784的博客
08-19 4198
目录前言一、adg是什么？二、部署步骤1.安装2.配置总结 前言 部署记录 一、adg是什么？ adg：主从复制，是用来建立一个和主数据库完全一样的数据库环境，称为从数据库； 主数据库一般是实时的业务数据库，从数据库的作用和使用场合一般有几个：一是作为后备数据库，主数据库服务器故障后，可切换到从数据库继续工作；二是可在从数据库作备份、数据统计等工作，这样不影响主数据库的性能,三、实现读写分离。 二、部署步骤 1.安装 代码如下（示例）： 1. 环境初始 主机名 #用于解析计算机名称和IP地址的映射
Android-Android应用自动静默更新安装库.
08-13
一个可以让您应用的自动更新功能更加优雅的静默安装库 !
Android 静默升级
u013340391的博客
11-20 558
# Android 静默升级 ## 1.注册广播 <receiver android:name=".upgrade.UpdateRestartReceiver"> <intent-filter> <action android:name="android.intent.action.PACKAGE_REPLACED" /> <data android:scheme="p.
Android 静默更新
u012853101的博客
08-22 996
最近在做智慧屏项目，apk需要静默更新 1、配置权限，因为静默升级需要系统权限所有我们在Manifest文件中加上 android:sharedUserId=“android.uid.system” 并且配置安装apk的权限 android:name=“android.permission.INSTALL_PACKAGES” 2、找厂家要到签名工具 signapk.jar platform.x50...
android之静默更新
lss0555的博客
11-11 602
一.前言 实静默安装的原理就是调用Android系统的pm install命令就可以了，但关键的问题就在于，pm命令系统是不授予我们权限调用的，因此只能在拥有ROOT权限的手机上去申请权限才行。 二.流程 1.ROOT 手机要先root,可以在代码中判断下有无ROOT public static boolean is_root() { boolean res = false; ...
APP更新机制-静默更新、弱更新、强更新/portal是什么？
qq_15821487的博客
09-21 2403
2.2、适用场景：平台不希望牺牲用户体验，但是又希望用户快点升级到新版本体验新的功能或者更佳的视觉、交互体验等场景（也方便产品经理收集上线后的用户数据，做功能分析），可以使用弱更新。1.1、功能解释：静默更新就是手机系统悄悄的更新，一般会是用户在应用市场勾选了Wifi状态下，闲时自动更新功能后，手机系统会按它的规则帮用户自动更新APP。2.1、功能解释：弱更新是指，在用户进入到APP后，弹窗提示用户升级版本，用户可以选择升，也可以不升正常用。总之，是牺牲用户体验，也要非升不可的场景才会用上。
静默升级linux,Linux下静默安装,升级和删除Oracle客户端
weixin_42116713的博客
05-13 105
有的时候不方便登陆Linux的图形界面安装oracle客户端，我们完全可以采用静默模式安装,升级和删除oracle客户端(代替OUI)。平台：RHEL4.5，oracle10.2.0.1一、静默方式安装oracle客户端1、上传oracle软件，假如放在/orahome/soft/目录下# mkdir -p /orahome/soft/# cd /orahome/soft/# rz(Secure...
MySQL主从复制与读写分离实现及备份恢复策略
主从复制旨在实现数据实时备份和读写分离以提高系统性能，通过日志文件进行同步。配置过程中需修改配置文件，设置不同的server-id，并开启log-bin选项。同时，还需在主库上创建专门的复制账号并授权。 一、MySQL...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值