content: package androidx.appcompat.view;
  
  import android.app.Activity;
  import android.content.Context;
  import android.content.ContextWrapper;
  import android.content.res.ColorStateList;
  import android.content.res.TypedArray;
  import android.content.res.XmlResourceParser;
  import android.graphics.PorterDuff;
  import android.util.AttributeSet;
  import android.util.Log;
  import android.util.Xml;
  import android.view.InflateException;
  import android.view.Menu;
  import android.view.MenuInflater;
  import android.view.MenuItem;
  import android.view.SubMenu;
  import android.view.View;
  import androidx.appcompat.R;
  import androidx.appcompat.view.menu.MenuItemImpl;
  import androidx.appcompat.view.menu.MenuItemWrapperICS;
  import androidx.appcompat.widget.DrawableUtils;
  import androidx.appcompat.widget.TintTypedArray;
  import androidx.core.internal.view.SupportMenu;
  import androidx.core.view.ActionProvider;
  import androidx.core.view.MenuItemCompat;
  import java.io.IOException;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Method;
  import org.xmlpull.v1.XmlPullParser;
  import org.xmlpull.v1.XmlPullParserException;
  
  public class SupportMenuInflater extends MenuInflater {
      static final Class<?>[] ACTION_PROVIDER_CONSTRUCTOR_SIGNATURE;
      static final Class<?>[] ACTION_VIEW_CONSTRUCTOR_SIGNATURE;
      static final String LOG_TAG = "SupportMenuInflater";
      static final int NO_ID = 0;
      private static final String XML_GROUP = "group";
      private static final String XML_ITEM = "item";
      private static final String XML_MENU = "menu";
      final Object[] mActionProviderConstructorArguments;
      final Object[] mActionViewConstructorArguments;
      Context mContext;
      private Object mRealOwner;
  
      private static class InflatedOnMenuItemClickListener implements MenuItem.OnMenuItemClickListener {
          private static final Class<?>[] PARAM_TYPES = {MenuItem.class};
          private Method mMethod;
          private Object mRealOwner;
  
          public InflatedOnMenuItemClickListener(Object realOwner, String methodName) {
              this.mRealOwner = realOwner;
              Class<?> cls = realOwner.getClass();
              try {
                  this.mMethod = cls.getMethod(methodName, PARAM_TYPES);
              } catch (Exception e) {
                  InflateException inflateException = new InflateException("Couldn't resolve menu item onClick handler " + methodName + " in class " + cls.getName());
                  inflateException.initCause(e);
                  throw inflateException;
              }
          }
  
          public boolean onMenuItemClick(MenuItem item) {
              try {
                  if (this.mMethod.getReturnType() == Boolean.TYPE) {
                      return ((Boolean) this.mMethod.invoke(this.mRealOwner, new Object[]{item})).booleanValue();
                  }
                  this.mMethod.invoke(this.mRealOwner, new Object[]{item});
                  return true;
              } catch (Exception e) {
                  throw new RuntimeException(e);
              }
          }
      }
  
      private class MenuState {
          private static final int defaultGroupId = 0;
          private static final int defaultItemCategory = 0;
          private static final int defaultItemCheckable = 0;
          private static final boolean defaultItemChecked = false;
          private static final boolean defaultItemEnabled = true;
          private static final int defaultItemId = 0;
          private static final int defaultItemOrder = 0;
          private static final boolean defaultItemVisible = true;
          private int groupCategory;
          private int groupCheckable;
          private boolean groupEnabled;
          private int groupId;
          private int groupOrder;
          private boolean groupVisible;
          ActionProvider itemActionProvider;
          private String itemActionProviderClassName;
          private String itemActionViewClassName;
          private int itemActionViewLayout;
          private boolean itemAdded;
          private int itemAlphabeticModifiers;
          private char itemAlphabeticShortcut;
          private int itemCategoryOrder;
          private int itemCheckable;
          private boolean itemChecked;
          private CharSequence itemContentDescription;
          private boolean itemEnabled;
          private int itemIconResId;
          private ColorStateList itemIconTintList = null;
          private PorterDuff.Mode itemIconTintMode = null;
          private int itemId;
          private String itemListenerMethodName;
          private int itemNumericModifiers;
          private char itemNumericShortcut;
          private int itemShowAsAction;
          private CharSequence itemTitle;
          private CharSequence itemTitleCondensed;
          private CharSequence itemTooltipText;
          private boolean itemVisible;
          private Menu menu;
  
          public MenuState(Menu menu2) {
              this.menu = menu2;
              resetGroup();
          }
  
          private char getShortcut(String shortcutString) {
              if (shortcutString == null) {
                  return 0;
              }
              return shortcutString.charAt(0);
          }
  
          private <T> T newInstance(String className, Class<?>[] clsArr, Object[] arguments) {
              try {
                  Constructor<?> constructor = Class.forName(className, false, SupportMenuInflater.this.mContext.getClassLoader()).getConstructor(clsArr);
                  constructor.setAccessible(true);
                  return constructor.newInstance(arguments);
              } catch (Exception e) {
                  Log.w(SupportMenuInflater.LOG_TAG, "Cannot instantiate class: " + className, e);
                  return null;
              }
          }
  
          private void setItem(MenuItem item) {
              item.setChecked(this.itemChecked).setVisible(this.itemVisible).setEnabled(this.itemEnabled).setCheckable(this.itemCheckable >= 1).setTitleCondensed(this.itemTitleCondensed).setIcon(this.itemIconResId);
              int i = this.itemShowAsAction;
              if (i >= 0) {
                  item.setShowAsAction(i);
              }
              if (this.itemListenerMethodName != null) {
                  if (!SupportMenuInflater.this.mContext.isRestricted()) {
                      item.setOnMenuItemClickListener(new InflatedOnMenuItemClickListener(SupportMenuInflater.this.getRealOwner(), this.itemListenerMethodName));
                  } else {
                      throw new IllegalStateException("The android:onClick attribute cannot be used within a restricted context");
                  }
              }
              if (this.itemCheckable >= 2) {
                  if (item instanceof MenuItemImpl) {
                      ((MenuItemImpl) item).setExclusiveCheckable(true);
                  } else if (item instanceof MenuItemWrapperICS) {
                      ((MenuItemWrapperICS) item).setExclusiveCheckable(true);
                  }
              }
              boolean z = false;
              String str = this.itemActionViewClassName;
              if (str != null) {
                  item.setActionView((View) newInstance(str, SupportMenuInflater.ACTION_VIEW_CONSTRUCTOR_SIGNATURE, SupportMenuInflater.this.mActionViewConstructorArguments));
                  z = true;
              }
              int i2 = this.itemActionViewLayout;
              if (i2 > 0) {
                  if (!z) {
                      item.setActionView(i2);
                  } else {
                      Log.w(SupportMenuInflater.LOG_TAG, "Ignoring attribute 'itemActionViewLayout'. Action view already specified.");
                  }
              }
              ActionProvider actionProvider = this.itemActionProvider;
              if (actionProvider != null) {
                  MenuItemCompat.setActionProvider(item, actionProvider);
              }
              MenuItemCompat.setContentDescription(item, this.itemContentDescription);
              MenuItemCompat.setTooltipText(item, this.itemTooltipText);
              MenuItemCompat.setAlphabeticShortcut(item, this.itemAlphabeticShortcut, this.itemAlphabeticModifiers);
              MenuItemCompat.setNumericShortcut(item, this.itemNumericShortcut, this.itemNumericModifiers);
              PorterDuff.Mode mode = this.itemIconTintMode;
              if (mode != null) {
                  MenuItemCompat.setIconTintMode(item, mode);
              }
              ColorStateList colorStateList = this.itemIconTintList;
              if (colorStateList != null) {
                  MenuItemCompat.setIconTintList(item, colorStateList);
              }
          }
  
          public void addItem() {
              this.itemAdded = true;
              setItem(this.menu.add(this.groupId, this.itemId, this.itemCategoryOrder, this.itemTitle));
          }
  
          public SubMenu addSubMenuItem() {
              this.itemAdded = true;
              SubMenu addSubMenu = this.menu.addSubMenu(this.groupId, this.itemId, this.itemCategoryOrder, this.itemTitle);
              setItem(addSubMenu.getItem());
              return addSubMenu;
          }
  
          public boolean hasAddedItem() {
              return this.itemAdded;
          }
  
          public void readGroup(AttributeSet attrs) {
              TypedArray obtainStyledAttributes = SupportMenuInflater.this.mContext.obtainStyledAttributes(attrs, R.styleable.MenuGroup);
              this.groupId = obtainStyledAttributes.getResourceId(R.styleable.MenuGroup_android_id, 0);
              this.groupCategory = obtainStyledAttributes.getInt(R.styleable.MenuGroup_android_menuCategory, 0);
              this.groupOrder = obtainStyledAttributes.getInt(R.styleable.MenuGroup_android_orderInCategory, 0);
              this.groupCheckable = obtainStyledAttributes.getInt(R.styleable.MenuGroup_android_checkableBehavior, 0);
              this.groupVisible = obtainStyledAttributes.getBoolean(R.styleable.MenuGroup_android_visible, true);
              this.groupEnabled = obtainStyledAttributes.getBoolean(R.styleable.MenuGroup_android_enabled, true);
              obtainStyledAttributes.recycle();
          }
  
          public void readItem(AttributeSet attrs) {
              TintTypedArray obtainStyledAttributes = TintTypedArray.obtainStyledAttributes(SupportMenuInflater.this.mContext, attrs, R.styleable.MenuItem);
              this.itemId = obtainStyledAttributes.getResourceId(R.styleable.MenuItem_android_id, 0);
              this.itemCategoryOrder = (-65536 & obtainStyledAttributes.getInt(R.styleable.MenuItem_android_menuCategory, this.groupCategory)) | (65535 & obtainStyledAttributes.getInt(R.styleable.MenuItem_android_orderInCategory, this.groupOrder));
              this.itemTitle = obtainStyledAttributes.getText(R.styleable.MenuItem_android_title);
              this.itemTitleCondensed = obtainStyledAttributes.getText(R.styleable.MenuItem_android_titleCondensed);
              this.itemIconResId = obtainStyledAttributes.getResourceId(R.styleable.MenuItem_android_icon, 0);
              this.itemAlphabeticShortcut = getShortcut(obtainStyledAttributes.getString(R.styleable.MenuItem_android_alphabeticShortcut));
              this.itemAlphabeticModifiers = obtainStyledAttributes.getInt(R.styleable.MenuItem_alphabeticModifiers, 4096);
              this.itemNumericShortcut = getShortcut(obtainStyledAttributes.getString(R.styleable.MenuItem_android_numericShortcut));
              this.itemNumericModifiers = obtainStyledAttributes.getInt(R.styleable.MenuItem_numericModifiers, 4096);
              if (obtainStyledAttributes.hasValue(R.styleable.MenuItem_android_checkable)) {
                  this.itemCheckable = obtainStyledAttributes.getBoolean(R.styleable.MenuItem_android_checkable, false) ? 1 : 0;
              } else {
                  this.itemCheckable = this.groupCheckable;
              }
              this.itemChecked = obtainStyledAttributes.getBoolean(R.styleable.MenuItem_android_checked, false);
              this.itemVisible = obtainStyledAttributes.getBoolean(R.styleable.MenuItem_android_visible, this.groupVisible);
              this.itemEnabled = obtainStyledAttributes.getBoolean(R.styleable.MenuItem_android_enabled, this.groupEnabled);
              this.itemShowAsAction = obtainStyledAttributes.getInt(R.styleable.MenuItem_showAsAction, -1);
              this.itemListenerMethodName = obtainStyledAttributes.getString(R.styleable.MenuItem_android_onClick);
              this.itemActionViewLayout = obtainStyledAttributes.getResourceId(R.styleable.MenuItem_actionLayout, 0);
              this.itemActionViewClassName = obtainStyledAttributes.getString(R.styleable.MenuItem_actionViewClass);
              String string = obtainStyledAttributes.getString(R.styleable.MenuItem_actionProviderClass);
              this.itemActionProviderClassName = string;
              boolean z = string != null;
              if (z && this.itemActionViewLayout == 0 && this.itemActionViewClassName == null) {
                  this.itemActionProvider = (ActionProvider) newInstance(string, SupportMenuInflater.ACTION_PROVIDER_CONSTRUCTOR_SIGNATURE, SupportMenuInflater.this.mActionProviderConstructorArguments);
              } else {
                  if (z) {
                      Log.w(SupportMenuInflater.LOG_TAG, "Ignoring attribute 'actionProviderClass'. Action view already specified.");
                  }
                  this.itemActionProvider = null;
              }
              this.itemContentDescription = obtainStyledAttributes.getText(R.styleable.MenuItem_contentDescription);
              this.itemTooltipText = obtainStyledAttributes.getText(R.styleable.MenuItem_tooltipText);
              if (obtainStyledAttributes.hasValue(R.styleable.MenuItem_iconTintMode)) {
                  this.itemIconTintMode = DrawableUtils.parseTintMode(obtainStyledAttributes.getInt(R.styleable.MenuItem_iconTintMode, -1), this.itemIconTintMode);
              } else {
                  this.itemIconTintMode = null;
              }
              if (obtainStyledAttributes.hasValue(R.styleable.MenuItem_iconTint)) {
                  this.itemIconTintList = obtainStyledAttributes.getColorStateList(R.styleable.MenuItem_iconTint);
              } else {
                  this.itemIconTintList = null;
              }
              obtainStyledAttributes.recycle();
              this.itemAdded = false;
          }
  
          public void resetGroup() {
              this.groupId = 0;
              this.groupCategory = 0;
              this.groupOrder = 0;
              this.groupCheckable = 0;
              this.groupVisible = true;
              this.groupEnabled = true;
          }
      }
  
      /* JADX DEBUG: Multi-variable search result rejected for TypeSearchVarInfo{r0v1, resolved type: java.lang.Class<?>[]} */
      /* JADX WARNING: Multi-variable type inference failed */
      static {
          /*
              r0 = 1
              java.lang.Class[] r0 = new java.lang.Class[r0]
              r1 = 0
              java.lang.Class<android.content.Context> r2 = android.content.Context.class
              r0[r1] = r2
              ACTION_VIEW_CONSTRUCTOR_SIGNATURE = r0
              ACTION_PROVIDER_CONSTRUCTOR_SIGNATURE = r0
              return
          */
          throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.view.SupportMenuInflater.<clinit>():void");
      }
  
      public SupportMenuInflater(Context context) {
          super(context);
          this.mContext = context;
          Object[] objArr = {context};
          this.mActionViewConstructorArguments = objArr;
          this.mActionProviderConstructorArguments = objArr;
      }
  
      private Object findRealOwner(Object owner) {
          return (!(owner instanceof Activity) && (owner instanceof ContextWrapper)) ? findRealOwner(((ContextWrapper) owner).getBaseContext()) : owner;
      }
  
      private void parseMenu(XmlPullParser parser, AttributeSet attrs, Menu menu) throws XmlPullParserException, IOException {
          MenuState menuState = new MenuState(menu);
          int eventType = parser.getEventType();
          boolean z = false;
          String str = null;
          while (true) {
              if (eventType != 2) {
                  eventType = parser.next();
                  if (eventType == 1) {
                      break;
                  }
              } else {
                  String name = parser.getName();
                  if (name.equals(XML_MENU)) {
                      eventType = parser.next();
                  } else {
                      throw new RuntimeException("Expecting menu, got " + name);
                  }
              }
          }
          boolean z2 = false;
          while (!z2) {
              switch (eventType) {
                  case 1:
                      throw new RuntimeException("Unexpected end of document");
                  case 2:
                      if (!z) {
                          String name2 = parser.getName();
                          if (!name2.equals(XML_GROUP)) {
                              if (!name2.equals(XML_ITEM)) {
                                  if (!name2.equals(XML_MENU)) {
                                      z = true;
                                      str = name2;
                                      break;
                                  } else {
                                      parseMenu(parser, attrs, menuState.addSubMenuItem());
                                      break;
                                  }
                              } else {
                                  menuState.readItem(attrs);
                                  break;
                              }
                          } else {
                              menuState.readGroup(attrs);
                              break;
                          }
                      } else {
                          break;
                      }
                  case 3:
                      String name3 = parser.getName();
                      if (!z || !name3.equals(str)) {
                          if (!name3.equals(XML_GROUP)) {
                              if (!name3.equals(XML_ITEM)) {
                                  if (!name3.equals(XML_MENU)) {
                                      break;
                                  } else {
                                      z2 = true;
                                      break;
                                  }
                              } else if (!menuState.hasAddedItem()) {
                                  if (menuState.itemActionProvider != null && menuState.itemActionProvider.hasSubMenu()) {
                                      menuState.addSubMenuItem();
                                      break;
                                  } else {
                                      menuState.addItem();
                                      break;
                                  }
                              } else {
                                  break;
                              }
                          } else {
                              menuState.resetGroup();
                              break;
                          }
                      } else {
                          z = false;
                          str = null;
                          break;
                      }
              }
              eventType = parser.next();
          }
      }
  
      /* access modifiers changed from: package-private */
      public Object getRealOwner() {
          if (this.mRealOwner == null) {
              this.mRealOwner = findRealOwner(this.mContext);
          }
          return this.mRealOwner;
      }
  
      public void inflate(int menuRes, Menu menu) {
          if (!(menu instanceof SupportMenu)) {
              super.inflate(menuRes, menu);
              return;
          }
          XmlResourceParser xmlResourceParser = null;
          try {
              xmlResourceParser = this.mContext.getResources().getLayout(menuRes);
              parseMenu(xmlResourceParser, Xml.asAttributeSet(xmlResourceParser), menu);
              if (xmlResourceParser != null) {
                  xmlResourceParser.close();
              }
          } catch (XmlPullParserException e) {
              throw new InflateException("Error inflating menu XML", e);
          } catch (IOException e2) {
              throw new InflateException("Error inflating menu XML", e2);
          } catch (Throwable th) {
              if (xmlResourceParser != null) {
                  xmlResourceParser.close();
              }
              throw th;
          }
      }
  }
  