android 应用内部下载安装apk 安装时提示：恶意安装来源

问题：自己编写了一个android的APP，里面有一个“下载并安装” 其它APP的功能。

操作步骤：
在华为鸿蒙系统上，下载完对应的APK后（剪映），进行安装时提示，无法继续安装，请问如何解决？

1、已经关闭了：纯净模式

写回答
好问题 0 提建议
追加酬金
关注问题
分享
邀请回答
编辑收藏删除结题
收藏举报

1条回答默认最新

CSDN-Ada助手 CSDN-AI 官方账号 2023-11-05 20:07

关注

【相关推荐】

你可以看下这个问题的回答https://ask.csdn.net/questions/736470
我还给你找了一篇非常好的博客，你可以看看是否有帮助，链接：安卓开发：魅族手机安装apk安装包提示安装失败、更新包不兼容问题的解决方法
您还可以看一下霍常亮老师的教你30分钟将网站封装成原生态APP课程中的制作安卓证书，生成APK文件小节, 巩固相关知识点

除此之外, 这篇博客: android 系统中将一个apk应用打入死牢==》禁止在android系统中安装某一个apk应用中的需求部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

有时候我们在维护开发一个android 系统的时候，不想要我们这个系统去安装某一个公司的apk，只要是已安装，就会安装失败。我们可以这样做：

在PMS中：

frameworks / base/services/core/java/com/android/server/pm/PackageManagerService.java

 /*
         * Invoke remote method to get package information and install
         * location values. Override install location based on default
         * policy if needed and then create install arguments based
         * on the install location.
         */
        public void handleStartCopy() throws RemoteException {
            int ret = PackageManager.INSTALL_SUCCEEDED;

            // If we're already staged, we've firmly committed to an install location
            if (origin.staged) {
                if (origin.file != null) {
                    installFlags |= PackageManager.INSTALL_INTERNAL;
                    installFlags &= ~PackageManager.INSTALL_EXTERNAL;
                } else {
                    throw new IllegalStateException("Invalid stage location");
                }
            }

            final boolean onSd = (installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
            final boolean onInt = (installFlags & PackageManager.INSTALL_INTERNAL) != 0;
            final boolean ephemeral = (installFlags & PackageManager.INSTALL_INSTANT_APP) != 0;
            PackageInfoLite pkgLite = null;

            if (onInt && onSd) {
                // Check if both bits are set.
                Slog.w(TAG, "Conflicting flags specified for installing on both internal and external");
                ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
            } else if (onSd && ephemeral) {
                Slog.w(TAG,  "Conflicting flags specified for installing ephemeral on external");
                ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
            } else {
                pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath, installFlags,
                        packageAbiOverride);

                if (DEBUG_INSTANT && ephemeral) {
                    Slog.v(TAG, "pkgLite for install: " + pkgLite);
                }

                /*
                 * If we have too little free space, try to free cache
                 * before giving up.
                 */
                if (!origin.staged && pkgLite.recommendedInstallLocation
                        == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
                    // TODO: focus freeing disk space on the target device
                    final StorageManager storage = StorageManager.from(mContext);
                    final long lowThreshold = storage.getStorageLowBytes(
                            Environment.getDataDirectory());

                    final long sizeBytes = mContainerService.calculateInstalledSize(
                            origin.resolvedPath, packageAbiOverride);

                    try {
                        mInstaller.freeCache(null, sizeBytes + lowThreshold, 0, 0);
                        pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath,
                                installFlags, packageAbiOverride);
                    } catch (InstallerException e) {
                        Slog.w(TAG, "Failed to free cache", e);
                    }

                    /*
                     * The cache free must have deleted the file we
                     * downloaded to install.
                     *
                     * TODO: fix the "freeCache" call to not delete
                     *       the file we care about.
                     */
                    if (pkgLite.recommendedInstallLocation
                            == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
                        pkgLite.recommendedInstallLocation
                            = PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE;
                    }
                }
            }
			if（条件成立）{
		ret =PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;    //1
	}
            if (ret == PackageManager.INSTALL_SUCCEEDED) {
                int loc = pkgLite.recommendedInstallLocation;
                if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION) {
                    ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
                } else if (loc == PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS) {
                    ret = PackageManager.INSTALL_FAILED_ALREADY_EXISTS;
                } else if (loc == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
                    ret = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
                } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_APK) {
                    ret = PackageManager.INSTALL_FAILED_INVALID_APK;
                } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
                    ret = PackageManager.INSTALL_FAILED_INVALID_URI;
                } else if (loc == PackageHelper.RECOMMEND_MEDIA_UNAVAILABLE) {
                    ret = PackageManager.INSTALL_FAILED_MEDIA_UNAVAILABLE;
                } else {
                    // Override with defaults if needed.
                    loc = installLocationPolicy(pkgLite);
                    if (loc == PackageHelper.RECOMMEND_FAILED_VERSION_DOWNGRADE) {
                        ret = PackageManager.INSTALL_FAILED_VERSION_DOWNGRADE;
                    } else if (!onSd && !onInt) {
                        // Override install location with flags
                        if (loc == PackageHelper.RECOMMEND_INSTALL_EXTERNAL) {
                            // Set the flag to install on external media.
                            installFlags |= PackageManager.INSTALL_EXTERNAL;
                            installFlags &= ~PackageManager.INSTALL_INTERNAL;
                        } else if (loc == PackageHelper.RECOMMEND_INSTALL_EPHEMERAL) {
                            if (DEBUG_INSTANT) {
                                Slog.v(TAG, "...setting INSTALL_EPHEMERAL install flag");
                            }
                            installFlags |= PackageManager.INSTALL_INSTANT_APP;
                            installFlags &= ~(PackageManager.INSTALL_EXTERNAL
                                    |PackageManager.INSTALL_INTERNAL);
                        } else {
                            // Make sure the flag for installing on external
                            // media is unset
                            installFlags |= PackageManager.INSTALL_INTERNAL;
                            installFlags &= ~PackageManager.INSTALL_EXTERNAL;
                        }
                    }
                }
            }

            final InstallArgs args = createInstallArgs(this);
            mArgs = args;

            if (ret == PackageManager.INSTALL_SUCCEEDED) {
                // TODO: http://b/22976637
                // Apps installed for "all" users use the device owner to verify the app
                UserHandle verifierUser = getUser();
                if (verifierUser == UserHandle.ALL) {
                    verifierUser = UserHandle.SYSTEM;
                }

                /*
                 * Determine if we have any installed package verifiers. If we
                 * do, then we'll defer to them to verify the packages.
                 */
                final int requiredUid = mRequiredVerifierPackage == null ? -1
                        : getPackageUid(mRequiredVerifierPackage, MATCH_DEBUG_TRIAGED_MISSING,
                                verifierUser.getIdentifier());
                final int installerUid =
                        verificationInfo == null ? -1 : verificationInfo.installerUid;
                if (!origin.existing && requiredUid != -1
                        && isVerificationEnabled(
                                verifierUser.getIdentifier(), installFlags, installerUid)) {
                    final Intent verification = new Intent(
                            Intent.ACTION_PACKAGE_NEEDS_VERIFICATION);
                    verification.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
                    verification.setDataAndType(Uri.fromFile(new File(origin.resolvedPath)),
                            PACKAGE_MIME_TYPE);
                    verification.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

                    // Query all live verifiers based on current user state
                    final List<ResolveInfo> receivers = queryIntentReceiversInternal(verification,
                            PACKAGE_MIME_TYPE, 0, verifierUser.getIdentifier(),
                            false /*allowDynamicSplits*/);

                    if (DEBUG_VERIFY) {
                        Slog.d(TAG, "Found " + receivers.size() + " verifiers for intent "
                                + verification.toString() + " with " + pkgLite.verifiers.length
                                + " optional verifiers");
                    }

                    final int verificationId = mPendingVerificationToken++;

                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_ID, verificationId);

                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_PACKAGE,
                            installerPackageName);

                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALL_FLAGS,
                            installFlags);

                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_PACKAGE_NAME,
                            pkgLite.packageName);

                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_VERSION_CODE,
                            pkgLite.versionCode);

                    verification.putExtra(PackageManager.EXTRA_VERIFICATION_LONG_VERSION_CODE,
                            pkgLite.getLongVersionCode());

                    if (verificationInfo != null) {
                        if (verificationInfo.originatingUri != null) {
                            verification.putExtra(Intent.EXTRA_ORIGINATING_URI,
                                    verificationInfo.originatingUri);
                        }
                        if (verificationInfo.referrer != null) {
                            verification.putExtra(Intent.EXTRA_REFERRER,
                                    verificationInfo.referrer);
                        }
                        if (verificationInfo.originatingUid >= 0) {
                            verification.putExtra(Intent.EXTRA_ORIGINATING_UID,
                                    verificationInfo.originatingUid);
                        }
                        if (verificationInfo.installerUid >= 0) {
                            verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_UID,
                                    verificationInfo.installerUid);
                        }
                    }

                    final PackageVerificationState verificationState = new PackageVerificationState(
                            requiredUid, args);

                    mPendingVerification.append(verificationId, verificationState);

                    final List<ComponentName> sufficientVerifiers = matchVerifiers(pkgLite,
                            receivers, verificationState);

                    DeviceIdleController.LocalService idleController = getDeviceIdleController();
                    final long idleDuration = getVerificationTimeout();

                    /*
                     * If any sufficient verifiers were listed in the package
                     * manifest, attempt to ask them.
                     */
                    if (sufficientVerifiers != null) {
                        final int N = sufficientVerifiers.size();
                        if (N == 0) {
                            Slog.i(TAG, "Additional verifiers required, but none installed.");
                            ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
                        } else {
                            for (int i = 0; i < N; i++) {
                                final ComponentName verifierComponent = sufficientVerifiers.get(i);
                                idleController.addPowerSaveTempWhitelistApp(Process.myUid(),
                                        verifierComponent.getPackageName(), idleDuration,
                                        verifierUser.getIdentifier(), false, "package verifier");

                                final Intent sufficientIntent = new Intent(verification);
                                sufficientIntent.setComponent(verifierComponent);
                                mContext.sendBroadcastAsUser(sufficientIntent, verifierUser);
                            }
                        }
                    }

                    final ComponentName requiredVerifierComponent = matchComponentForVerifier(
                            mRequiredVerifierPackage, receivers);
                    if (ret == PackageManager.INSTALL_SUCCEEDED
                            && mRequiredVerifierPackage != null) {
                        Trace.asyncTraceBegin(
                                TRACE_TAG_PACKAGE_MANAGER, "verification", verificationId);
                        /*
                         * Send the intent to the required verification agent,
                         * but only start the verification timeout after the
                         * target BroadcastReceivers have run.
                         */
                        verification.setComponent(requiredVerifierComponent);
                        idleController.addPowerSaveTempWhitelistApp(Process.myUid(),
                                mRequiredVerifierPackage, idleDuration,
                                verifierUser.getIdentifier(), false, "package verifier");
                        mContext.sendOrderedBroadcastAsUser(verification, verifierUser,
                                android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
                                new BroadcastReceiver() {
                                    @Override
                                    public void onReceive(Context context, Intent intent) {
                                        final Message msg = mHandler
                                                .obtainMessage(CHECK_PENDING_VERIFICATION);
                                        msg.arg1 = verificationId;
                                        mHandler.sendMessageDelayed(msg, getVerificationTimeout());
                                    }
                                }, null, 0, null, null);

                        /*
                         * We don't want the copy to proceed until verification
                         * succeeds, so null out this field.
                         */
                        mArgs = null;
                    }
                } else {
                    /*
                     * No package verification is enabled, so immediately start
                     * the remote call to initiate copy using temporary file.
                     */
                    ret = args.copyApk(mContainerService, true);
                }
            }

            mRet = ret;
        }

在1处，可以直接根据条件将安装结果置为fail。这样就不会安装成功了。

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^

报告相同问题？

关注问题

Android app检测版本并下载apk后实现覆盖安装
2017-02-28 07:00

回答 3 已采纳 /** * 安装apk */ public static void installApk(Context context,String fileName) { File
android7.0弹出apk安装界面 android
2017-05-23 05:17

回答 1 已采纳 http://blog.csdn.net/sinat_14849739/article/details/65758033?winzoom=1
android 10 app版本降级时提示未安装应用怎么解决？ android java
2021-10-09 16:05

回答 3 已采纳更新版本比安装版本低，有些手机会提示卸载高版本重新安装，有些手机就直接拒绝安装了
android开发应用程序加固，360加固宝软件加固，apk加固
2023-09-06 15:54

在Android应用开发中，安全是至关重要的一个环节。Android应用程序加固是保护代码、数据和用户隐私免受恶意攻击的一种手段。360加固宝是一款知名的Android应用加固工具，它为开发者提供了一整套的安全解决方案，以...
Unity2017空项目打64位apk 无法在android12手机安装 android unity 游戏引擎
2022-11-11 01:18

回答 3 已采纳分析1、应用安装包本身就存在问题导致的【这个需要你根据这个思路去排查下：如果你的app组件，存在intent-filter标签，并且有属性，则设置exported为true <activity
Android如何安装apk文件 android java
2022-06-10 10:33

回答 1 已采纳先试试手动装一下，是否能打开下面是我封装好的，常用方法（包含判断某个应用是否安装、安装应用、打开应用等），拿走不谢 /** * 安装apk * * @par
android studio生成的apk在真机上安装报错 android android-studio
2022-05-26 15:58

回答 4 已采纳手机打开开发者模式，连上电脑可以直接这样看
Apk.1安装器 1.9版本
2020-10-09 17:47

通常，微信在接收到APK文件时，会将其重命名为apk.1或者其他非标准的APK扩展名，以防止直接在聊天界面内安装未知来源的应用，这是一项安全措施，旨在保护用户的设备免受恶意软件的侵害。但这个行为也给正常分享和...
华为android6.0，代码安装apk，不会弹出安装界面 android 华为
2017-03-21 02:52

回答 3 已采纳 Build.VERSION.SDK_INT>=Build.VERSION_CODES.M 应该改为： Build.VERSION.SDK_INT>=Build.VERSION_CODE
Android Studio编译得到的apk拷贝到手机不能安装，而用adb工具能安装 android android-studio
2021-01-10 14:59

回答 8 已采纳是不是debug的apk，这个应该是没法主动安装的，如果打包的release包也不能安装的话就是安装过不能正常覆盖安装，可以先试试adb uninstall com.xx.xx 再安装
AndroidStudio 打包的APK 安装失败 android android-studio gradle
2021-12-03 18:00

回答 2 已采纳怎么个失败法，给个手机截图看看
android 使用虚拟机安装apk(图文教程)
2020-09-05 16:14

9. 测试APK文件的完整性与安全性：在安装任何APK文件之前，应当确保文件是从可靠来源获取，以防潜在的恶意软件危害。此外，测试安装过程中可能出现的错误或异常，确保应用的正常运行。通过本教程，新手用户可以...
安装apk后出现三个应用图标 android android-studio
2019-06-25 08:51

回答 5 已采纳删掉其中两个的 ``` ```
Android实现静默安装实例代码
2020-08-30 08:43

在Android平台上，静默安装指的是在用户无感知的情况下自动安装应用程序。这通常涉及到对系统级权限的使用，因为默认情况下，Android系统会要求用户交互来确认安装请求。静默安装适用于自动化部署、企业级设备管理和...
Android恶意代码——木马APK分析.pdf
2021-09-21 21:52

应用程序使用 Java 语言编写，所有源代码及资源文件包含在一个 APK 文件中，以供安装时使用。应用程序框架层是 Android 平台的第二层，提供了众多供应用程序调用的接口，这些接口多数是由 Android 软件工具包提供...
没有解决我的问题, 去提问

问题事件

关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
创建了问题 11月5日

悬赏问题

¥300 寻抓云闪付tn组成网页付款链接
¥15 请问Ubuntu要怎么安装chrome呀？
¥15 视频编码十六进制问题
¥15 Xsheii7我安装这个文件的时候跳出来另一个文件已锁定文件的无一部分进程无法访问。这个该怎么解决
¥15 unity terrain打包后地形错位，跟建筑不在同一个位置，怎么办
¥15 FileNotFoundError 解决方案
¥15 uniapp实现如下图的图表功能
¥15 u-subsection如何修改相邻两个节点样式
¥30 vs2010开发 WFP（windows filtering platform）
¥15 服务端控制goose报文控制块的发布问题

android 应用内部 下载安装apk 安装时提示： 恶意安装来源

1条回答 默认 最新

问题事件

悬赏问题

android 应用内部下载安装apk 安装时提示：恶意安装来源

1条回答默认最新