jetpack的Navigation注意点

已于 2023-05-07 18:53:03 修改
阅读量84 收藏
点赞数
分类专栏： 码牛jetpack 文章标签： android java 开发语言
于 2023-05-06 22:27:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qczg_wxg/article/details/130536575
版权

1，导航文件的注意点

<?xml version="1.0" encoding="utf-8"?>
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/nav_graph"
    app:startDestination="@id/fmt_a">
    <!-- app:startDestination="@id/fmt_a"：开始时加载的Fragment,必须设置-->
    <!--一个fragment代表一个目标，也就是一个具体的Fragment-->
    <!--id:资源编号，name:资源类型,全类名(包名+类名)，layout:fragment对应需要加载的布局资源,label:标签文本-->
    <fragment
        android:id="@+id/fmt_a"
        android:name="com.example.testnavigation.BlankFragment1"
        android:label="FragmentA"
        android:layout="@layout/fragment_blank1"
        >

    </fragment>
    <fragment
        android:id="@+id/fmt_b"
        android:name="com.example.testnavigation.BlankFragment2"
        android:label="FragmentA"
        tools:layout="@layout/fragment_blank2"></fragment>
    <fragment
        android:id="@+id/fmt_c"
        android:name="com.example.testnavigation.BlankFragment3"
        android:label="FragmentA"
        tools:layout="@layout/fragment_blank3"></fragment>
    <fragment
        android:id="@+id/fmt_d"
        android:name="com.example.testnavigation.BlankFragment4"
        android:label="FragmentA"
        tools:layout="@layout/fragment_blank4"></fragment>
    <!--一个activity代表一个目标，也就是一个具体的Activity-->
        <activity
            android:id="@+id/activity"
            android:name="com.example.testnavigation.MainActivity2"
            ></activity>

    <!--action表示路径，destination表示跳转的目的地，可以写在fragment/activity里面，也可以写在外面 -->
    <!--如果是用在底部导航栏的情况下，多写在外面。如果要使用BottomNavigationView，Menu中的ID，必须与nav_graph中的资源ID保持一致-->
    <action
        android:id="@+id/to2"
        app:destination="@+id/fmt_b"
        app:enterAnim="@anim/nav_default_enter_anim"
        app:exitAnim="@anim/nav_default_exit_anim" />
    <action
        android:id="@+id/toActivity"
        app:destination="@+id/activity"
        app:enterAnim="@anim/nav_default_enter_anim"
        app:exitAnim="@anim/nav_default_exit_anim" />
</navigation>

navigation携带参数跳转

  @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        Button btClicked = view.findViewById(R.id.btClicked);
        btClicked.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Bundle bundle = new Bundle();
                bundle.putString("fromFragment1", "fromFragment1");
                //getView()的注释
//                Get the root view for the fragment's layout (the one returned by onCreateView), if provided.
//                Returns:The fragment's root view, or null if it has no layout.
                //具体跳转的代码，所有的跳转统一都在nav_graph里的<action/>
                Navigation.findNavController(getView()).navigate(R.id.to2,bundle);
            }
        });
    }

参数的接收

  //跳转的目的地如果是Fragment，那就从gerArguments里面找，
  getArguments().getString("fromFragment1")
 //如果跳转的目的地是activity，我们要这样写:getInten().getStringExtra("fromFragment1")
 getIntent().getStringExtra("fromFragment2")

深度链接

在这里插入图片描述

官方导航器缺点

因为官方考虑到实时性，每次切换都会用replace,，而不是show()和hide()每次都会新建Fragment。需要我们自己处理，扩展官方架构
在这里插入图片描述

package com.maniu.mn_vip_navigation.navigator;

import android.content.Context;
import android.os.Bundle;
import android.util.Log;
import android.view.View;

import androidx.annotation.IdRes;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;
import androidx.navigation.NavDestination;
import androidx.navigation.NavOptions;
import androidx.navigation.Navigator;
import androidx.navigation.fragment.FragmentNavigator;

import java.lang.reflect.Field;
import java.util.ArrayDeque;
import java.util.Map;

/**
 * 定制的Fragment导航器，替换ft.replace(mContainerId, frag);为 hide()/show()
 */
//框架内部导航跳转使用导航器。框架提供了四个导航器。框架是根据注解选择导航器，这里也需要增加注解
//虽然增加了注解， 但我们无法在nav_graph里写<fixfragment></fixfragment>标签
//解决方案：第一步：我们自己定义一个JSON文件
@Navigator.Name("fixfragment")
public class FixFragmentNavigator extends FragmentNavigator {
    private static final String TAG = "FixFragmentNavigator";
    private Context mContext;
    private FragmentManager mManager;
    private int mContainerId;

    public FixFragmentNavigator(@NonNull Context context, @NonNull FragmentManager manager, int containerId) {
        super(context, manager, containerId);
        mContext = context;
        mManager = manager;
        mContainerId = containerId;
    }

    @Nullable
    @Override
    public NavDestination navigate(@NonNull Destination destination, @Nullable Bundle args, @Nullable NavOptions navOptions, @Nullable Navigator.Extras navigatorExtras) {
        //直接把源码复制过来加以修改
        if (mManager.isStateSaved()) {
            Log.i(TAG, "Ignoring navigate() call: FragmentManager has already"
                    + " saved its state");
            return null;
        }
        String className = destination.getClassName();
        if (className.charAt(0) == '.') {
            className = mContext.getPackageName() + className;
        }
        //注释掉这句话
        // 不需要每次去navigate的时候都去实例化fragment
        //final Fragment frag = instantiateFragment(mContext, mManager,
        //       className, args);
        //frag.setArguments(args);
        final FragmentTransaction ft = mManager.beginTransaction();

        int enterAnim = navOptions != null ? navOptions.getEnterAnim() : -1;
        int exitAnim = navOptions != null ? navOptions.getExitAnim() : -1;
        int popEnterAnim = navOptions != null ? navOptions.getPopEnterAnim() : -1;
        int popExitAnim = navOptions != null ? navOptions.getPopExitAnim() : -1;
        if (enterAnim != -1 || exitAnim != -1 || popEnterAnim != -1 || popExitAnim != -1) {
            enterAnim = enterAnim != -1 ? enterAnim : 0;
            exitAnim = exitAnim != -1 ? exitAnim : 0;
            popEnterAnim = popEnterAnim != -1 ? popEnterAnim : 0;
            popExitAnim = popExitAnim != -1 ? popExitAnim : 0;
            ft.setCustomAnimations(enterAnim, exitAnim, popEnterAnim, popExitAnim);
        }
        //获取到当前显示的fragment
        Fragment fragment = mManager.getPrimaryNavigationFragment();
        //如果不为空  就隐藏
        if (fragment != null) {
            ft.hide(fragment);
        }
        //去获取目的地的Fragment 即将要显示的Fragment
        Fragment frag = null;
        String tag = String.valueOf(destination.getId());
        //去通过tag从manager中获取fragment
        frag = mManager.findFragmentByTag(tag);
        //如果不为空就显示
        if (frag != null) {
            ft.show(frag);
        } else {
            //如果为空就创建一个fragment的对象,而不是每次都创建一个Fragment
            frag = instantiateFragment(mContext, mManager, className, args);
            frag.setArguments(args);
            ft.add(mContainerId, frag, tag);
        }
        //不再需要replace
        //ft.replace(mContainerId, frag);
        //帮要显示的fragment设置成当前的fragment
        ft.setPrimaryNavigationFragment(frag);

        final @IdRes int destId = destination.getId();
        //通过反射获取mBackStack 然后重新设置参数。因为在源代码中，mBackStack是私有的，只能通过反射获取
        ArrayDeque<Integer> mBackStack = null;
        try {
            Field field = FragmentNavigator.class.getDeclaredField("mBackStack");
            field.setAccessible(true);
            //因为是反射父类的私有成员变量，这里可以直接传参数this
            mBackStack = (ArrayDeque<Integer>) field.get(this);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        final boolean initialNavigation = mBackStack.isEmpty();
        // TODO Build first class singleTop behavior for fragments
        final boolean isSingleTopReplacement = navOptions != null && !initialNavigation
                && navOptions.shouldLaunchSingleTop()
                && mBackStack.peekLast() == destId;

        boolean isAdded;
        if (initialNavigation) {
            isAdded = true;
        } else if (isSingleTopReplacement) {
            // Single Top means we only want one instance on the back stack
            if (mBackStack.size() > 1) {
                // If the Fragment to be replaced is on the FragmentManager's
                // back stack, a simple replace() isn't enough so we
                // remove it from the back stack and put our replacement
                // on the back stack in its place
                mManager.popBackStack(
                        generateBackStackName(mBackStack.size(), mBackStack.peekLast()),
                        FragmentManager.POP_BACK_STACK_INCLUSIVE);
                ft.addToBackStack(generateBackStackName(mBackStack.size(), destId));
            }
            isAdded = false;
        } else {
            ft.addToBackStack(generateBackStackName(mBackStack.size() + 1, destId));
            isAdded = true;
        }
        if (navigatorExtras instanceof Extras) {
            Extras extras = (Extras) navigatorExtras;
            for (Map.Entry<View, String> sharedElement : extras.getSharedElements().entrySet()) {
                ft.addSharedElement(sharedElement.getKey(), sharedElement.getValue());
            }
        }
        ft.setReorderingAllowed(true);
        ft.commit();
        // The commit succeeded, update our view of the world
        if (isAdded) {
            mBackStack.add(destId);
            return destination;
        } else {
            return null;
        }
    }

    private String generateBackStackName(int backStackindex, int destid) {
        return backStackindex + "-" + destid;
    }
}



{
  "afragment": {
    "isFragment": true,
    "asStarter": true,
    "needLogin": false,
    "pageUrl": "afragment",
    "className": "com.maniu.mn_vip_navigation.Fragment.AFragment",
    "id": 40134018,
    "label": "首页"
  },
  "bfragment": {
    "isFragment": true,
    "asStarter": false,
    "needLogin": false,
    "pageUrl": "bfragment",
    "className": "com.maniu.mn_vip_navigation.Fragment.BFragment",
    "id": 1767320445,
    "label": "列表"
  },
  "efragment": {
    "isFragment": true,
    "asStarter": false,
    "needLogin": false,
    "pageUrl": "efragment",
    "className": "com.maniu.mn_vip_navigation.Fragment.EFragment",
    "id": 1400250758,
    "label": ""
  },
  "cfragment": {
    "isFragment": true,
    "asStarter": false,
    "needLogin": false,
    "pageUrl": "cfragment",
    "className": "com.maniu.mn_vip_navigation.Fragment.CFragment",
    "id": 720192388,
    "label": "购物车"
  },
  "dfragment": {
    "isFragment": true,
    "asStarter": false,
    "needLogin": false,
    "pageUrl": "dfragment",
    "className": "com.maniu.mn_vip_navigation.Fragment.DFragment",
    "id": 1087262075,
    "label": "我的"
  }
}

>
pageUrl:对应nav_graph中的的deepLink
id:对应nav_graph中的的id
label:对应nav_graph中的的label
className:对应nav_graph中的的name
是不是太麻烦了这样，还要写json文件，
没关系，我们可以用注解

package com.maniu.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
public @interface ActivityDestination {
    String pageUrl();

    boolean needLogin() default false;

    boolean asStarter() default false;
}


package com.maniu.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
public @interface FragmentDestination {
    String pageUrl();

    boolean needLogin() default false;

    boolean asStarter() default false;

    String label() default "";

}

写个注解处理器，自动生成json(类似于框架的nav_graph.xml)文件

package com.maniu.annotation_compiler;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.auto.service.AutoService;
import com.maniu.annotation.ActivityDestination;
import com.maniu.annotation.FragmentDestination;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.lang.annotation.Annotation;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Filer;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
import javax.tools.FileObject;
import javax.tools.StandardLocation;

/**
 * APP页面导航信息收集注解处理器
 * <p>
 * AutoService注解：就这么一标记，annotationProcessor  project()应用一下,编译时就能自动执行该类了。
 * <p>
 * SupportedSourceVersion注解:声明我们所支持的jdk版本
 * <p>
 * SupportedAnnotationTypes:声明该注解处理器想要处理那些注解
 */
@AutoService(Processor.class)
public class NavProcessor extends AbstractProcessor {
    private Messager messager;
    private Filer filer;
    private static final String OUTPUT_FILE_NAME = "destination.json";

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        //日志打印,在java环境下不能使用android.util.log.e()
        messager = processingEnv.getMessager();
        //文件处理工具
        filer = processingEnv.getFiler();
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> types = new HashSet<>();
        types.add(FragmentDestination.class.getCanonicalName());
        types.add(ActivityDestination.class.getCanonicalName());
        return types;
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return processingEnv.getSourceVersion();
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        //通过处理器环境上下文roundEnv分别获取 项目中标记的FragmentDestination.class 和ActivityDestination.class注解。
        //此目的就是为了收集项目中哪些类 被注解标记了
        Set<? extends Element> fragmentElements = roundEnv.getElementsAnnotatedWith(FragmentDestination.class);
        Set<? extends Element> activityElements = roundEnv.getElementsAnnotatedWith(ActivityDestination.class);

        if (!fragmentElements.isEmpty() || !activityElements.isEmpty()) {
            HashMap<String, JSONObject> destMap = new HashMap<>();
            //分别 处理FragmentDestination  和 ActivityDestination 注解类型
            //并收集到destMap 这个map中。以此就能记录下所有的页面信息了
            handleDestination(fragmentElements, FragmentDestination.class, destMap);
            handleDestination(activityElements, ActivityDestination.class, destMap);

            //app/src/main/assets
            FileOutputStream fos = null;
            OutputStreamWriter writer = null;
            try {
                //filer.createResource()意思是创建源文件
                //我们可以指定为class文件输出的地方，
                //StandardLocation.CLASS_OUTPUT：java文件生成class文件的位置，/app/build/intermediates/javac/debug/classes/目录下
                //StandardLocation.SOURCE_OUTPUT：java文件的位置，一般在/ppjoke/app/build/generated/source/apt/目录下
                //StandardLocation.CLASS_PATH 和 StandardLocation.SOURCE_PATH用的不多，指的了这个参数，就要指定生成文件的pkg包名了
                FileObject resource = filer.createResource(StandardLocation.CLASS_OUTPUT, "", OUTPUT_FILE_NAME);
                String resourcePath = resource.toUri().getPath();
                messager.printMessage(Diagnostic.Kind.NOTE, "resourcePath:" + resourcePath);

                //由于我们想要把json文件生成在app/src/main/assets/目录下,所以这里可以对字符串做一个截取，
                //以此便能准确获取项目在每个电脑上的 /app/src/main/assets/的路径
                String appPath = resourcePath.substring(0, resourcePath.indexOf("app") + 4);
                String assetsPath = appPath + "src/main/assets/";

                File file = new File(assetsPath);
                if (!file.exists()) {
                    file.mkdirs();
                }

                //此处就是稳健的写入了
                File outPutFile = new File(file, OUTPUT_FILE_NAME);
                if (outPutFile.exists()) {
                    outPutFile.delete();
                }
                outPutFile.createNewFile();

                //利用fastjson把收集到的所有的页面信息 转换成JSON格式的。并输出到文件中
                String content = JSON.toJSONString(destMap);
                fos = new FileOutputStream(outPutFile);
                writer = new OutputStreamWriter(fos, "UTF-8");
                writer.write(content);
                writer.flush();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (writer != null) {
                    try {
                        writer.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }


        return true;
    }

    private void handleDestination(Set<? extends Element> elements, Class<? extends Annotation> annotationClaz,
                                   HashMap<String, JSONObject> destMap) {
        for (Element element : elements) {
            //TypeElement是Element的一种。
            //如果我们的注解标记在了类名上。所以可以直接强转一下。使用它得到全类名
            TypeElement typeElement = (TypeElement) element;
            //全类名com.mooc.ppjoke.home
            String clazName = typeElement.getQualifiedName().toString();
            //页面的id.此处不能重复,使用页面的类名做hascode即可,navigation框架内部走的也是Integer
            int id = Math.abs(clazName.hashCode());
            //页面的pageUrl相当于隐士跳转意图中的host://schem/path格式
            String pageUrl = null;
            //是否需要登录
            boolean needLogin = false;
            //是否作为首页的第一个展示的页面
            boolean asStarter = false;
            //标记该页面是fragment 还是activity类型的
            boolean isFragment = false;
            String label = null;
            //提取类的注解，生成json文件
            Annotation annotation = element.getAnnotation(annotationClaz);
            if (annotation instanceof FragmentDestination) {
                FragmentDestination dest = (FragmentDestination) annotation;
                pageUrl = dest.pageUrl();
                asStarter = dest.asStarter();
                needLogin = dest.needLogin();
                isFragment = true;
                label = dest.label();
            } else if (annotation instanceof ActivityDestination) {
                ActivityDestination dest = (ActivityDestination) annotation;
                pageUrl = dest.pageUrl();
                asStarter = dest.asStarter();
                needLogin = dest.needLogin();
                isFragment = false;
            }

            if (destMap.containsKey(pageUrl)) {
                messager.printMessage(Diagnostic.Kind.ERROR, "不同的页面不允许使用相同的pageUrl：" + clazName);
            } else {
                JSONObject object = new JSONObject();
                object.put("id", id);
                object.put("needLogin", needLogin);
                object.put("asStarter", asStarter);
                object.put("pageUrl", pageUrl);
                object.put("className", clazName);
                object.put("isFragment", isFragment);
                object.put("label",label);
                destMap.put(pageUrl, object);
            }
        }
    }
}

在这里插入图片描述
创建三个解释器
算了不写了，直接上传源码吧

qczg_wxg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Jetpack Navigation 使用技巧
sunrain62的专栏
05-14 132
记录使用 Jetpack Navigation 的小技巧和注意事项
JetPack之Navigation
nihai_baba的博客
09-28 859
Navigation的诞生 Activity嵌套多个fragment的ui架构模式已经非常普遍，但是对Fragment的管理一直是一件比较麻烦的事情，我们需要通过fragmentManager和fragmentTransaction来管理fragment之间的切换，页面的切换通常还包括对应用程序App bar的管理、Fragment间的切换动画，以及fragment间的参数传递。纯代码的方式使用起来不是特别的友好，并且fragment和app bar在管理和使用过程中显得混乱。 为此，jetpack提供了
Jetpack Navigation
txaz6的博客
07-07 1260
从最原始的Intent跳转，然后到比较好用的Arouter管理activity跳转，再到现在的navigation，官方都把饭做好了，你还不来吃，快来和我一起学习这个真香的框架吧！
Android Jetpack Navigation 的使用
weixin_44021334的博客
11-28 343
Navigation 是 Android Jetpack 的导航组件，相关说明详见官网链接 https://developer.android.google.cn/guide/navigation/navigation-getting-started Android Studio 3.3 或者更高版本才可以使用 开始使用 1.添加依赖 dependencies { def nav_versio...
Jetpack之Navigation使用及源码解读
热门推荐
小孟来码的博客
08-04 1万+
首先Navigation是一个架构组件，因为切换Activity是一个Binder通信的过程，所以Activity是属于比较重的组件。而Fragment的切换其实只是View的切换，比较轻量级。因此单Activity加Fragment切换成为了比较常见的架构方式。为什么要用Navigation：1、使得Fragment的管理简单，可读性高。2、传递数据方式简单。3、标准的栈管理。4、支持Deeplink、URL Link定位到Fragment。5、处理动画更加方便。下面也主要围绕这几点进行讲解。......
jetpack navigation
zhizhuodewo6的博客
02-18 303
一、Navigation 主要是用来处理 Fragment 的跳转，所以说它并不是用来代替 startActivity，而是用来代替 FragmentTransaction 的相关操作。 二、参考文章 https://www.jianshu.com/p/4c1a2d35d8b8 ...
Android jetpack navigation
Lance_W
12-24 1352
Navigation 版本导入： ext.nav_version = "2.3.5" implementation("androidx.navigation:navigation-fragment-ktx:$nav_version") implementation("androidx.navigation:navigation-ui-ktx:$nav_version") NavHost navigation的宿主载体，即需要一个空的布局来承载fragment的切换。 navigation的宿主需要实现Na
Android Jetpack | Navigation
codeSong的博客
06-22 698
参考文章当在应用中导航到不同目的地的时候，可能会需要传递数据。为了避免使用全局对象引用，通过数据传递可以实现更好的代码封装结构，这样不同的 fragment 或者 activity 仅需要分享它们所需的数据即可。Bundles机制：为要传递的数据创建一个 Bundle，然后在接收侧将数据提取出来。导航组件传递数据，Android 中跨 activity 传递数据。不过导航组件有更好的方法:SafeArgsSafeArgs gradle 插件，在不同的目的地 (界面)之间提供更加便捷的数据传递功能。
Android Jetpack 之 Navigation
接受自己的普通，然后拼尽全力去与众不同
10-25 504
1. Navigation 的定义 Navigation 是指支持用户导航、进入和退出应用中不同内容片段的交互。Android Jetpack 的导航组件可帮助实现导航，无论是简单的按钮点击，还是应用栏和抽屉式导航栏等更为复杂的模式，该组件均可应对。导航组件还通过遵循一套既定原则来确保一致且可预测的用户体验。 导航组件由以下三个关键部分组成： 导航图：在一个集中位置包含所有导航相关信息的 X...
【Android】广播机制
最新发布
2301_79977698的博客
07-24 506
在Android中，广播（Broadcast）是一种消息，任何应用程序都可以发送广播消息，任何应用程序也都可以接收广播消息。广播通常用于通知应用程序某些事件的发生，比如系统启动、电量低、网络状态改变等。Broadcast Receiver（广播接收器）：用于接收广播消息并响应这些消息的组件。Intent（意图）：用于传递广播消息的数据结构。标准广播（Normal Broadcast）是完全异步的，所有接收器几乎同时接收广播，并且接收顺序是不确定的。
Android DataBinding从入门到精通
Dream的博客
07-22 1072
DataBinding可以更加方便的编写与视图交互的代码。即系统会为模块中的每个xml文件生成一个绑定类，其实例包含指向相应布局中具有ID的所有视图的直接引用。大多数情况下，DataBinding会代替findMyId。
【23】Android高级知识之Window(四) - ThreadedRenderer
mr_zengkun的博客
07-21 1066
ThreadedRenderer、WMS
Android 多用户问题
m0_54010212的博客
07-22 312
在工程模式下，可以使用 getInstalledPackages 或 getInstalledPackagesAsUser 方法获取全部已安装的应用程序，并展示给用户。List<MediaController> 在普通应用中可以获取到，但是在systemUI中获取不到。这个api解决 那为什么systemUI在 0这个组别？在systemserver 里启动的组别就是这个。音频mediassion相关是区分用户的。看了一下是 user组别问题导致的。那么还有没有什么是区别用户的。当然有 PMS也是这样。
DASCTF-BabyAndroid
Nike_name的博客
07-24 158
jpg隐藏解密函数,native层余弦变换什么什么的
Android 源码分析：ViewGroup
liufeismart2024的博客
07-23 288
如果要自定义ViewGroup，对添加到其中的View对应LayoutParams有特殊要求(如需要是MarginLayoutParams)，可重写ViewGroup.generateDefaultLayoutParams()和ViewGroup.generateLayoutParams()如果调用的是ViewGroup.addView(View)，会调用ViewGroup.generateDefaultLayoutParams()创建需要的LayoutParamas对象。
Android SurfaceFlinger——关联EGL三要素（二十七）
小旭的专栏
07-22 1821
经过前面的几篇文章我们呢了解了系统启动动画的播放流程，这里我们对 OpenGL ES 初始化流程总结如下：eglGetDisplay：加载 OpenGL ES 的 so 库，获取一个屏幕句柄对象。此时的 EGLDisplay 其实就是 egl_display_t，并且保存在数组中。eglInitialize：设置了EGLDisplay 的状态，同时初始化着色器缓存。eglChooseConfig：获取当前 OpenGL es 提供的参数中最佳参数。
android audio 相机按键音：(一)资源加载与替换
五味香的专栏
07-21 449
可以使用自定义资源文件，替换按键音资源。替换时，将自定义文件名称修改与系统文件名一致，但是文件格式必须一致。
Android SurfaceFlinger——GraphicBuffer初始化（二十九）
小旭的专栏
07-23 941
GraphicBuffer 对象封装了一块内存，这块内存可以用于存储像素数据，例如图像帧或者视频帧。它提供了跨进程传输的能力，使得不同进程之间可以共享同一块图形数据。简单来说，GraphicBuffer 是实现图形内容在硬件和软件层面上存储和传递的具体实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值