App 版本信息等

最新推荐文章于 2023-10-18 16:07:36 发布
最新推荐文章于 2023-10-18 16:07:36 发布
阅读量371 收藏
点赞数
分类专栏： android工具 文章标签： app 
package com.github.lazylibrary.util; /**
 * Copyright 2014 Zhenguo Jin
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.io.ByteArrayInputStream;
import java.io.File;

import java.io.FileFilter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.MessageDigest;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import android.app.ActivityManager;
import android.app.ActivityManager.MemoryInfo;
import android.app.ActivityManager.RunningAppProcessInfo;
import android.app.ActivityManager.RunningServiceInfo;
import android.app.ActivityManager.RunningTaskInfo;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.Signature;
import android.net.Uri;
import android.text.TextUtils;

import javax.security.auth.x500.X500Principal;

/**
 * APP工具类
 * APP相关信息工具类。获取版本信息
 *
 * @author jingle1267@163.com
 */
public final class AppUtils {

    private static final boolean DEBUG = true;
    private static final String TAG = "AppUtils";


    /**
     * Don't let anyone instantiate this class.
     */
    private AppUtils() {
        throw new Error("Do not need instantiate!");
    }


    /**
     * 得到软件版本号
     *
     * @param context 上下文
     * @return 当前版本Code
     */
    public static int getVerCode(Context context) {
        int verCode = -1;
        try {
            String packageName = context.getPackageName();
            verCode = context.getPackageManager()
                             .getPackageInfo(packageName, 0).versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return verCode;
    }


    /**
     * 获取应用运行的最大内存
     *
     * @return 最大内存
     */
    public static long getMaxMemory() {

        return Runtime.getRuntime().maxMemory() / 1024;
    }


    /**
     * 得到软件显示版本信息
     *
     * @param context 上下文
     * @return 当前版本信息
     */
    public static String getVerName(Context context) {
        String verName = "";
        try {
            String packageName = context.getPackageName();
            verName = context.getPackageManager()
                             .getPackageInfo(packageName, 0).versionName;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return verName;
    }


    /**
     * 安装apk
     *
     * @param context 上下文
     * @param file    APK文件
     */
    public static void installApk(Context context, File file) {
        Intent intent = new Intent();
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.setAction(Intent.ACTION_VIEW);
        intent.setDataAndType(Uri.fromFile(file),
                "application/vnd.android.package-archive");
        context.startActivity(intent);
    }


    /**
     * 安装apk
     *
     * @param context 上下文
     * @param file    APK文件uri
     */
    public static void installApk(Context context, Uri file) {
        Intent intent = new Intent();
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.setAction(Intent.ACTION_VIEW);
        intent.setDataAndType(file, "application/vnd.android.package-archive");
        context.startActivity(intent);
    }


    /**
     * 卸载apk
     *
     * @param context     上下文
     * @param packageName 包名
     */
    public static void uninstallApk(Context context, String packageName) {
        Intent intent = new Intent(Intent.ACTION_DELETE);
        Uri packageURI = Uri.parse("package:" + packageName);
        intent.setData(packageURI);
        context.startActivity(intent);
    }


    /**
     * 检测服务是否运行
     *
     * @param context   上下文
     * @param className 类名
     * @return 是否运行的状态
     */
    public static boolean isServiceRunning(Context context, String className) {
        boolean isRunning = false;
        ActivityManager activityManager
                = (ActivityManager) context.getSystemService(
                Context.ACTIVITY_SERVICE);
        List<RunningServiceInfo> servicesList
                = activityManager.getRunningServices(Integer.MAX_VALUE);
        for (RunningServiceInfo si : servicesList) {
            if (className.equals(si.service.getClassName())) {
                isRunning = true;
            }
        }
        return isRunning;
    }


    /**
     * 停止运行服务
     *
     * @param context   上下文
     * @param className 类名
     * @return 是否执行成功
     */
    public static boolean stopRunningService(Context context, String className) {
        Intent intent_service = null;
        boolean ret = false;
        try {
            intent_service = new Intent(context, Class.forName(className));
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (intent_service != null) {
            ret = context.stopService(intent_service);
        }
        return ret;
    }


    /**
     * 得到CPU核心数
     *
     * @return CPU核心数
     */
    public static int getNumCores() {
        try {
            File dir = new File("/sys/devices/system/cpu/");
            File[] files = dir.listFiles(new FileFilter() {
                @Override public boolean accept(File pathname) {
                    if (Pattern.matches("cpu[0-9]", pathname.getName())) {
                        return true;
                    }
                    return false;
                }
            });
            return files.length;
        } catch (Exception e) {
            return 1;
        }
    }


    /**
     * whether this process is named with processName
     *
     * @param context     上下文
     * @param processName 进程名
     * @return 是否含有当前的进程
     */
    public static boolean isNamedProcess(Context context, String processName) {
        if (context == null || TextUtils.isEmpty(processName)) {
            return false;
        }

        int pid = android.os.Process.myPid();
        ActivityManager manager = (ActivityManager) context.getSystemService(
                Context.ACTIVITY_SERVICE);
        List<RunningAppProcessInfo> processInfoList
                = manager.getRunningAppProcesses();
        if (processInfoList == null) {
            return true;
        }

        for (RunningAppProcessInfo processInfo : manager.getRunningAppProcesses()) {
            if (processInfo.pid == pid &&
                    processName.equalsIgnoreCase(processInfo.processName)) {
                return true;
            }
        }
        return false;
    }


    /**
     * whether application is in background
     * <ul>
     * <li>need use permission android.permission.GET_TASKS in Manifest.xml</li>
     * </ul>
     *
     * @param context 上下文
     * @return if application is in background return true, otherwise return
     * false
     */
    public static boolean isApplicationInBackground(Context context) {
        ActivityManager am = (ActivityManager) context.getSystemService(
                Context.ACTIVITY_SERVICE);
        List<RunningTaskInfo> taskList = am.getRunningTasks(1);
        if (taskList != null && !taskList.isEmpty()) {
            ComponentName topActivity = taskList.get(0).topActivity;
            if (topActivity != null && !topActivity.getPackageName()
                                                   .equals(context.getPackageName())) {
                return true;
            }
        }
        return false;
    }


    /**
     * 获取应用签名
     *
     * @param context 上下文
     * @param pkgName 包名
     * @return 返回应用的签名
     */
    public static String getSign(Context context, String pkgName) {
        try {
            PackageInfo pis = context.getPackageManager()
                                     .getPackageInfo(pkgName,
                                             PackageManager.GET_SIGNATURES);
            return hexdigest(pis.signatures[0].toByteArray());
        } catch (NameNotFoundException e) {
            e.printStackTrace();
            return null;
        }

    }


    /**
     * 将签名字符串转换成需要的32位签名
     *
     * @param paramArrayOfByte 签名byte数组
     * @return 32位签名字符串
     */
    private static String hexdigest(byte[] paramArrayOfByte) {
        final char[] hexDigits = { 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
                98, 99, 100, 101, 102 };
        try {
            MessageDigest localMessageDigest = MessageDigest.getInstance("MD5");
            localMessageDigest.update(paramArrayOfByte);
            byte[] arrayOfByte = localMessageDigest.digest();
            char[] arrayOfChar = new char[32];
            for (int i = 0, j = 0; ; i++, j++) {
                if (i >= 16) {
                    return new String(arrayOfChar);
                }
                int k = arrayOfByte[i];
                arrayOfChar[j] = hexDigits[(0xF & k >>> 4)];
                arrayOfChar[++j] = hexDigits[(k & 0xF)];
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }


    /**
     * 清理后台进程与服务
     *
     * @param context 应用上下文对象context
     * @return 被清理的数量
     */
    public static int gc(Context context) {
        long i = getDeviceUsableMemory(context);
        int count = 0; // 清理掉的进程数
        ActivityManager am = (ActivityManager) context.getSystemService(
                Context.ACTIVITY_SERVICE);
        // 获取正在运行的service列表
        List<RunningServiceInfo> serviceList = am.getRunningServices(100);
        if (serviceList != null) {
            for (RunningServiceInfo service : serviceList) {
                if (service.pid == android.os.Process.myPid()) continue;
                try {
                    android.os.Process.killProcess(service.pid);
                    count++;
                } catch (Exception e) {
                    e.getStackTrace();
                }
            }
        }

        // 获取正在运行的进程列表
        List<RunningAppProcessInfo> processList = am.getRunningAppProcesses();
        if (processList != null) {
            for (RunningAppProcessInfo process : processList) {
                // 一般数值大于RunningAppProcessInfo.IMPORTANCE_SERVICE的进程都长时间没用或者空进程了
                // 一般数值大于RunningAppProcessInfo.IMPORTANCE_VISIBLE的进程都是非可见进程，也就是在后台运行着
                if (process.importance >
                        RunningAppProcessInfo.IMPORTANCE_VISIBLE) {
                    // pkgList 得到该进程下运行的包名
                    String[] pkgList = process.pkgList;
                    for (String pkgName : pkgList) {
                        if (DEBUG) {

                        }
                        try {
                            am.killBackgroundProcesses(pkgName);
                            count++;
                        } catch (Exception e) { // 防止意外发生
                            e.getStackTrace();
                        }
                    }
                }
            }
        }
        if (DEBUG) {

        }
        return count;
    }


    /**
     * 获取设备的可用内存大小
     *
     * @param context 应用上下文对象context
     * @return 当前内存大小
     */
    public static int getDeviceUsableMemory(Context context) {
        ActivityManager am = (ActivityManager) context.getSystemService(
                Context.ACTIVITY_SERVICE);
        MemoryInfo mi = new MemoryInfo();
        am.getMemoryInfo(mi);
        // 返回当前系统的可用内存
        return (int) (mi.availMem / (1024 * 1024));
    }


    /**
     * 获取系统中所有的应用
     *
     * @param context 上下文
     * @return 应用信息List
     */
    public static List<PackageInfo> getAllApps(Context context) {

        List<PackageInfo> apps = new ArrayList<PackageInfo>();
        PackageManager pManager = context.getPackageManager();
        List<PackageInfo> paklist = pManager.getInstalledPackages(0);
        for (int i = 0; i < paklist.size(); i++) {
            PackageInfo pak = paklist.get(i);
            if ((pak.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) <=
                    0) {
                // customs applications
                apps.add(pak);
            }
        }
        return apps;
    }


    /**
     * 获取手机系统SDK版本
     *
     * @return 如API 17 则返回 17
     */
    public static int getSDKVersion() {
        return android.os.Build.VERSION.SDK_INT;
    }


    /**
     * 是否Dalvik模式
     *
     * @return 结果
     */
    public static boolean isDalvik() {
        return "Dalvik".equals(getCurrentRuntimeValue());
    }


    /**
     * 是否ART模式
     *
     * @return 结果
     */
    public static boolean isART() {
        String currentRuntime = getCurrentRuntimeValue();
        return "ART".equals(currentRuntime) ||
                "ART debug build".equals(currentRuntime);
    }


    /**
     * 获取手机当前的Runtime
     *
     * @return 正常情况下可能取值Dalvik, ART, ART debug build;
     */
    public static String getCurrentRuntimeValue() {
        try {
            Class<?> systemProperties = Class.forName(
                    "android.os.SystemProperties");
            try {
                Method get = systemProperties.getMethod("get", String.class,
                        String.class);
                if (get == null) {
                    return "WTF?!";
                }
                try {
                    final String value = (String) get.invoke(systemProperties,
                            "persist.sys.dalvik.vm.lib",
                        /* Assuming default is */"Dalvik");
                    if ("libdvm.so".equals(value)) {
                        return "Dalvik";
                    }
                    else if ("libart.so".equals(value)) {
                        return "ART";
                    }
                    else if ("libartd.so".equals(value)) {
                        return "ART debug build";
                    }

                    return value;
                } catch (IllegalAccessException e) {
                    return "IllegalAccessException";
                } catch (IllegalArgumentException e) {
                    return "IllegalArgumentException";
                } catch (InvocationTargetException e) {
                    return "InvocationTargetException";
                }
            } catch (NoSuchMethodException e) {
                return "SystemProperties.get(String key, String def) method is not found";
            }
        } catch (ClassNotFoundException e) {
            return "SystemProperties class is not found";
        }
    }


    private final static X500Principal DEBUG_DN = new X500Principal(
            "CN=Android Debug,O=Android,C=US");


    /**
     * 检测当前应用是否是Debug版本
     *
     * @param ctx 上下文
     * @return 是否是Debug版本
     */
    public static boolean isDebuggable(Context ctx) {
        boolean debuggable = false;
        try {
            PackageInfo pinfo = ctx.getPackageManager()
                                   .getPackageInfo(ctx.getPackageName(),
                                           PackageManager.GET_SIGNATURES);
            Signature signatures[] = pinfo.signatures;
            for (int i = 0; i < signatures.length; i++) {
                CertificateFactory cf = CertificateFactory.getInstance("X.509");
                ByteArrayInputStream stream = new ByteArrayInputStream(
                        signatures[i].toByteArray());
                X509Certificate cert = (X509Certificate) cf.generateCertificate(
                        stream);
                debuggable = cert.getSubjectX500Principal().equals(DEBUG_DN);
                if (debuggable) break;
            }
        } catch (NameNotFoundException e) {
        } catch (CertificateException e) {
        }
        return debuggable;
    }
}
yunzhonghe5786
关注
专栏目录
检测app版本
02-29
- 要实现版本检测，服务器端需要提供一个API，返回当前可用的最新版本信息，包括版本号、更新日志、下载链接等。 - 这个接口通常是JSON格式，如：`{"latestVersion": "1.4.5", "updateLog": "修复了一些bug, 添加...
android如何获取应用版本号和版本名称
热门推荐
android丿Studio`
08-13 4万+
在android中，一个应用有对应的版本号versionCode和versionName代表的是版本信息。一般在应用的刚打开的欢迎页面，会有当前应用的版本号显示。当然在应用的帮助模块也有显示这个。 当然版本号可以自定义设置，但是后者设置的版本号不能低于前者设置的版本号，否则是无法更新最新版本的。一般版本号都是设置为1，然后慢慢升级设置版本号1.1，1.1.1等等版本号。至于版本信息version
查看apk的版本信息
最新发布
weixin_62916723的博客
10-18 1787
两种方法（aapt、Android Studio）查看apk的版本信息
获取App应用版本号或者当前版本号
来啊 快活啊
06-21 2384
有时候制作App是需要做一个版本信息的功能，这时就需要读取当前版本号，下面我来介绍一种方法吧 在AndroidManifest.xml中设置程序的版本号等，如android:versionName=”1.0.0” 那如果想在代码中获取这个版本号呢，可以用如下方法(这些修改版本号时只需要修改AndroidManifest.xml中的设置，不用修改代码了) 我们要读取的就是versionNam
ios应用版本号设置规则
依楼听风雨，落花方知惜~~
02-18 1万+
已经完成的应用再上传到app store的时候 都要求添加它的版本号 那么这个版本号随着应用的升级，该怎么去设置呢？ 这里我来浅谈一下 假设我第一版release的app 的版本号是ver 1.0.0 1.我再ver1.0.0的基础上 修复了某些bug 做了小小的改动 那么我第二次提交的版本号应该是ver 1.0.1, 也就是在第三位+1，前面两位不变 2.如果在ver1.0.0的基础上增
如何查看手机app的ua及版本信息
宋坚强大大~~
10-18 1万+
在app内 打开   http://www.ip138.com/useragent/   这个地址会看到如下展示    这里包含了所有关于window.navigator.userAgent的信息
App信息管理系统
07-16
用ssm做的，个人写了非常详细的注释，数据库文件在里面，包括前台（登录，注销，查询APP信息列表，新增，修改，新增APP版本信息，修改APP版本信息，查看APP，删除APP，App上下架操作）和后台（登录，注销，查看待...
APP信息管理系统
11-11
用户可以在这里查看应用的详细介绍，比如应用的功能、版本信息、开发者信息、用户评价等。同时，前台还可能提供应用的分类和推荐功能，帮助用户快速找到符合需求的应用。 后台则是系统的运营和管理核心，主要负责...
安卓APP版本号命名
02-28
本文将深入探讨安卓APP版本号命名的规范和常见实践。 首先，安卓APP的版本号通常由两部分组成：`版本号（Version Number）`和`构建号（Build Number）`。在Android系统中，这两部分可以分别通过`android:...
android 获取本机其他app的版本信息的示例代码
08-29
在Android平台上，获取其他应用程序的版本信息是开发者经常会遇到的需求，比如进行应用更新检查或集成自动化测试时。本文将详细讲解如何通过示例代码来实现这一功能。 首先，我们需要创建一个用于存储应用信息的...
Android获取App版本信息
XieChaoAndroid的博客
11-28 633
import android.content.Context; import android.content.pm.ApplicationInfo; import android.content.pm.PackageInfo; import android.content.pm.PackageManager;public class PackageUtils { /** * 获取版本
app版本信息
huzhaohao的专栏
01-20 351
NSDictionary *infoDictionary = [[NSBundle mainBundle] infoDictionary];   NSString *name = [infoDictionary objectForKey:@"CFBundleDisplayName"];   NSString *version = [infoDictionary objectForKey:@"C
获得当前app的版本信息
tangaowen的专栏
01-21 1147
两个UINT64数字的比较函数： 获得当前app的版本信息
PackageUtils（一个获取APP版本信息的工具类）
计蒙不吃鱼的博客
08-12 3486
用途：用于APP更新 功能： 1.获取当前应用的名称：getAppName 2.获取当前应用的版本号：getVersionCode 3.获取当前应用的版本名称：getVersionName /*用途 * 1.获取当前应用的名称：getAppName * 2.获取当前应用的版本号：getVersionCode * 3.获取当前应用的版本名称：getVersionName */ public cla...
获取APP版本信息，可用于更新
wz119的专栏
03-18 450
/** * 获取版本信息 *  * @param context * @return */ public static String getVersion(Context context) { try { PackageInfo info = context.getPackageManager().getPackageInfo( context.getPackageName(),
将版本信息显示在App图标上
夏天然后的技术专栏
04-14 1115
测试Xcode版本: 7.2.1 在测试App版本升级功能或者需要多版本切换的时候，可能需要经常去确定当前App的版本号，如果中途打断很有可能会忘记了当前的版本号，并且App内部如果没有显示版本号的功能，就只能从头来了。 如果能让App的版本信息直接显示到图标上，测试的时候是不是就会更加直观，更加效率，更加苏胡 原文链接：http://www.jianshu.com/p/4ccea3d2ba0
Android获取app版本信息
qq_37077360的博客
05-04 711
1、获取包的信息private static PackageInfo getPackageInfo(Context context) { PackageInfo pi = null; try { PackageManager pm = context.getPackageManager(); pi = pm.getPackageInfo(context.getPac...
从App Store上获取已经上架的App版本信息
weixin_30663471的博客
03-20 151
一般App在设备上启动后都会有做版本检测以确认本版本是否是最新版本的App，以便提示用户更新到最新版本。 当然可以在公司的的服务器做接口查询，这是一个比较笨的办法，但鉴于iOS App的上架App特性，我们希望检测到当前设备安装的版本与 App Store上的版本比较，具体操作如下： 1. 如何从App Store上获取指定App的信息？ 这里可以通过Apple公司提供的RE...
APP版本号命名规范及原则
gao_chun
05-17 4万+
为什么需要规范APP命名？ 当我们在需求及业务明确后，产品及设计已经做出了对应的文档及UI图，那么进入研发阶段开始编码实现功能，当功能实现的差不多了之后，期间会需要签出不同的包作为展示或测试，不管当前的进度处于什么阶段，签出对应安装包的时候都会对其进行命名并发送给测试人员。一般往往通过命名，就可以大概知道当前签出的包处于哪个版本阶段，Alpha阶段？Beta阶段？R
Python_Adb自动化获取Android App版本信息并生成表格
总结来说，《自拍教程51》中的Python_adb批量生成App版本表格教程展示了如何利用自动化脚本工具高效管理Android设备上的应用版本，这对于软件开发团队进行版本管理和测试数据收集具有实际价值。通过这个教程，开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值