Android11.0自定义服务中添加设置第三方应用为默认Launcher接口供第三方开发使用

已于 2023-12-12 10:51:28 修改
阅读量947 收藏 8
点赞数 8
分类专栏： Android11.0 文章标签： android
于 2023-12-11 11:38:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjz_0314/article/details/134919103
版权

Android11.0自定义服务中添加设置第三方应用为默认Launcher接口供第三方开发使用

Android11.0自定义服务中添加设置第三方应用为默认Launcher接口供第三方开发使用

本文描述Android11自定义服务中添加设置第三方app为系统默认Launcher接口，提供第三方应用开发使用，如何添加自定义服务：Android11.0Frameworks中添加一个自定义系统服务，并提供jar包供应用开发调用。

  1. ITestManager及TestManager中添加方法定义，修改文件路径：
    /frameworks/base/core/com/yjz/test/api/ITestManager.aidl
     boolean hasDefaultLauncher();

     int setDefaultLauncher(String packageName);

     void clearDefaultLauncher();

/frameworks/base/core/com/yjz/test/TestManager.java

    public boolean hasDefaultLauncher() {
        try {
            return mService.hasDefaultLauncher();
        } catch (RemoteException e) {
            e.printStackTrace();
        }
        return false;
    }

    public int setDefaultLauncher(String packageName) {
        try {
            return mService.setDefaultLauncher(packageName);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
        return 1;
    }

    public void clearDefaultLauncher() {
        try {
            mService.clearDefaultLauncher();
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
  1. TestManagerService中添加方法，修改路径：
    /frameworks/base/services/core/java/com/android/server/yjz/TestManagerService.java；
    //*******省略代码******
    @Override
    public boolean hasDefaultLauncher() throws RemoteException {
        return LauncherHelper.getInstance().hasDefaultLauncher();
    }

    @Override
    public int setDefaultLauncher(String s) throws RemoteException {
        int result = LauncherHelper.getInstance().checkCanSetDefaultLauncher(mContext, s);
        if (result != LauncherHelper.LAUNCHER_SUCCESS) {
            return result;
        }

        final LauncherData data = new LauncherData(new CompletableFuture<>(), s);
        Message msg = Message.obtain();
        msg.what = MSG_WHAT_SET_LAUNCHER;
        msg.obj = data;
        mHandler.sendMessage(msg);

        try {
            boolean success = data.getFuture().get();
            Log.d(TAG, "set def launcher result " + success);
            return success ? LauncherHelper.LAUNCHER_SUCCESS : LauncherHelper.LAUNCHER_FAIL;
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return LauncherHelper.LAUNCHER_FAIL;
    }

    @Override
    public void clearDefaultLauncher() throws RemoteException {
        mHandler.sendEmptyMessage(MSG_WHAT_CLEAR_LAUNCHER);
    }

    private static final int MSG_WHAT_SET_LAUNCHER = 7;
    private static final int MSG_WHAT_CLEAR_LAUNCHER = 8;

    @SuppressLint("HandlerLeak")
    private Handler mHandler = new Handler() {
        @Override
        public void dispatchMessage(@NonNull Message msg) {
            switch (msg.what) {
                case MSG_WHAT_SET_LAUNCHER:
                    final LauncherData data = (LauncherData) msg.obj;
                    LauncherHelper.getInstance().setDefaultLauncher(mContext, data.getPackageName(), isOk -> {
                        if (isOk) {
                            clearOldLauncherTask(mContext, data.getPackageName());
                        }
                        data.getFuture().complete(isOk);
                    });
                    break;
                case MSG_WHAT_CLEAR_LAUNCHER:
                    LauncherHelper.getInstance().clearDefaultLauncher(mContext);
                    break;
            }
        }
    };

    private void clearOldLauncherTask(Context context, String packageName) {
        ActivityManager manager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningTaskInfo> list = manager.getRunningTasks(Integer.MAX_VALUE);
        if (null != list) {
            for (ActivityManager.RunningTaskInfo item : list) {
                if (item.configuration.windowConfiguration.getActivityType() == WindowConfiguration.ACTIVITY_TYPE_HOME) {
                    if (!item.realActivity.getPackageName().equals(packageName)) {
                        Log.d(TAG, "clearOldLauncherTask " + item.realActivity.getPackageName());
                        final int tId = item.taskId;
                        try {
                            ActivityTaskManager.getService().removeTask(tId);
                        } catch (RemoteException e) {
                            Log.w(TAG, "Failed to remove task=" + tId, e);
                        }
                    }
                }
            }
        }
    }

    private class LauncherData {
        private CompletableFuture<Boolean> future;
        private String packageName;

        public LauncherData(@NonNull CompletableFuture<Boolean> future, @NonNull String packageName) {
            this.future = future;
            this.packageName = packageName;
        }

        public CompletableFuture<Boolean> getFuture() {
            return future;
        }

        public String getPackageName() {
            return packageName;
        }
    }

/frameworks/base/core/com/yjz/test/core/LauncherHelper.java

package com.yjz.test.core;

import android.app.role.RoleManager;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.os.SystemProperties;
import android.os.UserHandle;
import android.util.Log;
import android.util.Singleton;

import com.yjz.test.utils.Tools;

import java.util.List;
import java.util.concurrent.Executor;
import java.util.function.Consumer;

public class LauncherHelper {
    private static final String TAG = "LauncherHelper";

    public static final int LAUNCHER_SUCCESS = 0;
    public static final int LAUNCHER_FAIL = 1;
    public static final int SET_LAUNCHER_ERROR_NOT_FOUND = 2;
    public static final int SET_LAUNCHER_ERROR_NOT_HOME = 3;

    private final String defLauncherKey = "persist.sys.def_launcher";
    private final String defLauncherEnableKey = "persist.sys.def_launcher_enable";
    private final byte[] mLock = new byte[0];

    private LauncherHelper() {
    }

    private static final Singleton<LauncherHelper> mSingletonLauncherHelper = new Singleton<LauncherHelper>() {
        @Override
        protected LauncherHelper create() {
            return new LauncherHelper();
        }
    };

    public static LauncherHelper getInstance() {
        return mSingletonLauncherHelper.get();
    }

    public boolean hasDefaultLauncher() {
        synchronized (mLock) {
            String launcherPackageName = SystemProperties.get(defLauncherKey);
            return null != launcherPackageName && !"".equals(launcherPackageName);
        }
    }

    public int checkCanSetDefaultLauncher(Context context, String packageName) {
        //检查应用是否已安装
        if (null == Tools.getApplicationInfo(context, packageName)) {
            return SET_LAUNCHER_ERROR_NOT_FOUND;
        }

        //检查应用是否是home
        if (!isHomeApp(context, packageName)) {
            return SET_LAUNCHER_ERROR_NOT_HOME;
        }

        return LAUNCHER_SUCCESS;
    }


    public void setDefaultLauncher(Context context, String packageName, SetHomeRoleCallback listener) {
        setHomePreferredActivity(context, packageName, true, isOk -> {
            if (isOk) {
                synchronized (mLock) {
                    SystemProperties.set(defLauncherKey, packageName);
                    SystemProperties.set(defLauncherEnableKey, "true");
                }

                //检查应用是否为前台应用
                if (!Tools.isPackageInForeground(context, packageName)) {
                    Log.d(TAG, "need startup launcher app " + packageName);
                    Intent intent = new Intent(Intent.ACTION_MAIN)
                            .addCategory(Intent.CATEGORY_HOME)
                            .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                    context.startActivityAsUser(intent, UserHandle.SYSTEM);
                }
            }
            if (null != listener) {
                listener.onResult(isOk);
            }
        });
    }

    public void clearDefaultLauncher(Context context) {
        synchronized (mLock) {
            String launcherPackageName = SystemProperties.get(defLauncherKey);
            if (null != launcherPackageName && !"".equals(launcherPackageName)) {
                PackageManager pm = context.getPackageManager();
                pm.clearPackagePreferredActivities(launcherPackageName);

                setHomePreferredActivity(context, launcherPackageName, false, null);
            }
            SystemProperties.set(defLauncherKey, "");
            SystemProperties.set(defLauncherEnableKey, "false");
        }
    }

    private boolean isHomeApp(Context context, String packageName) {
        PackageManager pm = context.getPackageManager();

        Intent queryIntent = new Intent();
        queryIntent.addCategory(Intent.CATEGORY_HOME);
        queryIntent.setAction(Intent.ACTION_MAIN);
        List<ResolveInfo> homeActivities = pm.queryIntentActivities(queryIntent, 0);
        if (homeActivities == null) {
            return false;
        }

        for (ResolveInfo info : homeActivities) {
            if (info.activityInfo.packageName.equals(packageName)) {
                return true;
            }
        }
        return false;
    }

    private void setHomePreferredActivity(Context context, String packageName, boolean add, SetHomeRoleCallback listener) {
        RoleManager roleManager = (RoleManager) context.getSystemService(RoleManager.class);
        Executor executor = context.getMainExecutor();
        Consumer<Boolean> callback = successful -> {
            if (successful) {
                Log.i(TAG, "Package " + (add ? "added" : "removed")
                        + " as role holder, role: " + RoleManager.ROLE_HOME + ", package: " + packageName);
            } else {
                Log.i(TAG, "Failed to " + (add ? "add" : "remove")
                        + " package as role holder, role: " + RoleManager.ROLE_HOME + ", package: "
                        + packageName);
            }

            if (null != listener) {
                listener.onResult(successful);
            }
        };
        if (add) {
            roleManager.addRoleHolderAsUser(RoleManager.ROLE_HOME, packageName, 0, UserHandle.SYSTEM, executor, callback);
        } else {
            roleManager.removeRoleHolderAsUser(RoleManager.ROLE_HOME, packageName, 0, UserHandle.SYSTEM, executor,
                    callback);
        }
    }

    public interface SetHomeRoleCallback {
        void onResult(boolean isOk);
    }

}

/frameworks/base/core/com/yjz/test/utils/Tools.java

public final class Tools {
    private static final String TAG = "Tools";

    public static ApplicationInfo getApplicationInfo(Context context, String packageName) {
        ApplicationInfo info = null;
        try {
            info = context.getPackageManager().getApplicationInfo(packageName, PackageManager.GET_UNINSTALLED_PACKAGES);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
            return null;
        }
        return info;
    }

    public static boolean isPackageInForeground(Context context, String packageName){
        int uid;
        try {
            uid = context.getPackageManager().getPackageUid(packageName, 0);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
            return false;
        }

        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        return am.getUidImportance(uid) == IMPORTANCE_FOREGROUND;
    }
}
  1. 提供第三方开发的jar包中添加方法，修改路径 /vendor/yjz/com/yjz/sdk/SDKManager.java；
    public boolean hasDefaultLauncher() {
        return mTestManager.hasDefaultLauncher();
    }

    public int setDefaultLauncher(String packageName) {
        return mTestManager.setDefaultLauncher(packageName);
    }

    public void clearDefaultLauncher() {
        mTestManager.clearDefaultLauncher();
    }
  1. 编译刷机验证，RoleManager设置的数据中保存在/data/misc_de/0/apexdata/com.android.permission/roles.xml中：
    在这里插入图片描述
yjz_0314
关注
专栏目录
Android 11.0 mtk 设置默认launcher app
u011990002的专栏
07-09 2837
当手机上有多个launcher，那么第一次使用的时候会提示选择哪个launcher。 frameworks/base/core/java/com/android/internal/app/ResolverActivity.java 选择的界面是ResolverActivity，里面的addPreferredActivity就是设置默认app的。 修改方法如下： [Launcher]add ro.kte.laucher.package ro.kte.laucher.activity diff -.
在Android中添加自定义服务并生成jar供第三方应用调用
2301_79330513的博客
08-12 214
接下来，我们需要创建一个新的Android库模块，以便将我们的服务打包成jar文件。希望本文对您有所帮助！为了实现这一目标，我们可以创建一个自定义服务，并将其封装在一个jar文件中，使其可以被第三方应用调用。然后，我们定义了一个名为"jar"的任务，该任务将源代码目录（除去不必要的文件）作为输入，并创建一个jar文件作为输出。在下面的示例中，我将演示如何在Android中创建一个自定义服务，并将其打包成jar文件。至此，我们已经创建了一个自定义服务并生成了一个jar文件，可以供第三方应用程序使用。
Android11.0内置第三方Launcher并设置为默认，保留Launcher3并可切换
yjz_0314的博客
11-30 4155
本文描述Android11中内置第三方应用为Launcher并保住自带的Launcher3，刷机后系统启动时选择内置第三方应用显示并设置为默认Launcher。
android 当系统存在多个Launcher时，如何设置开机自动进入默认的Launcher？
thinkinwm的专栏
04-05 1973
来自MTK  FAQ 当系统存在多个Launcher时，开机完成并解锁后，系统会弹出一个选择框让用户选择进入哪一个Launcher，如果不想选择，而是想直接进入某一个默认的Launcher，并且用户在设置->应用程序->管理应用程序->所有应用程序列表，找到之前设置的那个默认的Launcher，并且取消了默认值，可以重新弹出launcher选框。 下面以设置Google Lau
【Android】设置三方应用为默认Launcher
最新发布
cycy1821的博客
02-19 1001
问题：替换原生Launcher，换成指定包名设置的应用为默认Launcher。
展讯 android 11 多个Launcher设置默认Launcher
m0_60898338的博客
09-17 414
A11多个Launcher如何设置默认Launcher
Android11 设置默认launcher app
Aaron121314的博客
06-29 4571
如果手机上有多个launcher，那么第一次使用的时候会提示选择哪个launcher。 frameworks/base/core/java/com/android/internal/app/ResolverActivity.java 选择的界面是ResolverActivity，里面的addPreferredActivity就是设置默认app的。 @Override protected void onCreate(Bundle savedInstanceState) {
Android 11.0 设置默认Launcher的方法
wed110的专栏
05-24 7121
不好的方法，修改frameworks/base/core/java/com/android/internal/app/ResolverActivity.java ，修改这个地方，有个问题，会弹窗然后在消失，用户体验不好。 好的方法，修改Provision，然后在用roleManager.addRoleHolderAsUser(roleName, packageName, flags, user, executor, callback);的方法去处理默认值 不好的方法 diff --git a/.
Android 11.0 设置默认Launcher安装一款Launcher默认Launcher无效的解决方案
安卓兼职framework和app工程师的博客
01-03 1572
在11.0的系统产品开发中，对于设置默认Launcher的功能，也是常见的，但是在设置默认Launcher以后，工作开发测试中，发现安装另外安装一款 Launcher以后，发现设置的默认Launcher无效，在系统设置的默认Launcher应用中为未选择的状态，所以需要从安装Launcher的相关方法 中分析，看做了哪些操作，然后修复这个功能
Android 12.0 rom定制专栏系列解读
安卓兼职framework和app工程师的博客
12-11 3523
在从事android系统rom定制化的这几年里，经历了坎坎坷坷，开发过好几种类型的产品，也随着google对android系统的更新加快，也需要跟随上时代的进步，所以需要把平时工作中遇到的问题总结出来，及时做好记录归纳总结，然后进一步的提升自己能力，本专栏提供给在12.0的rom定制过程中需要寻求帮助的伙伴们给个指引，如有不到之处可以提出来探论，共同进步
( 持续更新，目前含 200+ 工具类 ) DevUtils 是一个 Android 工具库, 主要根据不同功能模块，封装快捷使用的工具类及 API 方法调用。
afkT 的博客
09-24 5098
About DevUtils 是一个 Android 工具库, 主要根据不同功能模块，封装快捷使用的工具类及 API 方法调用。 该项目尽可能的便于开发人员，快捷、快速开发安全可靠的项目，以及内置部分常用的资源文件，如color.xml、(toast) layout.xml等 Gradle Step 1. Add the JitPack repository to your build fil...
(1)Android之路====APK基础入门1(UI控件使用)
qq_23922117的博客
05-28 561
本来是要写雇主公司自研SoC的Android驱动的,前几天开了个员工,其中一条"罪名"特别强调拷贝操作系统芯片代码到个人存储器,也就是Linux驱动,看来GPL协议保护有时候保护不了我们(就算能用GPL协议维权,也只是得一笔赔偿金,仍然开除),所以,目前不考虑写雇主公司的驱动教程了.我之前完全由我自行实现,且非工作任务,并声明GPL协议的代码,也被领导要求在博客下架,怕被公司法务追责,没办法,我还...
Android 11.0 Launcher3 去掉长按屏幕微件里面的设置和日历等微件
安卓兼职framework和app工程师的博客
11-28 1215
在11.0的系统rom产品开发中，在开发Launcher3的微件功能时长按屏幕时，这时候可以进入微件.进入微件以后发现 设置 日历 图库等都有微件图标,这样可以拖动到workspace 作为微件图标使用 点击进入app，由于开发项目的需要，要求去掉这些微件，不让通过进入微件进入app，这就需要分析微件是怎么产生的，然后去掉微件，接下来就来看 怎么样来实现这个功能
Android 设置默认Launcher
金佳杰
05-01 2638
如果想定制Android系统，想让我们自己的Launcher
链接——Android，自定义Launcher(桌面)
不止于代码
10-11 636
Android 桌面Widget (小组件)开发详解
Android多个Launcher启动时设置默认Launcher
PixelLancer的博客
08-30 891
要设置默认的Launcher，我们将使用Android的Launcher Intent。Launcher Intent是一种用于启动应用程序的Intent，它指定了要启动的应用程序的包名和类名。通过发送一个Launcher Intent，我们可以将用户重定向到特定的Launcher应用程序，并要求其成为默认的Launcher。这将打开设备的主屏幕设置界面，并将要设置为默认Launcher的应用程序的包名传递给该界面。方法将Intent的组件设置为要设置为默认Launcher的应用程序的组件。
Android 自己做的Launcher
03-28
NULL 博文链接：https://iaiai.iteye.com/blog/1209347
Android 9.0添加自定义服务，并生成jar给第三方app调用
安卓兼职framework和app工程师的博客
02-22 763
在9.0的系统产品rom定制化开发中，在产品定制化过程中，需求也是特别多的，所以在开发一些定制化需求时，需要增加自定义的服务接口，提供给第三方app调用，这就 需要在frameworks下新增api服务，然后在服务中添加接口，用命令生成jar包，接下来看下如何实现这些功能的开发，
Android11 Launcher3
06-27
Android11 Launcher3
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值