devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

android NavigationView解析_android navigationview

作者：weixin_40725706 | 2024-03-11 13:04:32

赞

踩

android navigationview

NavigationView实际上是一个FrameLayout，这个FrameLayout中又包含了一个RecyclerView。如果用户设置了Header布局，那么NavigationView就把这个Header作为这个RecyclerView的第一个Item View，在Header的下面就是菜单列表。通过这种封装使得构建用户菜单变得非常简单，而不需要用户每次都通过RecyclerView手动设置header和菜单，提高了工程师的开发效率。

NavigationView就是一个MVP设计模式，Toolbar的菜单解析也遵循MVP设计模式。由于Toolbar的MVP比较复杂，我们就通过剖析NavigationView的案例来学习MVP的运用。

NavigationView的构造方法：

 

NavigationMenuPresenter的getMenuView方法：

 

NavigationMenuPresenter加载菜单方法：inflateMenu

 

NavigationMenuPresenter加载head view的方法：addHeaderView

 

 

 

 

NavigationView中MVP的使用：

 

NavigationView的OnNavigationItemSelectedListener的作用：

其实NavigatioNmenuPresenter持有NavigationMenu,NavigationMenu选中会通知触发OnNavigationItemSelectedListener的onNavigationItemSelected方法，其实也类似于NavigatioNmenuPresenter在通知OnNavigationItemSelectedListener执行onNavigationItemSelected方法。

 

NavigationView中的Model层NavigationItem

 

 

 

 

 

在使用NavigationView的时候，app:menu设置菜单项；app:headerLayout设置菜单Header。

 

NavigationView实际上是一个FrameLayout，确切的说它继承自FrameLayout。

 

  1. public class ScrimInsetsFrameLayout extends FrameLayout {
  2.  
  3. }
  4.  
  5. public class NavigationView extends ScrimInsetsFrameLayout {
  6.  
  7. //菜单Presenter
  8. private final NavigationMenu mMenu;
  9. private final NavigationMenuPresenter mPresenter = new NavigationMenuPresenter();
  10.  
  11. OnNavigationItemSelectedListener mListener;
  12. private int mMaxWidth;
  13. //菜单解析的Inflater
  14. private MenuInflater mMenuInflater;
  15. }

 

  1.   public NavigationView(Context context, AttributeSet attrs, int defStyleAttr) {
  2.         super(context, attrs, defStyleAttr);
  3.  
  4.         ThemeUtils.checkAppCompatTheme(context);
  5.  
  6.         // Create the menu
  7.         mMenu = new NavigationMenu(context);
  8. //其他初始化操作
  9.         // Custom attributes
  10.         TintTypedArray a = TintTypedArray.obtainStyledAttributes(context, attrs,
  11.                 R.styleable.NavigationView, defStyleAttr,
  12.                 R.style.Widget_Design_NavigationView);
  13.  
  14.         ViewCompat.setBackground(
  15.                 this, a.getDrawable(R.styleable.NavigationView_android_background));
  16.         if (a.hasValue(R.styleable.NavigationView_elevation)) {
  17.             ViewCompat.setElevation(this, a.getDimensionPixelSize(
  18.                     R.styleable.NavigationView_elevation, 0));
  19.         }
  20.         ViewCompat.setFitsSystemWindows(this,
  21.                 a.getBoolean(R.styleable.NavigationView_android_fitsSystemWindows, false));
  22.  
  23.         mMaxWidth = a.getDimensionPixelSize(R.styleable.NavigationView_android_maxWidth, 0);
  24.  
  25.         final ColorStateList itemIconTint;
  26.         if (a.hasValue(R.styleable.NavigationView_itemIconTint)) {
  27.             itemIconTint = a.getColorStateList(R.styleable.NavigationView_itemIconTint);
  28.         } else {
  29.             itemIconTint = createDefaultColorStateList(android.R.attr.textColorSecondary);
  30.         }
  31.  
  32.         boolean textAppearanceSet = false;
  33.         int textAppearance = 0;
  34.         if (a.hasValue(R.styleable.NavigationView_itemTextAppearance)) {
  35.             textAppearance = a.getResourceId(R.styleable.NavigationView_itemTextAppearance, 0);
  36.             textAppearanceSet = true;
  37.         }
  38.  
  39.         ColorStateList itemTextColor = null;
  40.         if (a.hasValue(R.styleable.NavigationView_itemTextColor)) {
  41.             itemTextColor = a.getColorStateList(R.styleable.NavigationView_itemTextColor);
  42.         }
  43.  
  44.         if (!textAppearanceSet && itemTextColor == null) {
  45.             // If there isn't a text appearance set, we'll use a default text color
  46.             itemTextColor = createDefaultColorStateList(android.R.attr.textColorPrimary);
  47.         }
  48.  
  49.         final Drawable itemBackground = a.getDrawable(R.styleable.NavigationView_itemBackground);
  50.  
  51.         mMenu.setCallback(new MenuBuilder.Callback() {
  52.             @Override
  53.             public boolean onMenuItemSelected(MenuBuilder menu, MenuItem item) {
  54.                 return mListener != null && mListener.onNavigationItemSelected(item);
  55.             }
  56.  
  57.             @Override
  58.             public void onMenuModeChange(MenuBuilder menu) {}
  59.         });
  60.         mPresenter.setId(PRESENTER_NAVIGATION_VIEW_ID);
  61.        //1.初始化一些资源
  62.         mPresenter.initForMenu(context, mMenu);
  63.         mPresenter.setItemIconTintList(itemIconTint);
  64.         if (textAppearanceSet) {
  65.             mPresenter.setItemTextAppearance(textAppearance);
  66.         }
  67.         mPresenter.setItemTextColor(itemTextColor);
  68.         mPresenter.setItemBackground(itemBackground);
  69.         mMenu.addMenuPresenter(mPresenter);
  70. //2.构建整个菜单视图并且添加到当前视图中
  71.         addView((View) mPresenter.getMenuView(this));
  72.  
  73. //3.初始化菜单资源menu目录
  74.         if (a.hasValue(R.styleable.NavigationView_menu)) {
  75.             inflateMenu(a.getResourceId(R.styleable.NavigationView_menu, 0));
  76.         }
  77.  
  78. //4.初始化header layout
  79.         if (a.hasValue(R.styleable.NavigationView_headerLayout)) {
  80.             inflateHeaderView(a.getResourceId(R.styleable.NavigationView_headerLayout, 0));
  81.         }
  82.  
  83.         a.recycle();
  84.     }
  1. #NavigationView
  2.     /**
  3.      * Inflate a menu resource into this navigation view.
  4.      *(将菜单资源扩展到此导航视图中。)
  5.      * <p>Existing items in the menu will not be modified or removed.</p>
  6.      *(菜单中的现有项目不会被修改或删除。)
  7.      * @param resId ID of a menu resource to inflate
  8.      */
  9.     public void inflateMenu(int resId) {
  10.         mPresenter.setUpdateSuspended(true);
  11.         getMenuInflater().inflate(resId, mMenu);
  12.         mPresenter.setUpdateSuspended(false);
  13.         mPresenter.updateMenuView(false);
  14.     }
  15.  
  16. #NavigationView
  17.     /**
  18.      * Inflates a View and add it as a header of the navigation menu.
  19.      *(加载视图并将其添加为导航菜单的标题。)
  20.      * @param res The layout resource ID.
  21.      * @return a newly inflated View.
  22.      */
  23.     public View inflateHeaderView(@LayoutRes int res) {
  24.         return mPresenter.inflateHeaderView(res);
  25.     }

 

 

在NavigationView中我们可以看到熟悉的Presenter字眼，即NavigationMenuPresenter。

在NavigattionView的构造函数有几个比较重要的步骤：

1.初始化资源；

2.构建菜单和Header视图根布局；

3.解析、显示菜单项；

4.解析和显示Header视图。

 

在这四个步骤中，我们可以看到这四步基本上都是通过Presenter实现的，Presenter承担了几乎所有的业务逻辑。

 

  1. public class NavigationMenuPresenter implements MenuPresenter {
  2.  
  3. //菜单视图，也就是一个RecyclerView
  4.  private NavigationMenuView mMenuView;
  5.  
  6. //菜单的Header布局
  7.     LinearLayout mHeaderLayout;
  8.  
  9.     private Callback mCallback;
  10.     MenuBuilder mMenu;
  11.     private int mId;
  12.  
  13.     NavigationMenuAdapter mAdapter;
  14.     LayoutInflater mLayoutInflater;
  15.  
  16. }

 

  1.    /**
  2.      * Padding for separators between items
  3.      */
  4.     int mPaddingSeparator;
  5.  
  6. //1.初始化mLayoutInflater和MenuBuilder
  7.     @Override
  8.     public void initForMenu(Context context, MenuBuilder menu) {
  9.         mLayoutInflater = LayoutInflater.from(context);
  10.         mMenu = menu;
  11.         Resources res = context.getResources();
  12.         mPaddingSeparator = res.getDimensionPixelOffset(
  13.                 R.dimen.design_navigation_separator_vertical_padding);
  14.     }

 

 

  1. 2.构建菜单和Header视图
  2.     @Override
  3.     public MenuView getMenuView(ViewGroup root) {
  4.         if (mMenuView == null) {
  5.            //加载菜单NavigationView
  6.             mMenuView = (NavigationMenuView) mLayoutInflater.inflate(
  7.                     R.layout.design_navigation_menu, root, false);
  8.             if (mAdapter == null) {
  9.                 mAdapter = new NavigationMenuAdapter();
  10.             }
  11. //加载菜单的Header
  12.             mHeaderLayout = (LinearLayout) mLayoutInflater
  13.                     .inflate(R.layout.design_navigation_item_header,
  14.                             mMenuView, false);
  15.             mMenuView.setAdapter(mAdapter);
  16.         }
  17.         return mMenuView;
  18.     }

 

 

  1. //3.更新菜单项
  2. @Override
  3.     public void updateMenuView(boolean cleared) {
  4.         if (mAdapter != null) {
  5.             mAdapter.update();
  6.         }
  7.     }
  1. //4.加载Header布局
  2.  public View inflateHeaderView(@LayoutRes int res) {
  3.         View view = mLayoutInflater.inflate(res, mHeaderLayout, false);
  4.         addHeaderView(view);
  5.         return view;
  6.     }

 

 

  1.  public void addHeaderView(@NonNull View view) {
  2.         mHeaderLayout.addView(view);
  3.         // The padding on top should be cleared.
  4.         mMenuView.setPadding(0, 0, 0, mMenuView.getPaddingBottom());
  5.     }

 

NvaigationView构造函数的第一个重要的函数是Presnter的initForMenu，在这个函数中只是进行简单的初始化操作，将mMenu对象指向构造函数传递进来的MenuBuilder，并且初始化了一些padding值。

 

第二个重要的函数是NavigationMenuPresenter的getMenuView函数，该函数中构造了菜单NavigationMenuView、菜单项Adapter、和Header视图。在前文中，我们提到过，NavigationMenuView本质上是一个RecyclerView，它是以数值的布局方式显示的菜单项。

 

  1. public class NavigationMenuView extends RecyclerView implements MenuView {
  2. }
  3.  
  4.  
  5.   public NavigationMenuView(Context context, AttributeSet attrs, int defStyleAttr) {
  6.         super(context, attrs, defStyleAttr);
  7.     //布局方式是竖直线性布局
  8.         setLayoutManager(new LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false));
  9.     }

 

 

构造完NavigationMenuView和Header视图，最后将NavigationMenuAdapter设置为NavigationMenuView的Adapter。这个NavigationMenuAdapter就负责根据视图类型来解析、绑定、展示不同非菜单项视图，比如Header视图、普通菜单项、子菜单项等。

  1.   public NavigationView(Context context, AttributeSet attrs, int defStyleAttr) {
  2.         super(context, attrs, defStyleAttr);
  3.  
  4.         ThemeUtils.checkAppCompatTheme(context);
  5.  
  6.         // Create the menu
  7.         mMenu = new NavigationMenu(context);
  8.  
  9.         // Custom attributes
  10.         TintTypedArray a = TintTypedArray.obtainStyledAttributes(context, attrs,
  11.                 R.styleable.NavigationView, defStyleAttr,
  12.                 R.style.Widget_Design_NavigationView);
  13.  
  14.         ViewCompat.setBackground(
  15.                 this, a.getDrawable(R.styleable.NavigationView_android_background));
  16.         if (a.hasValue(R.styleable.NavigationView_elevation)) {
  17.             ViewCompat.setElevation(this, a.getDimensionPixelSize(
  18.                     R.styleable.NavigationView_elevation, 0));
  19.         }
  20.         ViewCompat.setFitsSystemWindows(this,
  21.                 a.getBoolean(R.styleable.NavigationView_android_fitsSystemWindows, false));
  22.  
  23.         mMaxWidth = a.getDimensionPixelSize(R.styleable.NavigationView_android_maxWidth, 0);
  24.  
  25.         final ColorStateList itemIconTint;
  26.         if (a.hasValue(R.styleable.NavigationView_itemIconTint)) {
  27.             itemIconTint = a.getColorStateList(R.styleable.NavigationView_itemIconTint);
  28.         } else {
  29.             itemIconTint = createDefaultColorStateList(android.R.attr.textColorSecondary);
  30.         }
  31.  
  32.         boolean textAppearanceSet = false;
  33.         int textAppearance = 0;
  34.         if (a.hasValue(R.styleable.NavigationView_itemTextAppearance)) {
  35.             textAppearance = a.getResourceId(R.styleable.NavigationView_itemTextAppearance, 0);
  36.             textAppearanceSet = true;
  37.         }
  38.  
  39.         ColorStateList itemTextColor = null;
  40.         if (a.hasValue(R.styleable.NavigationView_itemTextColor)) {
  41.             itemTextColor = a.getColorStateList(R.styleable.NavigationView_itemTextColor);
  42.         }
  43.  
  44.         if (!textAppearanceSet && itemTextColor == null) {
  45.             // If there isn't a text appearance set, we'll use a default text color
  46.             itemTextColor = createDefaultColorStateList(android.R.attr.textColorPrimary);
  47.         }
  48.  
  49.         final Drawable itemBackground = a.getDrawable(R.styleable.NavigationView_itemBackground);
  50.  
  51.         mMenu.setCallback(new MenuBuilder.Callback() {
  52.             @Override
  53.             public boolean onMenuItemSelected(MenuBuilder menu, MenuItem item) {
  54.                 return mListener != null && mListener.onNavigationItemSelected(item);
  55.             }
  56.  
  57.             @Override
  58.             public void onMenuModeChange(MenuBuilder menu) {}
  59.         });
  60.         mPresenter.setId(PRESENTER_NAVIGATION_VIEW_ID);
  61.         mPresenter.initForMenu(context, mMenu);
  62.         mPresenter.setItemIconTintList(itemIconTint);
  63.         if (textAppearanceSet) {
  64.             mPresenter.setItemTextAppearance(textAppearance);
  65.         }
  66.         mPresenter.setItemTextColor(itemTextColor);
  67.         mPresenter.setItemBackground(itemBackground);
  68.         mMenu.addMenuPresenter(mPresenter);
  69.  
  70. //2.构建整个菜单视图并添加到当前视图中
  71.         addView((View) mPresenter.getMenuView(this));
  72.  
  73. //3.初始化菜单资源menu目录
  74.         if (a.hasValue(R.styleable.NavigationView_menu)) {
  75.             inflateMenu(a.getResourceId(R.styleable.NavigationView_menu, 0));
  76.         }
  77.  
  78. //4. 初始化 header layout
  79.         if (a.hasValue(R.styleable.NavigationView_headerLayout)) {
  80.             inflateHeaderView(a.getResourceId(R.styleable.NavigationView_headerLayout, 0));
  81.         }
  82.  
  83.         a.recycle();
  84.     }
  85.  
  86.  
  87.     /**
  88.      * Inflate a menu resource into this navigation view.
  89.      *(将菜单资源扩展到此导航视图中。)
  90.      * <p>Existing items in the menu will not be modified or removed.</p>
  91.      *
  92.      * @param resId ID of a menu resource to inflate
  93.      */
  94.     public void inflateMenu(int resId) {
  95.         mPresenter.setUpdateSuspended(true);
  96.  
  97. //解析菜单项资源
  98.         getMenuInflater().inflate(resId, mMenu);
  99.         mPresenter.setUpdateSuspended(false);
  100.  
  101. //更新菜单视图
  102.         mPresenter.updateMenuView(false);
  103.     }

 

在注释3中的inflateMenu函数中，我们获取到用户设置的menu项资源，然后解析该menu资源。这个资源就是我们在前文的示例中的app:menu属性设置的menu资源，即res/menu/slide_menu.xml。里面的资源会被解析为相应的Java对象，最后添加到NavigationMenuAdapter中。

 

解析完菜单之后，我们再通过NavigationAdapter来更新整个菜单视图。菜单项对象会存储在mMenu对象中，然后通过Presenter的updateMenuView函数更新视图。

 

  1. #NavigationMenuPresenter
  2.  @Override
  3.     public void updateMenuView(boolean cleared) {
  4.         if (mAdapter != null) {
  5.             mAdapter.update();
  6.         }
  7.     }
  8.  
  9. NavigationMenuAdapter是NavigationMenuPresenter的内部类
  10.  
  11.  private class NavigationMenuAdapter extends RecyclerView.Adapter<ViewHolder> {
  12.    //视图类型，分别为菜单、子菜单、分割视图、header
  13.  private static final int VIEW_TYPE_NORMAL = 0;
  14.         private static final int VIEW_TYPE_SUBHEADER = 1;
  15.         private static final int VIEW_TYPE_SEPARATOR = 2;
  16.         private static final int VIEW_TYPE_HEADER = 3;
  17.  }

 

  1. #NavigationMenuAdapter
  2. /**
  3.      * Flattens the visible menu items of {@link #mMenu} into {@link #mItems},
  4.      * while inserting separators between items when necessary.
  5.      */（将{@link #mMenu}的可见菜单项展平为{@link #mItems}，同时在必要时在项之间插入分隔符。）
  6.     private void prepareMenuItems() {
  7.         if (mUpdateSuspended) {
  8.             return;
  9.         }
  10.         mUpdateSuspended = true;
  11.         mItems.clear();
  12. //1.添加header视图，放在第一项
  13.         mItems.add(new NavigationMenuHeaderItem());
  14.  
  15.         int currentGroupId = -1;
  16.         int currentGroupStart = 0;
  17.         boolean currentGroupHasIcon = false;
  18. //2.从Menu中解析、添加菜单item
  19.         for (int i = 0, totalSize = mMenu.getVisibleItems().size(); i < totalSize; i++) {
  20.             MenuItemImpl item = mMenu.getVisibleItems().get(i);
  21.             if (item.isChecked()) {
  22.                 setCheckedItem(item);
  23.             }
  24.             if (item.isCheckable()) {
  25.                 item.setExclusiveCheckable(false);
  26.             }
  27.             if (item.hasSubMenu()) {
  28.                 SubMenu subMenu = item.getSubMenu();
  29.                 if (subMenu.hasVisibleItems()) {
  30.                     if (i != 0) {
  31.                         mItems.add(new NavigationMenuSeparatorItem(mPaddingSeparator, 0));
  32.                     }
  33. //添加菜单以及子菜单
  34.                     mItems.add(new NavigationMenuTextItem(item));
  35.                     boolean subMenuHasIcon = false;
  36.                     int subMenuStart = mItems.size();
  37.                     for (int j = 0, size = subMenu.size(); j < size; j++) {
  38.                         MenuItemImpl subMenuItem = (MenuItemImpl) subMenu.getItem(j);
  39.                         if (subMenuItem.isVisible()) {
  40.                             if (!subMenuHasIcon && subMenuItem.getIcon() != null) {
  41.                                 subMenuHasIcon = true;
  42.                             }
  43.                             if (subMenuItem.isCheckable()) {
  44.                                 subMenuItem.setExclusiveCheckable(false);
  45.                             }
  46.                             if (item.isChecked()) {
  47.                                 setCheckedItem(item);
  48.                             }
  49.                             mItems.add(new NavigationMenuTextItem(subMenuItem));
  50.                         }
  51.                     }
  52.                     if (subMenuHasIcon) {
  53.                         appendTransparentIconIfMissing(subMenuStart, mItems.size());
  54.                     }
  55.                 }
  56.             } else {
  57. //添加菜单
  58.                 int groupId = item.getGroupId();
  59.                 if (groupId != currentGroupId) { // first item in group
  60.                     currentGroupStart = mItems.size();
  61.                     currentGroupHasIcon = item.getIcon() != null;
  62.                     if (i != 0) {
  63.                         currentGroupStart++;
  64.                         mItems.add(new NavigationMenuSeparatorItem(
  65.                                 mPaddingSeparator, mPaddingSeparator));
  66.                     }
  67.                 } else if (!currentGroupHasIcon && item.getIcon() != null) {
  68.                     currentGroupHasIcon = true;
  69.                     appendTransparentIconIfMissing(currentGroupStart, mItems.size());
  70.                 }
  71.                 NavigationMenuTextItem textItem = new NavigationMenuTextItem(item);
  72.                 textItem.needsEmptyIcon = currentGroupHasIcon;
  73.                 mItems.add(textItem);
  74.                 currentGroupId = groupId;
  75.             }
  76.         }
  77.         mUpdateSuspended = false;
  78.     }
  1. #NavigationMenuAdapter
  2.    @Override
  3.         public int getItemViewType(int position) {
  4.             NavigationMenuItem item = mItems.get(position);
  5.             if (item instanceof NavigationMenuSeparatorItem) {
  6.                 return VIEW_TYPE_SEPARATOR;
  7.             } else if (item instanceof NavigationMenuHeaderItem) {
  8.                 return VIEW_TYPE_HEADER;
  9.             } else if (item instanceof NavigationMenuTextItem) {
  10.                 NavigationMenuTextItem textItem = (NavigationMenuTextItem) item;
  11.                 if (textItem.getMenuItem().hasSubMenu()) {
  12.                     return VIEW_TYPE_SUBHEADER;
  13.                 } else {
  14.                     return VIEW_TYPE_NORMAL;
  15.                 }
  16.             }
  17.             throw new RuntimeException("Unknown item type.");
  18.         }
  19.  
  20. #NavigationMenuAdapter
  21.   @Override
  22.         public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
  23.             switch (viewType) {
  24.                 case VIEW_TYPE_NORMAL:
  25.                     return new NormalViewHolder(mLayoutInflater, parent, mOnClickListener);
  26.                 case VIEW_TYPE_SUBHEADER:
  27.                     return new SubheaderViewHolder(mLayoutInflater, parent);
  28.                 case VIEW_TYPE_SEPARATOR:
  29.                     return new SeparatorViewHolder(mLayoutInflater, parent);
  30.                 case VIEW_TYPE_HEADER:
  31.                     return new HeaderViewHolder(mHeaderLayout);
  32.             }
  33.             return null;
  34.         }
  35.  
  36. #NavigationMenuAdapter
  37.  public void update() {
  38.             prepareMenuItems();
  39.             notifyDataSetChanged();
  40.         }

 

 

从代码中可以看到，在update函数中我们首先会获取到mMenu中所有的MenuItemImpl对象，MenuItemImpl就是每个菜单Java对象。然后将这些对象转换为NavigationMenuItem对象，并且添加到列表中。最后调用notifyDataSetChanged函数更新NavigationMenuView。而不同的菜单类型会有不同的ViewHoler，最终表现为不同的视觉效果。例如，header与菜单项是完全不同一样的。

 

至此，通过NavigationMenuView（本质为RecyclerView）构建了整个菜单视图。总结这些组件的逻辑关系：NavigationView就是MVP中的View角色，它通过Presenter处理解析、构造各种类别菜单项的业务逻辑，将自身从复杂的逻辑中解耦出来，因此NavigationView的代码非常少，而Model就是NavigationMenuItem对象，它们只是简单的实体类，负责承载菜单项的数据。

 

参考《Android源码设计模式》

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/219221
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号