Info Call to Reflection API

Description

List of calls allowing the application to examine and modify the structure and behavior of an object at runtime.

Recommendation

This entry is informative, no recommendations applicable.

Technical details

Method com.urbandroid.lux.MainActivity.addColorToPref() calling method java.lang.reflect.Method.invoke()


    private void addColorToPref(com.urbandroid.lux.ui.SeekBarPreference p8, com.urbandroid.lux.MainActivity$IColorConvertor p9)
    {
        com.urbandroid.lux.MainActivity$35 v0_1 = new android.graphics.drawable.ShapeDrawable(new android.graphics.drawable.shapes.OvalShape());
        v0_1.getPaint().setColor(p9.getColor(p8.getCurrentValue()));
        v0_1.getPaint().setStyle(android.graphics.Paint$Style.FILL);
        v0_1.getPaint().setAntiAlias(1);
        v0_1.setIntrinsicHeight(this.getDip(24));
        v0_1.setIntrinsicWidth(this.getDip(24));
        try {
            reflect.Method v1_6 = p8.getClass();
            Class[] v4 = new Class[1];
            v4[0] = android.graphics.drawable.Drawable;
            reflect.Method v1_7 = v1_6.getMethod("setIcon", v4);
            Object[] v2_2 = new Object[1];
            v2_2[0] = v0_1;
            v1_7.invoke(p8, v2_2);
            p8.setOnProgressListener(new com.urbandroid.lux.MainActivity$35(this, p8, p9));
        } catch (Throwable) {
        }
        return;
    }

Method android.support.v4.graphics.TypefaceCompatApi28Impl.createFromFamiliesWithDefault() calling method java.lang.reflect.Method.invoke()


    protected android.graphics.Typeface createFromFamiliesWithDefault(Object p6)
    {
        try {
            RuntimeException v0_6 = reflect.Array.newInstance(this.mFontFamily, 1);
            reflect.Array.set(v0_6, 0, p6);
            reflect.InvocationTargetException v6_4 = this.mCreateFromFamiliesWithDefault;
            Object[] v4_1 = new Object[4];
            v4_1[0] = v0_6;
            v4_1[1] = "sans-serif";
            v4_1[2] = Integer.valueOf(-1);
            v4_1[3] = Integer.valueOf(-1);
            return ((android.graphics.Typeface) v6_4.invoke(0, v4_1));
        } catch (reflect.InvocationTargetException v6_3) {
            throw new RuntimeException(v6_3);
        } catch (reflect.InvocationTargetException v6_3) {
        }
    }

Method android.support.transition.ViewUtilsApi22.setLeftTopRightBottom() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method android.support.v7.widget.MenuPopupWindow.setTouchModal() calling method java.lang.reflect.Method.invoke()


    public void setTouchModal(boolean p5)
    {
        String v0_0 = android.support.v7.widget.MenuPopupWindow.sSetTouchModalMethod;
        if (v0_0 != null) {
            try {
                android.widget.PopupWindow v1 = this.mPopup;
                Object[] v2_1 = new Object[1];
                v2_1[0] = Boolean.valueOf(p5);
                v0_0.invoke(v1, v2_1);
            } catch (Exception) {
                android.util.Log.i("MenuPopupWindow", "Could not invoke setTouchModal() on PopupWindow. Oh well.");
            }
        }
        return;
    }

Method android.support.v7.view.menu.MenuItemWrapperICS.setExclusiveCheckable() calling method java.lang.reflect.Method.invoke()


    public void setExclusiveCheckable(boolean p7)
    {
        try {
            if (this.mSetExclusiveCheckableMethod != null) {
                reflect.Method v0_3 = this.mSetExclusiveCheckableMethod;
                Object v3_0 = this.mWrappedObject;
                Object[] v2_1 = new Object[1];
                v2_1[0] = Boolean.valueOf(p7);
                v0_3.invoke(v3_0, v2_1);
            } else {
                reflect.Method v0_6 = ((android.support.v4.internal.view.SupportMenuItem) this.mWrappedObject).getClass();
                Class[] v4 = new Class[1];
                v4[0] = Boolean.TYPE;
                this.mSetExclusiveCheckableMethod = v0_6.getDeclaredMethod("setExclusiveCheckable", v4);
            }
        } catch (Boolean v7_1) {
            android.util.Log.w("MenuItemWrapper", "Error while calling setExclusiveCheckable", v7_1);
        }
        return;
    }

Method android.support.v4.graphics.drawable.IconCompat.getUri() calling method java.lang.reflect.Method.invoke()


    private static android.net.Uri getUri(android.graphics.drawable.Icon p7)
    {
        if (android.os.Build$VERSION.SDK_INT < 28) {
            try {
                Class[] v6 = new Class[0];
                Object[] v4_0 = new Object[0];
                return ((android.net.Uri) p7.getClass().getMethod("getUri", v6).invoke(p7, v4_0));
            } catch (NoSuchMethodException v7_5) {
                android.util.Log.e("IconCompat", "Unable to get icon uri", v7_5);
                return 0;
            } catch (NoSuchMethodException v7_4) {
                android.util.Log.e("IconCompat", "Unable to get icon uri", v7_4);
                return 0;
            } catch (NoSuchMethodException v7_3) {
                android.util.Log.e("IconCompat", "Unable to get icon uri", v7_3);
                return 0;
            }
        } else {
            return p7.getUri();
        }
    }

Method android.support.v4.graphics.drawable.IconCompat.getType() calling method java.lang.reflect.Method.invoke()


    private static int getType(android.graphics.drawable.Icon p7)
    {
        if (android.os.Build$VERSION.SDK_INT < 28) {
            try {
                Class[] v6 = new Class[0];
                StringBuilder v4_0 = new Object[0];
                String v7_1 = ((Integer) p7.getClass().getMethod("getType", v6).invoke(p7, v4_0)).intValue();
                return v7_1;
            } catch (NoSuchMethodException v3_6) {
                StringBuilder v4_6 = new StringBuilder();
                v4_6.append("Unable to get icon type ");
                v4_6.append(v7_1);
                android.util.Log.e("IconCompat", v4_6.toString(), v3_6);
                return -1;
            } catch (NoSuchMethodException v3_4) {
                StringBuilder v4_4 = new StringBuilder();
                v4_4.append("Unable to get icon type ");
                v4_4.append(v7_1);
                android.util.Log.e("IconCompat", v4_4.toString(), v3_4);
                return -1;
            } catch (NoSuchMethodException v3_3) {
                StringBuilder v4_2 = new StringBuilder();
                v4_2.append("Unable to get icon type ");
                v4_2.append(v7_1);
                android.util.Log.e("IconCompat", v4_2.toString(), v3_3);
                return -1;
            }
        } else {
            return p7.getType();
        }
    }

Method android.support.v4.graphics.drawable.IconCompat.getResPackage() calling method java.lang.reflect.Method.invoke()


    private static String getResPackage(android.graphics.drawable.Icon p7)
    {
        if (android.os.Build$VERSION.SDK_INT < 28) {
            try {
                Class[] v6 = new Class[0];
                Object[] v4_0 = new Object[0];
                return ((String) p7.getClass().getMethod("getResPackage", v6).invoke(p7, v4_0));
            } catch (NoSuchMethodException v7_5) {
                android.util.Log.e("IconCompat", "Unable to get icon package", v7_5);
                return 0;
            } catch (NoSuchMethodException v7_4) {
                android.util.Log.e("IconCompat", "Unable to get icon package", v7_4);
                return 0;
            } catch (NoSuchMethodException v7_3) {
                android.util.Log.e("IconCompat", "Unable to get icon package", v7_3);
                return 0;
            }
        } else {
            return p7.getResPackage();
        }
    }

Method android.support.v4.graphics.drawable.IconCompat.getResId() calling method java.lang.reflect.Method.invoke()


    private static int getResId(android.graphics.drawable.Icon p6)
    {
        if (android.os.Build$VERSION.SDK_INT < 28) {
            try {
                Class[] v5 = new Class[0];
                Object[] v4_0 = new Object[0];
                return ((Integer) p6.getClass().getMethod("getResId", v5).invoke(p6, v4_0)).intValue();
            } catch (NoSuchMethodException v6_6) {
                android.util.Log.e("IconCompat", "Unable to get icon resource", v6_6);
                return 0;
            } catch (NoSuchMethodException v6_5) {
                android.util.Log.e("IconCompat", "Unable to get icon resource", v6_5);
                return 0;
            } catch (NoSuchMethodException v6_4) {
                android.util.Log.e("IconCompat", "Unable to get icon resource", v6_4);
                return 0;
            }
        } else {
            return p6.getResId();
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi26Impl.createFromFamiliesWithDefault() calling method java.lang.reflect.Method.invoke()


    protected android.graphics.Typeface createFromFamiliesWithDefault(Object p6)
    {
        try {
            RuntimeException v0_5 = reflect.Array.newInstance(this.mFontFamily, 1);
            reflect.Array.set(v0_5, 0, p6);
            reflect.InvocationTargetException v6_4 = this.mCreateFromFamiliesWithDefault;
            Object[] v4_1 = new Object[3];
            v4_1[0] = v0_5;
            v4_1[1] = Integer.valueOf(-1);
            v4_1[2] = Integer.valueOf(-1);
            return ((android.graphics.Typeface) v6_4.invoke(0, v4_1));
        } catch (reflect.InvocationTargetException v6_3) {
            throw new RuntimeException(v6_3);
        } catch (reflect.InvocationTargetException v6_3) {
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi26Impl.freeze() calling method java.lang.reflect.Method.invoke()


    private boolean freeze(Object p3)
    {
        try {
            Object[] v1_1 = new Object[0];
            return ((Boolean) this.mFreeze.invoke(p3, v1_1)).booleanValue();
        } catch (reflect.InvocationTargetException v3_1) {
            throw new RuntimeException(v3_1);
        } catch (reflect.InvocationTargetException v3_1) {
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi26Impl.addFontFromBuffer() calling method java.lang.reflect.Method.invoke()


    private boolean addFontFromBuffer(Object p4, java.nio.ByteBuffer p5, int p6, int p7, int p8)
    {
        try {
            reflect.Method v0 = this.mAddFontFromBuffer;
            Object[] v1_1 = new Object[5];
            v1_1[0] = p5;
            v1_1[1] = Integer.valueOf(p6);
            v1_1[2] = 0;
            v1_1[3] = Integer.valueOf(p7);
            v1_1[4] = Integer.valueOf(p8);
            return ((Boolean) v0.invoke(p4, v1_1)).booleanValue();
        } catch (reflect.InvocationTargetException v4_4) {
            throw new RuntimeException(v4_4);
        } catch (reflect.InvocationTargetException v4_4) {
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi26Impl.addFontFromAssetManager() calling method java.lang.reflect.Method.invoke()


    private boolean addFontFromAssetManager(android.content.Context p4, Object p5, String p6, int p7, int p8, int p9, android.graphics.fonts.FontVariationAxis[] p10)
    {
        try {
            reflect.Method v0 = this.mAddFontFromAssetManager;
            Object[] v1_1 = new Object[8];
            v1_1[0] = p4.getAssets();
            v1_1[1] = p6;
            v1_1[2] = Integer.valueOf(0);
            v1_1[3] = Boolean.valueOf(0);
            v1_1[4] = Integer.valueOf(p7);
            v1_1[5] = Integer.valueOf(p8);
            v1_1[6] = Integer.valueOf(p9);
            v1_1[7] = p10;
            return ((Boolean) v0.invoke(p5, v1_1)).booleanValue();
        } catch (reflect.InvocationTargetException v4_9) {
            throw new RuntimeException(v4_9);
        } catch (reflect.InvocationTargetException v4_9) {
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi26Impl.abortCreation() calling method java.lang.reflect.Method.invoke()


    private void abortCreation(Object p3)
    {
        try {
            Object[] v1_1 = new Object[0];
            this.mAbortCreation.invoke(p3, v1_1);
            return;
        } catch (reflect.InvocationTargetException v3_1) {
            throw new RuntimeException(v3_1);
        } catch (reflect.InvocationTargetException v3_1) {
        }
    }

Method android.support.transition.ViewUtilsApi21.transformMatrixToLocal() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method android.support.transition.ViewUtilsApi21.transformMatrixToGlobal() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method android.support.v7.widget.ListPopupWindow.show() calling method java.lang.reflect.Method.invoke()


    public void show()
    {
        android.os.Handler v0_0 = this.buildDropDown();
        android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_7 = this.isInputMethodNotNeeded();
        android.support.v4.widget.PopupWindowCompat.setWindowLayoutType(this.mPopup, this.mDropDownWindowLayoutType);
        int v3_0 = 1;
        if (!this.mPopup.isShowing()) {
            android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_5 = this.mDropDownWidth;
            if (v1_5 != -1) {
                if (v1_5 == -2) {
                    v1_5 = this.getAnchorView().getWidth();
                }
            } else {
                v1_5 = -1;
            }
            String v2_0 = this.mDropDownHeight;
            if (v2_0 != -1) {
                if (v2_0 != -2) {
                    v0_0 = v2_0;
                }
            } else {
                v0_0 = -1;
            }
            android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_11;
            this.mPopup.setWidth(v1_5);
            this.mPopup.setHeight(v0_0);
            this.setPopupClipToScreenEnabled(1);
            if ((this.mForceIgnoreOutsideTouch) || (this.mDropDownAlwaysVisible)) {
                v1_11 = 0;
            } else {
                v1_11 = 1;
            }
            this.mPopup.setOutsideTouchable(v1_11);
            this.mPopup.setTouchInterceptor(this.mTouchInterceptor);
            if (this.mOverlapAnchorSet) {
                android.support.v4.widget.PopupWindowCompat.setOverlapAnchor(this.mPopup, this.mOverlapAnchor);
            }
            android.os.Handler v0_5 = android.support.v7.widget.ListPopupWindow.sSetEpicenterBoundsMethod;
            if (v0_5 != null) {
                try {
                    android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_14 = this.mPopup;
                    String v2_3 = new Object[1];
                    v2_3[0] = this.mEpicenterBounds;
                    v0_5.invoke(v1_14, v2_3);
                } catch (android.os.Handler v0_6) {
                    android.util.Log.e("ListPopupWindow", "Could not invoke setEpicenterBounds on PopupWindow", v0_6);
                }
            }
            android.support.v4.widget.PopupWindowCompat.showAsDropDown(this.mPopup, this.getAnchorView(), this.mDropDownHorizontalOffset, this.mDropDownVerticalOffset, this.mDropDownGravity);
            this.mDropDownList.setSelection(-1);
            if ((!this.mModal) || (this.mDropDownList.isInTouchMode())) {
                this.clearListSelection();
            }
            if (!this.mModal) {
                this.mHandler.post(this.mHideSelector);
            }
        } else {
            if (android.support.v4.view.ViewCompat.isAttachedToWindow(this.getAnchorView())) {
                String v2_9 = this.mDropDownWidth;
                if (v2_9 != -1) {
                    if (v2_9 == -2) {
                        v2_9 = this.getAnchorView().getWidth();
                    }
                } else {
                    v2_9 = -1;
                }
                android.widget.PopupWindow v7_1 = this.mDropDownHeight;
                if (v7_1 != -1) {
                    if (v7_1 != -2) {
                        v0_0 = v7_1;
                    }
                } else {
                    if (v1_7 == null) {
                        v0_0 = -1;
                    }
                    if (v1_7 == null) {
                        int v4_1;
                        if (this.mDropDownWidth != -1) {
                            v4_1 = 0;
                        } else {
                            v4_1 = -1;
                        }
                        this.mPopup.setWidth(v4_1);
                        this.mPopup.setHeight(-1);
                    } else {
                        int v4_4;
                        if (this.mDropDownWidth != -1) {
                            v4_4 = 0;
                        } else {
                            v4_4 = -1;
                        }
                        this.mPopup.setWidth(v4_4);
                        this.mPopup.setHeight(0);
                    }
                }
                if ((this.mForceIgnoreOutsideTouch) || (this.mDropDownAlwaysVisible)) {
                    v3_0 = 0;
                }
                int v11;
                this.mPopup.setOutsideTouchable(v3_0);
                android.widget.PopupWindow v7_0 = this.mPopup;
                android.view.View v8 = this.getAnchorView();
                if (v2_9 >= null) {
                    v11 = v2_9;
                } else {
                    v11 = -1;
                }
                boolean v12;
                if (v0_0 >= null) {
                    v12 = v0_0;
                } else {
                    v12 = -1;
                }
                v7_0.update(v8, this.mDropDownHorizontalOffset, this.mDropDownVerticalOffset, v11, v12);
            } else {
                return;
            }
        }
        return;
    }

Method android.support.v7.widget.ListPopupWindow.setPopupClipToScreenEnabled() calling method java.lang.reflect.Method.invoke()


    private void setPopupClipToScreenEnabled(boolean p5)
    {
        String v0_0 = android.support.v7.widget.ListPopupWindow.sClipToWindowEnabledMethod;
        if (v0_0 != null) {
            try {
                android.widget.PopupWindow v1 = this.mPopup;
                Object[] v2_1 = new Object[1];
                v2_1[0] = Boolean.valueOf(p5);
                v0_0.invoke(v1, v2_1);
            } catch (Exception) {
                android.util.Log.i("ListPopupWindow", "Could not call setClipToScreenEnabled() on PopupWindow. Oh well.");
            }
        }
        return;
    }

Method android.support.v7.widget.ListPopupWindow.getMaxAvailableHeight() calling method java.lang.reflect.Method.invoke()


    private int getMaxAvailableHeight(android.view.View p6, int p7, boolean p8)
    {
        String v0_0 = android.support.v7.widget.ListPopupWindow.sGetMaxAvailableHeightMethod;
        if (v0_0 != null) {
            try {
                android.widget.PopupWindow v1 = this.mPopup;
                Object[] v2_1 = new Object[3];
                v2_1[0] = p6;
                v2_1[1] = Integer.valueOf(p7);
                v2_1[2] = Boolean.valueOf(p8);
                p6 = ((Integer) v0_0.invoke(v1, v2_1)).intValue();
                return p6;
            } catch (Exception) {
                android.util.Log.i("ListPopupWindow", "Could not call getMaxAvailableHeightMethod(View, int, boolean) on PopupWindow. Using the public version.");
            }
        }
        return this.mPopup.getMaxAvailableHeight(p6, p7);
    }

Method android.support.v4.graphics.TypefaceCompatApi24Impl.createFromFamiliesWithDefault() calling method java.lang.reflect.Method.invoke()


    private static android.graphics.Typeface createFromFamiliesWithDefault(Object p4)
    {
        try {
            RuntimeException v0_3 = reflect.Array.newInstance(android.support.v4.graphics.TypefaceCompatApi24Impl.sFontFamily, 1);
            reflect.Array.set(v0_3, 0, p4);
            Object[] v1_1 = new Object[1];
            v1_1[0] = v0_3;
            return ((android.graphics.Typeface) android.support.v4.graphics.TypefaceCompatApi24Impl.sCreateFromFamiliesWithDefault.invoke(0, v1_1));
        } catch (reflect.InvocationTargetException v4_3) {
            throw new RuntimeException(v4_3);
        } catch (reflect.InvocationTargetException v4_3) {
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi24Impl.addFontWeightStyle() calling method java.lang.reflect.Method.invoke()


    private static boolean addFontWeightStyle(Object p3, java.nio.ByteBuffer p4, int p5, int p6, boolean p7)
    {
        try {
            Object[] v1_1 = new Object[5];
            v1_1[0] = p4;
            v1_1[1] = Integer.valueOf(p5);
            v1_1[2] = 0;
            v1_1[3] = Integer.valueOf(p6);
            v1_1[4] = Boolean.valueOf(p7);
            return ((Boolean) android.support.v4.graphics.TypefaceCompatApi24Impl.sAddFontWeightStyle.invoke(p3, v1_1)).booleanValue();
        } catch (reflect.InvocationTargetException v3_4) {
            throw new RuntimeException(v3_4);
        } catch (reflect.InvocationTargetException v3_4) {
        }
    }

Method android.support.v4.app.ActionBarDrawerToggle.setActionBarUpIndicator() calling method java.lang.reflect.Method.invoke()


    private void setActionBarUpIndicator(android.graphics.drawable.Drawable p7, int p8)
    {
        android.app.ActionBar v0_0 = this.mActivityImpl;
        if (v0_0 == null) {
            if (android.os.Build$VERSION.SDK_INT < 18) {
                if (this.mSetIndicatorInfo == null) {
                    this.mSetIndicatorInfo = new android.support.v4.app.ActionBarDrawerToggle$SetIndicatorInfo(this.mActivity);
                }
                android.app.ActionBar v0_1 = this.mSetIndicatorInfo;
                if (v0_1.mSetHomeAsUpIndicator == null) {
                    String v8_1 = v0_1.mUpIndicatorView;
                    if (v8_1 == null) {
                        android.util.Log.w("ActionBarDrawerToggle", "Couldn\'t set home-as-up indicator");
                    } else {
                        v8_1.setImageDrawable(p7);
                    }
                } else {
                    try {
                        android.app.ActionBar v0_4 = this.mActivity.getActionBar();
                        Object[] v1_2 = this.mSetIndicatorInfo.mSetHomeAsUpIndicator;
                        Object[] v4 = new Object[1];
                        v4[0] = p7;
                        v1_2.invoke(v0_4, v4);
                        String v7_3 = this.mSetIndicatorInfo.mSetHomeActionContentDescription;
                        Object[] v1_4 = new Object[1];
                        v1_4[0] = Integer.valueOf(p8);
                        v7_3.invoke(v0_4, v1_4);
                    } catch (String v7_4) {
                        android.util.Log.w("ActionBarDrawerToggle", "Couldn\'t set home-as-up indicator via JB-MR2 API", v7_4);
                    }
                }
            } else {
                android.app.ActionBar v0_6 = this.mActivity.getActionBar();
                if (v0_6 != null) {
                    v0_6.setHomeAsUpIndicator(p7);
                    v0_6.setHomeActionContentDescription(p8);
                }
            }
            return;
        } else {
            v0_0.setActionBarUpIndicator(p7, p8);
            return;
        }
    }

Method android.support.v4.app.ActionBarDrawerToggle.setActionBarDescription() calling method java.lang.reflect.Method.invoke()


    private void setActionBarDescription(int p5)
    {
        String v0_0 = this.mActivityImpl;
        if (v0_0 == null) {
            if (android.os.Build$VERSION.SDK_INT < 18) {
                if (this.mSetIndicatorInfo == null) {
                    this.mSetIndicatorInfo = new android.support.v4.app.ActionBarDrawerToggle$SetIndicatorInfo(this.mActivity);
                }
                if (this.mSetIndicatorInfo.mSetHomeAsUpIndicator != null) {
                    try {
                        String v0_4 = this.mActivity.getActionBar();
                        String v1_1 = this.mSetIndicatorInfo.mSetHomeActionContentDescription;
                        Object[] v2_1 = new Object[1];
                        v2_1[0] = Integer.valueOf(p5);
                        v1_1.invoke(v0_4, v2_1);
                        v0_4.setSubtitle(v0_4.getSubtitle());
                    } catch (Exception v5_3) {
                        android.util.Log.w("ActionBarDrawerToggle", "Couldn\'t set content description via JB-MR2 API", v5_3);
                    }
                }
            } else {
                String v0_8 = this.mActivity.getActionBar();
                if (v0_8 != null) {
                    v0_8.setHomeActionContentDescription(p5);
                }
            }
            return;
        } else {
            v0_0.setActionBarDescription(p5);
            return;
        }
    }

Method android.support.transition.ViewUtilsApi19.setTransitionAlpha() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method android.support.transition.ViewUtilsApi19.getTransitionAlpha() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method org.json.hue.JSONObject.populateMap() calling method java.lang.reflect.Method.invoke()


    private void populateMap(Object p9)
    {
        int v1_2;
        reflect.Method[] v0_0 = p9.getClass();
        if (v0_0.getClassLoader() == null) {
            v1_2 = 0;
        } else {
            v1_2 = 1;
        }
        reflect.Method[] v0_1;
        if (v1_2 == 0) {
            v0_1 = v0_0.getDeclaredMethods();
        } else {
            v0_1 = v0_0.getMethods();
        }
        int v1_0 = 0;
        while (v1_0 < v0_1.length) {
            try {
                Object v4_1 = v0_1[v1_0];
            } catch (Exception) {
                v1_0++;
            }
            if (!reflect.Modifier.isPublic(v4_1.getModifiers())) {
            } else {
                java.util.Map v5_2 = v4_1.getName();
                String v7 = "";
                if (!v5_2.startsWith("get")) {
                    if (v5_2.startsWith("is")) {
                        v7 = v5_2.substring(2);
                    }
                } else {
                    if (!"getClass".equals(v5_2)) {
                        if (!"getDeclaringClass".equals(v5_2)) {
                            v7 = v5_2.substring(3);
                        } else {
                        }
                    }
                }
                if ((v7.length() <= 0) || ((!Character.isUpperCase(v7.charAt(0))) || (v4_1.getParameterTypes().length != 0))) {
                } else {
                    if (v7.length() != 1) {
                        if (!Character.isUpperCase(v7.charAt(1))) {
                            java.util.Map v5_12 = new StringBuilder();
                            v5_12.append(v7.substring(0, 1).toLowerCase());
                            v5_12.append(v7.substring(1));
                            v7 = v5_12.toString();
                        }
                    } else {
                        v7 = v7.toLowerCase();
                    }
                    Object v4_2 = v4_1.invoke(p9, 0);
                    if (v4_2 == null) {
                    } else {
                        this.map.put(v7, org.json.hue.JSONObject.wrap(v4_2));
                    }
                }
            }
        }
        return;
    }

Method com.urbandroid.lux.util.ServiceUtil.stopForegroundCompat() calling method java.lang.reflect.Method.invoke()


    public static void stopForegroundCompat(android.app.Service p5, int p6)
    {
        Boolean v1_1 = com.urbandroid.lux.util.ServiceUtil.getStopMethod(p5);
        if (v1_1 == null) {
            try {
                ((android.app.NotificationManager) p5.getSystemService("notification")).cancel(p6);
                String v6_1 = p5.getClass();
                Boolean v1_0 = new Class[1];
                v1_0[0] = Boolean.TYPE;
                String v6_2 = v6_1.getMethod("setForeground", v1_0);
                Object[] v0_2 = new Object[1];
                v0_2[0] = Boolean.valueOf(0);
                v6_2.invoke(p5, v0_2);
            } catch (IllegalAccessException v5_1) {
                com.urbandroid.common.logging.Logger.logSevere("Unable to invoke setForeground", v5_1);
            }
            return;
        } else {
            String v6_4 = new Object[1];
            v6_4[0] = Boolean.TRUE;
            try {
                v1_1.invoke(p5, v6_4);
            } catch (IllegalAccessException v5_3) {
                com.urbandroid.common.logging.Logger.logSevere("Unable to invoke stopForeground", v5_3);
            } catch (IllegalAccessException v5_2) {
                com.urbandroid.common.logging.Logger.logSevere("Unable to invoke stopForeground", v5_2);
            }
            return;
        }
    }

Method com.urbandroid.lux.util.ServiceUtil.startForegroundCompat() calling method java.lang.reflect.Method.invoke()


    public static void startForegroundCompat(android.app.Service p6, int p7, android.app.Notification p8)
    {
        Object[] v1_1 = com.urbandroid.lux.util.ServiceUtil.getStartMethod(p6);
        if (v1_1 == null) {
            try {
                String v0_3 = p6.getClass();
                Class[] v4_2 = new Class[1];
                v4_2[0] = Boolean.TYPE;
                String v0_1 = v0_3.getMethod("setForeground", v4_2);
                Object[] v1_0 = new Object[1];
                v1_0[0] = Boolean.valueOf(1);
                v0_1.invoke(p6, v1_0);
                ((android.app.NotificationManager) p6.getSystemService("notification")).notify(p7, p8);
            } catch (IllegalAccessException v6_3) {
                com.urbandroid.common.logging.Logger.logSevere("Unable to invoke setForeground", v6_3);
            }
            return;
        } else {
            Class[] v4_1 = new Object[2];
            v4_1[0] = Integer.valueOf(p7);
            v4_1[1] = p8;
            try {
                v1_1.invoke(p6, v4_1);
            } catch (IllegalAccessException v6_5) {
                com.urbandroid.common.logging.Logger.logSevere("Unable to invoke startForeground", v6_5);
            } catch (IllegalAccessException v6_4) {
                com.urbandroid.common.logging.Logger.logSevere("Unable to invoke startForeground", v6_4);
            }
            return;
        }
    }

Method com.urbandroid.lux.util.AlarmManagerCompat.setExactAndAllowWhileIdle() calling method java.lang.reflect.Method.invoke()


    public static void setExactAndAllowWhileIdle(android.app.AlarmManager p8, int p9, long p10, android.app.PendingIntent p12)
    {
        if (android.os.Build$VERSION.SDK_INT < 23) {
            if (!com.urbandroid.common.util.Environment.isKitKatOrGreater()) {
                p8.set(p9, p10, p12);
            } else {
                p8.setExact(p9, p10, p12);
            }
        } else {
            try {
                boolean v0_3 = p8.getClass();
                Class[] v3 = new Class[3];
                v3[0] = Integer.TYPE;
                v3[1] = Long.TYPE;
                v3[2] = android.app.PendingIntent;
                boolean v0_1 = v0_3.getMethod("setExactAndAllowWhileIdle", v3);
                Object[] v1_2 = new Object[3];
                v1_2[0] = Integer.valueOf(p9);
                v1_2[1] = Long.valueOf(p10);
                v1_2[2] = p12;
                v0_1.invoke(p8, v1_2);
            } catch (Exception v8_1) {
                com.urbandroid.common.logging.Logger.logSevere(v8_1);
            }
        }
        return;
    }

Method com.urbandroid.lux.ui.TwilightView.<init>() calling method java.lang.reflect.Method.invoke()


    public TwilightView()
    {
        com.urbandroid.lux.ui.TwilightView v1_1 = super(com.urbandroid.lux.context.AppContext.getInstance().getContext());
        v1_1.minutesToSunrise = -1;
        v1_1.shown = 0;
        v1_1.state = 0;
        v1_1.temperature = 1500;
        v1_1.dim = 0;
        v1_1.screenOn = 1;
        v1_1.dimBehind = 0;
        v1_1.filterNavbarInLandscape = 0;
        v1_1.p = new android.graphics.Paint();
        v1_1.viewListener = new com.urbandroid.lux.ui.TwilightView$1(v1_1);
        super.updateSettings();
        v1_1.dimBehind = v1_1.mockRemoteSettings.isDimBehind();
        v1_1.filterNavbarInLandscape = v1_1.mockRemoteSettings.isFilterNavbarInLandscape();
        Object[] v4_0 = 2006;
        if (!v1_1.dimBehind) {
            if (v1_1.mockRemoteSettings.isFullscreen()) {
                int v16;
                reflect.Method v3_11 = new android.view.WindowManager$LayoutParams;
                if (android.os.Build$VERSION.SDK_INT < 26) {
                    v16 = 2006;
                } else {
                    v16 = 2038;
                }
                v3_11(-1, -1, v16, 1336, -3);
                v1_1.mLayoutParams = v3_11;
            } else {
                int v10;
                reflect.Method v3_12 = new android.view.WindowManager$LayoutParams;
                if (android.os.Build$VERSION.SDK_INT < 26) {
                    v10 = 2003;
                } else {
                    v10 = 2038;
                }
                v3_12(-1, -1, v10, 312, -3);
                v1_1.mLayoutParams = v3_12;
            }
        } else {
            if (android.os.Build$VERSION.SDK_INT >= 26) {
                v4_0 = 2038;
            }
            v1_1.mLayoutParams = new android.view.WindowManager$LayoutParams(v4_0, 590616, -3);
        }
        v1_1.maxIntensity = v1_1.mockRemoteSettings.getMaxIntesity();
        if ((android.os.Build$VERSION.SDK_INT >= 11) && (!v1_1.mockRemoteSettings.isGpuRendering())) {
            try {
                Integer v5_1 = new Class[2];
                v5_1[0] = Integer.TYPE;
                v5_1[1] = android.graphics.Paint;
            } catch (int v0_1) {
                com.urbandroid.common.logging.Logger.logSevere(v0_1);
            }
            reflect.Method v3_21 = android.view.View.getMethod("setLayerType", v5_1);
            Object[] v4_4 = new Object[2];
            v4_4[0] = Integer.valueOf(1);
            v4_4[1] = 0;
            v3_21.invoke(v1_1, v4_4);
        }
        return;
    }

Method com.urbandroid.lux.ui.SystemBarTintManager.<clinit>() calling method java.lang.reflect.Method.invoke()


    static SystemBarTintManager()
    {
        if (android.os.Build$VERSION.SDK_INT >= 19) {
            try {
                String v0_5 = Class.forName("android.os.SystemProperties");
                Class[] v4 = new Class[1];
                v4[0] = String;
                String v0_1 = v0_5.getDeclaredMethod("get", v4);
                v0_1.setAccessible(1);
                Object[] v2_0 = new Object[1];
                v2_0[0] = "qemu.hw.mainkeys";
                com.urbandroid.lux.ui.SystemBarTintManager.sNavBarOverride = ((String) v0_1.invoke(0, v2_0));
            } catch (Throwable) {
                com.urbandroid.lux.ui.SystemBarTintManager.sNavBarOverride = 0;
            }
        }
        return;
    }

Method com.urbandroid.lux.ui.SeekBarPreference.updateColor() calling method java.lang.reflect.Method.invoke()


    public void updateColor(int p5)
    {
        try {
            Class[] v3 = new Class[0];
            android.graphics.Paint v1_4 = new Object[0];
            android.graphics.drawable.Drawable v0_1 = ((android.graphics.drawable.Drawable) this.getClass().getMethod("getIcon", v3).invoke(this, v1_4));
        } catch (Throwable) {
            return;
        }
        if (v0_1 == null) {
            return;
        } else {
            ((android.graphics.drawable.ShapeDrawable) v0_1).getPaint().setColor(p5);
            v0_1.invalidateSelf();
            return;
        }
    }

Method com.urbandroid.common.util.ServiceUtil.stopForegroundCompat() calling method java.lang.reflect.Method.invoke()


    public static void stopForegroundCompat(android.app.Service p5, int p6)
    {
        Boolean v1_1 = com.urbandroid.common.util.ServiceUtil.getStopMethod(p5);
        if (v1_1 == null) {
            try {
                ((android.app.NotificationManager) p5.getSystemService("notification")).cancel(p6);
                String v6_1 = p5.getClass();
                Boolean v1_0 = new Class[1];
                v1_0[0] = Boolean.TYPE;
                String v6_2 = v6_1.getMethod("setForeground", v1_0);
                Object[] v0_2 = new Object[1];
                v0_2[0] = Boolean.valueOf(0);
                v6_2.invoke(p5, v0_2);
            } catch (IllegalAccessException v5_1) {
                com.urbandroid.common.logging.Logger.logSevere("Unable to invoke setForeground", v5_1);
            }
            return;
        } else {
            String v6_4 = new Object[1];
            v6_4[0] = Boolean.TRUE;
            try {
                v1_1.invoke(p5, v6_4);
            } catch (IllegalAccessException v5_3) {
                com.urbandroid.common.logging.Logger.logSevere("Unable to invoke stopForeground", v5_3);
            } catch (IllegalAccessException v5_2) {
                com.urbandroid.common.logging.Logger.logSevere("Unable to invoke stopForeground", v5_2);
            }
            return;
        }
    }

Method com.urbandroid.common.util.ServiceUtil.startForegroundCompat() calling method java.lang.reflect.Method.invoke()


    public static void startForegroundCompat(android.app.Service p6, int p7, android.app.Notification p8)
    {
        Object[] v1_1 = com.urbandroid.common.util.ServiceUtil.getStartMethod(p6);
        if (v1_1 == null) {
            try {
                String v0_3 = p6.getClass();
                Boolean v4_3 = new Class[1];
                v4_3[0] = Boolean.TYPE;
                String v0_1 = v0_3.getMethod("setForeground", v4_3);
                Object[] v1_0 = new Object[1];
                v1_0[0] = Boolean.valueOf(1);
                v0_1.invoke(p6, v1_0);
                ((android.app.NotificationManager) p6.getSystemService("notification")).notify(p7, p8);
            } catch (IllegalAccessException v6_3) {
                com.urbandroid.common.logging.Logger.logSevere("Unable to invoke setForeground", v6_3);
                com.urbandroid.common.error.ErrorReporter.getInstance().generateAssertionError(com.urbandroid.common.error.AssertionType.GENERIC_ASSERTION_FAILURE, "Unable to invoke setForeground", 1);
            }
            return;
        } else {
            Boolean v4_2 = new Object[2];
            v4_2[0] = Integer.valueOf(p7);
            v4_2[1] = p8;
            try {
                v1_1.invoke(p6, v4_2);
            } catch (IllegalAccessException v6_6) {
                com.urbandroid.common.logging.Logger.logSevere("Unable to invoke startForeground", v6_6);
            } catch (IllegalAccessException v6_5) {
                com.urbandroid.common.logging.Logger.logSevere("Unable to invoke startForeground", v6_5);
            }
            return;
        }
    }

Method com.urbandroid.common.util.PowerManagerCompat.isIgnoringBatteryOptimizations() calling method java.lang.reflect.Method.invoke()


    public static boolean isIgnoringBatteryOptimizations(android.content.Context p7)
    {
        if (com.urbandroid.common.util.Environment.isMOrGreater()) {
            android.os.PowerManager v0_3 = ((android.os.PowerManager) p7.getSystemService("power"));
            try {
                reflect.Method v2_1 = v0_3.getClass();
                Class[] v4 = new Class[1];
                v4[0] = String;
                reflect.Method v2_0 = v2_1.getMethod("isIgnoringBatteryOptimizations", v4);
                Object[] v3_1 = new Object[1];
                v3_1[0] = p7.getPackageName();
                boolean v7_3 = ((Boolean) v2_0.invoke(v0_3, v3_1));
            } catch (boolean v7_4) {
                com.urbandroid.common.logging.Logger.logSevere(v7_4);
            }
            if ((v7_3) && (!v7_3.booleanValue())) {
                return 0;
            }
        }
        return 1;
    }

Method com.urbandroid.common.util.PermissionCompat.requestPermissions() calling method java.lang.reflect.Method.invoke()


    public static void requestPermissions(android.app.Activity p7, String[] p8, int p9)
    {
        if (com.urbandroid.common.util.Environment.isMOrGreater()) {
            try {
                reflect.Method v0_2 = p7.getClass();
                Class[] v3 = new Class[2];
                v3[0] = String[];
                v3[1] = Integer.TYPE;
                reflect.Method v0_1 = v0_2.getMethod("requestPermissions", v3);
                Object[] v1_0 = new Object[2];
                v1_0[0] = p8;
                v1_0[1] = Integer.valueOf(p9);
                v0_1.invoke(p7, v1_0);
            } catch (Exception v7_1) {
                com.urbandroid.common.logging.Logger.logSevere(v7_1);
            }
        }
        return;
    }

Method com.urbandroid.common.util.PermissionCompat.checkSelfPermission() calling method java.lang.reflect.Method.invoke()


    public static int checkSelfPermission(android.content.Context p6, String p7)
    {
        if (com.urbandroid.common.util.Environment.isMOrGreater()) {
            try {
                reflect.Method v0_2 = p6.getClass();
                Class[] v4 = new Class[1];
                v4[0] = String;
                reflect.Method v0_1 = v0_2.getMethod("checkSelfPermission", v4);
                Object[] v2_0 = new Object[1];
                v2_0[0] = p7;
                return ((Integer) v0_1.invoke(p6, v2_0)).intValue();
            } catch (Exception v6_4) {
                com.urbandroid.common.logging.Logger.logSevere(v6_4);
            }
        }
        return 0;
    }

Method com.urbandroid.common.util.PermissionCompat.canDrawOverlays() calling method java.lang.reflect.Method.invoke()


    public static boolean canDrawOverlays(android.content.Context p5)
    {
        try {
            int v2_0 = new Class[1];
            v2_0[0] = android.content.Context;
        } catch (Exception) {
            return 1;
        }
        reflect.Method v1_1 = android.provider.Settings.getMethod("canDrawOverlays", v2_0);
        Object[] v3_0 = new Object[1];
        v3_0[0] = p5;
        return ((Boolean) v1_1.invoke(0, v3_0)).booleanValue();
    }

Method com.urbandroid.common.util.Environment.isScreenOn() calling method java.lang.reflect.Method.invoke()


    public static Boolean isScreenOn(android.content.Context p4)
    {
        int v4_6 = ((android.os.PowerManager) p4.getSystemService("power"));
        try {
            Class[] v3 = new Class[0];
            Object[] v1_0 = new Object[0];
            return ((Boolean) v4_6.getClass().getMethod("isScreenOn", v3).invoke(v4_6, v1_0));
        } catch (int v4_3) {
            com.urbandroid.common.logging.Logger.logInfo("Cannot fetch screen state", v4_3);
            return 0;
        }
    }

Method com.urbandroid.common.util.Environment.getExternalDocumentsDirs() calling method java.lang.reflect.Method.invoke()


    public static java.io.File[] getExternalDocumentsDirs(android.content.Context p6)
    {
        try {
            reflect.Method v1_0 = p6.getClass();
            Class[] v4 = new Class[1];
            v4[0] = String;
            reflect.Method v1_1 = v1_0.getMethod("getExternalFilesDirs", v4);
            Object[] v2_0 = new Object[1];
            v2_0[0] = com.urbandroid.common.util.Environment.getDocumentsFolder();
            return ((java.io.File[]) v1_1.invoke(p6, v2_0));
        } catch (SecurityException) {
            java.io.File[] v6_3 = new java.io.File[0];
            return v6_3;
        }
    }

Method com.urbandroid.common.util.AlarmManagerCompat.setExactAndAllowWhileIdle() calling method java.lang.reflect.Method.invoke()


    public static void setExactAndAllowWhileIdle(android.app.AlarmManager p8, int p9, long p10, android.app.PendingIntent p12)
    {
        if (android.os.Build$VERSION.SDK_INT < 23) {
            if (!com.urbandroid.common.util.Environment.isKitKatOrGreater()) {
                p8.set(p9, p10, p12);
            } else {
                p8.setExact(p9, p10, p12);
            }
        } else {
            try {
                boolean v0_3 = p8.getClass();
                Class[] v3 = new Class[3];
                v3[0] = Integer.TYPE;
                v3[1] = Long.TYPE;
                v3[2] = android.app.PendingIntent;
                boolean v0_1 = v0_3.getMethod("setExactAndAllowWhileIdle", v3);
                Object[] v1_2 = new Object[3];
                v1_2[0] = Integer.valueOf(p9);
                v1_2[1] = Long.valueOf(p10);
                v1_2[2] = p12;
                v0_1.invoke(p8, v1_2);
            } catch (Exception v8_1) {
                com.urbandroid.common.logging.Logger.logSevere(v8_1);
            }
        }
        return;
    }

Method com.urbandroid.common.util.ActivityUtils.setLayerTypeSoftware() calling method java.lang.reflect.Method.invoke()


    public static void setLayerTypeSoftware(android.view.View p6)
    {
        try {
            int v2_2 = new Class[2];
            v2_2[0] = Integer.TYPE;
            v2_2[1] = android.graphics.Paint;
        } catch (Throwable) {
            return;
        }
        reflect.Method v0_1 = android.view.View.getMethod("setLayerType", v2_2);
        Object[] v1_1 = new Object[2];
        v1_1[0] = Integer.valueOf(1);
        v1_1[1] = 0;
        v0_1.invoke(p6, v1_1);
        return;
    }

Method com.urbandroid.common.util.ActivityUtils.setFinishOnTouchOutside() calling method java.lang.reflect.Method.invoke()


    public static void setFinishOnTouchOutside(android.app.Activity p5, boolean p6)
    {
        try {
            Class[] v2 = new Class[1];
            v2[0] = Boolean.TYPE;
        } catch (NoSuchMethodError) {
            return;
        } catch (Exception v5_1) {
            com.urbandroid.common.logging.Logger.logInfo("Cannot fetch screen state", v5_1);
            return;
        }
        reflect.Method v0_1 = android.app.Activity.getMethod("setFinishOnTouchOutside", v2);
        Object[] v1_1 = new Object[1];
        v1_1[0] = Boolean.valueOf(p6);
        v0_1.invoke(p5, v1_1);
        return;
    }

Method com.urbandroid.common.util.ActivityUtils.displayBackHomeNavigation() calling method java.lang.reflect.Method.invoke()


    public static void displayBackHomeNavigation(android.app.Activity p6)
    {
        try {
            if (com.urbandroid.common.util.Environment.isHoneycombOrGreater()) {
                Boolean v3_2 = new Class[0];
                Object[] v1_0 = new Object[0];
                Object v6_1 = p6.getClass().getMethod("getActionBar", v3_2).invoke(p6, v1_0);
                reflect.Method v0_2 = v6_1.getClass();
                Class[] v4 = new Class[1];
                v4[0] = Boolean.TYPE;
                reflect.Method v0_3 = v0_2.getMethod("setDisplayHomeAsUpEnabled", v4);
                Object[] v1_2 = new Object[1];
                v1_2[0] = Boolean.valueOf(1);
                v0_3.invoke(v6_1, v1_2);
            }
        } catch (Object v6_2) {
            com.urbandroid.common.logging.Logger.logSevere(v6_2);
        }
        return;
    }

Method com.urbandroid.common.datastore.compatibility.SafeMethodCalls.invalidateOptionsMenu() calling method java.lang.reflect.Method.invoke()


    public static void invalidateOptionsMenu(android.app.Activity p4)
    {
        if (com.urbandroid.common.util.Environment.getAPILevel() >= 11) {
            try {
                Class[] v3 = new Class[0];
                Object[] v1_0 = new Object[0];
                p4.getClass().getMethod("invalidateOptionsMenu", v3).invoke(p4, v1_0);
            } catch (Exception v4_1) {
                com.urbandroid.common.logging.Logger.logWarning("Invalidation of menu options is not supported", v4_1);
            }
        }
        return;
    }

Method com.philips.lighting.hue.sdk.heartbeat.PHHeartbeatProcessor$1.run() calling method java.lang.reflect.Method.invoke()


    public void run()
    {
        String v0_1 = new com.philips.lighting.hue.sdk.connection.impl.PHHueHttpConnection();
        com.philips.lighting.hue.sdk.bridge.impl.PHBridgeDelegator v1_3 = ((com.philips.lighting.hue.sdk.bridge.impl.PHBridgeImpl) com.philips.lighting.hue.sdk.heartbeat.PHHeartbeatProcessor.access$000(this.this$0)).getBridgeDelegator();
        try {
            com.philips.lighting.hue.sdk.heartbeat.PHHeartbeatProcessor$1$1 v2_2 = ((StringBuffer) v1_3.getClass().getMethod("buildHttpAddress", 0).invoke(v1_3, 0));
            v2_2.append("config");
        } catch (String v0_9) {
            v0_9.printStackTrace();
            return;
        } catch (String v0_8) {
            v0_8.printStackTrace();
            return;
        } catch (String v0_7) {
            v0_7.printStackTrace();
            return;
        } catch (String v0_6) {
            v0_6.printStackTrace();
            return;
        } catch (String v0_5) {
            v0_5.printStackTrace();
            return;
        }
        if (v0_1.putData("{\"linkbutton\":true}", v2_2.toString()).contains("success")) {
            v1_3.removeUsername(this.val$whitelistID, new com.philips.lighting.hue.sdk.heartbeat.PHHeartbeatProcessor$1$1(this, v1_3));
        }
        return;
    }

Method com.google.android.gms.common.server.response.FastJsonResponse.getFieldValue() calling method java.lang.reflect.Method.invoke()


    protected Object getFieldValue(com.google.android.gms.common.server.response.FastJsonResponse$Field p7)
    {
        RuntimeException v0_0 = p7.zapv;
        if (p7.zapx == null) {
            return this.getValueObject(v0_0);
        } else {
            Class[] v1_1;
            if (this.getValueObject(v0_0) != null) {
                v1_1 = 0;
            } else {
                v1_1 = 1;
            }
            Object[] v4 = new Object[1];
            v4[0] = p7.zapv;
            com.google.android.gms.common.internal.Preconditions.checkState(v1_1, "Concrete field shouldn\'t be value object: %s", v4);
            try {
                Exception v7_2 = Character.toUpperCase(v0_0.charAt(0));
                RuntimeException v0_1 = v0_0.substring(1);
                StringBuilder v2_1 = new StringBuilder((String.valueOf(v0_1).length() + 4));
                v2_1.append("get");
                v2_1.append(v7_2);
                v2_1.append(v0_1);
                Class[] v1_6 = new Class[0];
                RuntimeException v0_3 = new Object[0];
                return this.getClass().getMethod(v2_1.toString(), v1_6).invoke(this, v0_3);
            } catch (Exception v7_7) {
                throw new RuntimeException(v7_7);
            }
        }
    }

Method com.caverock.androidsvg.SVGImageView.setSoftwareLayerType() calling method java.lang.reflect.Method.invoke()


    private void setSoftwareLayerType()
    {
        if (com.caverock.androidsvg.SVGImageView.setLayerTypeMethod != null) {
            try {
            } catch (int v0_5) {
                android.util.Log.w("SVGImageView", "Unexpected failure calling setLayerType", v0_5);
                return;
            }
            Object[] v2_1 = new Object[2];
            v2_1[0] = Integer.valueOf(android.view.View.getField("LAYER_TYPE_SOFTWARE").getInt(new android.view.View(this.getContext())));
            v2_1[1] = 0;
            com.caverock.androidsvg.SVGImageView.setLayerTypeMethod.invoke(this, v2_1);
            return;
        } else {
            return;
        }
    }

Method androidx.versionedparcelable.VersionedParcel.writeToParcel() calling method java.lang.reflect.Method.invoke()


    protected static void writeToParcel(androidx.versionedparcelable.VersionedParcelable p7, androidx.versionedparcelable.VersionedParcel p8)
    {
        try {
            String v0_0 = androidx.versionedparcelable.VersionedParcel.findParcelClass(p7);
            Class[] v3 = new Class[2];
            v3[0] = p7.getClass();
            v3[1] = androidx.versionedparcelable.VersionedParcel;
            String v0_1 = v0_0.getDeclaredMethod("write", v3);
            Object[] v2_0 = new Object[2];
            v2_0[0] = p7;
            v2_0[1] = p8;
            v0_1.invoke(0, v2_0);
            return;
        } catch (RuntimeException v7_6) {
            throw new RuntimeException("VersionedParcel encountered IllegalAccessException", v7_6);
        } catch (RuntimeException v7_2) {
            throw new RuntimeException("VersionedParcel encountered NoSuchMethodException", v7_2);
        } catch (RuntimeException v7_1) {
            throw new RuntimeException("VersionedParcel encountered ClassNotFoundException", v7_1);
        } catch (RuntimeException v7_3) {
            if (!(v7_3.getCause() instanceof RuntimeException)) {
                throw new RuntimeException("VersionedParcel encountered InvocationTargetException", v7_3);
            } else {
                throw ((RuntimeException) v7_3.getCause());
            }
        }
    }

Method androidx.versionedparcelable.VersionedParcel.readFromParcel() calling method java.lang.reflect.Method.invoke()


    protected static androidx.versionedparcelable.VersionedParcelable readFromParcel(String p5, androidx.versionedparcelable.VersionedParcel p6)
    {
        try {
            RuntimeException v5_10 = Class.forName(p5, 1, androidx.versionedparcelable.VersionedParcel.getClassLoader());
            Class[] v2 = new Class[1];
            v2[0] = androidx.versionedparcelable.VersionedParcel;
            RuntimeException v5_1 = v5_10.getDeclaredMethod("read", v2);
            Object[] v1_0 = new Object[1];
            v1_0[0] = p6;
            return ((androidx.versionedparcelable.VersionedParcelable) v5_1.invoke(0, v1_0));
        } catch (RuntimeException v5_9) {
            throw new RuntimeException("VersionedParcel encountered IllegalAccessException", v5_9);
        } catch (RuntimeException v5_5) {
            throw new RuntimeException("VersionedParcel encountered NoSuchMethodException", v5_5);
        } catch (RuntimeException v5_4) {
            throw new RuntimeException("VersionedParcel encountered ClassNotFoundException", v5_4);
        } catch (RuntimeException v5_6) {
            if (!(v5_6.getCause() instanceof RuntimeException)) {
                throw new RuntimeException("VersionedParcel encountered InvocationTargetException", v5_6);
            } else {
                throw ((RuntimeException) v5_6.getCause());
            }
        }
    }

Method android.support.v7.widget.ViewUtils.makeOptionalFitsSystemWindows() calling method java.lang.reflect.Method.invoke()


    public static void makeOptionalFitsSystemWindows(android.view.View p6)
    {
        if (android.os.Build$VERSION.SDK_INT >= 16) {
            try {
                Class[] v5 = new Class[0];
                reflect.Method v2_0 = p6.getClass().getMethod("makeOptionalFitsSystemWindows", v5);
            } catch (NoSuchMethodException) {
                android.util.Log.d("ViewUtils", "Could not find method makeOptionalFitsSystemWindows. Oh well...");
            } catch (IllegalAccessException v6_2) {
                android.util.Log.d("ViewUtils", "Could not invoke makeOptionalFitsSystemWindows", v6_2);
            } catch (IllegalAccessException v6_1) {
                android.util.Log.d("ViewUtils", "Could not invoke makeOptionalFitsSystemWindows", v6_1);
            }
            if (!v2_0.isAccessible()) {
                v2_0.setAccessible(1);
            }
            Object[] v3_2 = new Object[0];
            v2_0.invoke(p6, v3_2);
        }
        return;
    }

Method android.support.v7.widget.ViewUtils.computeFitSystemWindows() calling method java.lang.reflect.Method.invoke()


    public static void computeFitSystemWindows(android.view.View p3, android.graphics.Rect p4, android.graphics.Rect p5)
    {
        reflect.Method v0 = android.support.v7.widget.ViewUtils.sComputeFitSystemWindowsMethod;
        if (v0 != null) {
            try {
                Object[] v1_1 = new Object[2];
                v1_1[0] = p4;
                v1_1[1] = p5;
                v0.invoke(p3, v1_1);
            } catch (Exception v3_1) {
                android.util.Log.d("ViewUtils", "Could not invoke computeFitSystemWindows", v3_1);
            }
        }
        return;
    }

Method android.support.v7.widget.SearchView$AutoCompleteTextViewReflector.ensureImeVisible() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method android.support.v7.widget.SearchView$AutoCompleteTextViewReflector.doBeforeTextChanged() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method android.support.v7.widget.SearchView$AutoCompleteTextViewReflector.doAfterTextChanged() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method android.support.v7.widget.AppCompatTextViewAutoSizeHelper.setRawTextSize() calling method java.lang.reflect.Method.invoke()


    private void setRawTextSize(float p4)
    {
        if (p4 != this.mTextView.getPaint().getTextSize()) {
            android.widget.TextView v4_2;
            this.mTextView.getPaint().setTextSize(p4);
            if (android.os.Build$VERSION.SDK_INT < 18) {
                v4_2 = 0;
            } else {
                v4_2 = this.mTextView.isInLayout();
            }
            if (this.mTextView.getLayout() != null) {
                this.mNeedsAutoSizeText = 0;
                try {
                    Exception v0_6 = this.getTextViewMethod("nullLayouts");
                } catch (Exception v0_7) {
                    android.util.Log.w("ACTVAutoSizeHelper", "Failed to invoke TextView#nullLayouts() method", v0_7);
                    if (v4_2 != null) {
                        this.mTextView.forceLayout();
                    } else {
                        this.mTextView.requestLayout();
                    }
                    this.mTextView.invalidate();
                }
                if (v0_6 == null) {
                } else {
                    Object[] v1_2 = new Object[0];
                    v0_6.invoke(this.mTextView, v1_2);
                }
            }
        }
        return;
    }

Method android.support.v7.widget.AppCompatTextViewAutoSizeHelper.invokeAndReturnWithDefault() calling method java.lang.reflect.Method.invoke()


    private Object invokeAndReturnWithDefault(Object p5, String p6, Object p7)
    {
        try {
            StringBuilder v2_1 = new Object[0];
            p7 = this.getTextViewMethod(p6).invoke(p5, v2_1);
        } catch (Exception v5_1) {
            throw v5_1;
        } catch (Exception v5_2) {
            StringBuilder v2_0 = new StringBuilder();
            v2_0.append("Failed to invoke TextView#");
            v2_0.append(p6);
            v2_0.append("() method");
            android.util.Log.w("ACTVAutoSizeHelper", v2_0.toString(), v5_2);
        }
        return p7;
    }

Method android.support.v7.view.SupportMenuInflater$InflatedOnMenuItemClickListener.onMenuItemClick() calling method java.lang.reflect.Method.invoke()


    public boolean onMenuItemClick(android.view.MenuItem p6)
    {
        try {
            if (this.mMethod.getReturnType() != Boolean.TYPE) {
                reflect.Method v0_5 = this.mMethod;
                Object v1_2 = this.mRealOwner;
                Object[] v4 = new Object[1];
                v4[0] = p6;
                v0_5.invoke(v1_2, v4);
                return 1;
            } else {
                reflect.Method v0_1 = this.mMethod;
                Object v1_0 = this.mRealOwner;
                Object[] v3_0 = new Object[1];
                v3_0[0] = p6;
                return ((Boolean) v0_1.invoke(v1_0, v3_0)).booleanValue();
            }
        } catch (boolean v6_4) {
            throw new RuntimeException(v6_4);
        }
    }

Method android.support.v7.app.AppCompatViewInflater$DeclaredOnClickListener.onClick() calling method java.lang.reflect.Method.invoke()


    public void onClick(android.view.View p5)
    {
        if (this.mResolvedMethod == null) {
            this.resolveMethod(this.mHostView.getContext(), this.mMethodName);
        }
        try {
            IllegalStateException v0_7 = this.mResolvedMethod;
            String v1_3 = this.mResolvedContext;
            Object[] v2_0 = new Object[1];
            v2_0[0] = p5;
            v0_7.invoke(v1_3, v2_0);
            return;
        } catch (reflect.InvocationTargetException v5_2) {
            throw new IllegalStateException("Could not execute non-public method for android:onClick", v5_2);
        } catch (reflect.InvocationTargetException v5_1) {
            throw new IllegalStateException("Could not execute method for android:onClick", v5_1);
        }
    }

Method android.support.v7.app.ActionBarDrawerToggleHoneycomb.setActionBarUpIndicator() calling method java.lang.reflect.Method.invoke()


    public static android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo setActionBarUpIndicator(android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo p5, android.app.Activity p6, android.graphics.drawable.Drawable p7, int p8)
    {
        android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo v5_1 = new android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo(p6);
        if (v5_1.setHomeAsUpIndicator == null) {
            String v6_3 = v5_1.upIndicatorView;
            if (v6_3 == null) {
                android.util.Log.w("ActionBarDrawerToggleHC", "Couldn\'t set home-as-up indicator");
            } else {
                v6_3.setImageDrawable(p7);
            }
        } else {
            try {
                String v6_1 = p6.getActionBar();
                Object[] v0_0 = v5_1.setHomeAsUpIndicator;
                Object[] v3 = new Object[1];
                v3[0] = p7;
                v0_0.invoke(v6_1, v3);
                String v7_1 = v5_1.setHomeActionContentDescription;
                Object[] v0_1 = new Object[1];
                v0_1[0] = Integer.valueOf(p8);
                v7_1.invoke(v6_1, v0_1);
            } catch (String v6_2) {
                android.util.Log.w("ActionBarDrawerToggleHC", "Couldn\'t set home-as-up indicator via JB-MR2 API", v6_2);
            }
        }
        return v5_1;
    }

Method android.support.v7.app.ActionBarDrawerToggleHoneycomb.setActionBarDescription() calling method java.lang.reflect.Method.invoke()


    public static android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo setActionBarDescription(android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo p3, android.app.Activity p4, int p5)
    {
        if (p3 == null) {
            p3 = new android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo(p4);
        }
        if (p3.setHomeAsUpIndicator != null) {
            try {
                Exception v4_2 = p4.getActionBar();
                String v0_3 = p3.setHomeActionContentDescription;
                Object[] v1_1 = new Object[1];
                v1_1[0] = Integer.valueOf(p5);
                v0_3.invoke(v4_2, v1_1);
            } catch (Exception v4_1) {
                android.util.Log.w("ActionBarDrawerToggleHC", "Couldn\'t set content description via JB-MR2 API", v4_1);
            }
            if (android.os.Build$VERSION.SDK_INT <= 19) {
                v4_2.setSubtitle(v4_2.getSubtitle());
            }
        }
        return p3;
    }

Method android.support.v4.widget.TextViewCompat$OreoCallback.recomputeProcessTextMenuItems() calling method java.lang.reflect.Method.invoke()


    private void recomputeProcessTextMenuItems(android.view.Menu p9)
    {
        java.util.List v0_1 = this.mTextView.getContext();
        android.content.pm.PackageManager v1 = v0_1.getPackageManager();
        if (!this.mInitializedMenuBuilderReferences) {
            this.mInitializedMenuBuilderReferences = 1;
            try {
                this.mMenuBuilderClass = Class.forName("com.android.internal.view.menu.MenuBuilder");
                int v2_2 = this.mMenuBuilderClass;
                android.view.MenuItem v6_0 = new Class[1];
                v6_0[0] = Integer.TYPE;
                this.mMenuBuilderRemoveItemAtMethod = v2_2.getDeclaredMethod("removeItemAt", v6_0);
                this.mCanUseMenuBuilderReferences = 1;
            } catch (ClassNotFoundException) {
                this.mMenuBuilderClass = 0;
                this.mMenuBuilderRemoveItemAtMethod = 0;
                this.mCanUseMenuBuilderReferences = 0;
            }
        }
        try {
            if ((!this.mCanUseMenuBuilderReferences) || (!this.mMenuBuilderClass.isInstance(p9))) {
                int v2_8 = p9.getClass();
                android.view.MenuItem v6_1 = new Class[1];
                v6_1[0] = Integer.TYPE;
                int v2_9 = v2_8.getDeclaredMethod("removeItemAt", v6_1);
            } else {
                v2_9 = this.mMenuBuilderRemoveItemAtMethod;
            }
        } catch (NoSuchMethodException) {
            return;
        }
        android.view.MenuItem v3_1 = (p9.size() - 1);
        while (v3_1 >= null) {
            android.view.MenuItem v6_4 = p9.getItem(v3_1);
            if ((v6_4.getIntent() != null) && ("android.intent.action.PROCESS_TEXT".equals(v6_4.getIntent().getAction()))) {
                android.view.MenuItem v6_8 = new Object[1];
                v6_8[0] = Integer.valueOf(v3_1);
                v2_9.invoke(p9, v6_8);
            }
            v3_1--;
        }
        java.util.List v0_2 = this.getSupportedActivities(v0_1, v1);
        int v2_10 = 0;
        while (v2_10 < v0_2.size()) {
            android.view.MenuItem v3_4 = ((android.content.pm.ResolveInfo) v0_2.get(v2_10));
            p9.add(0, 0, (v2_10 + 100), v3_4.loadLabel(v1)).setIntent(this.createProcessTextIntentForResolveInfo(v3_4, this.mTextView)).setShowAsAction(1);
            v2_10++;
        }
        return;
    }

Method android.support.v4.widget.PopupWindowCompat.setWindowLayoutType() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method android.support.v4.view.ViewConfigurationCompat.getLegacyScrollFactor() calling method java.lang.reflect.Method.invoke()


    private static float getLegacyScrollFactor(android.view.ViewConfiguration p3, android.content.Context p4)
    {
        if (android.os.Build$VERSION.SDK_INT >= 25) {
            String v0_4 = android.support.v4.view.ViewConfigurationCompat.sGetScaledScrollFactorMethod;
            if (v0_4 != null) {
                try {
                    Object[] v1_3 = new Object[0];
                    return ((float) ((Integer) v0_4.invoke(p3, v1_3)).intValue());
                } catch (Exception) {
                    android.util.Log.i("ViewConfigCompat", "Could not find method getScaledScrollFactor() on ViewConfiguration");
                }
            }
        }
        String v3_5 = new android.util.TypedValue();
        if (!p4.getTheme().resolveAttribute(16842829, v3_5, 1)) {
            return 0;
        } else {
            return v3_5.getDimension(p4.getResources().getDisplayMetrics());
        }
    }

Method android.support.v4.view.KeyEventDispatcher.actionBarOnMenuKeyEventPre28() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method android.support.v4.text.ICUCompat.maximizeAndGetScript() calling method java.lang.reflect.Method.invoke()


    public static String maximizeAndGetScript(java.util.Locale p4)
    {
        if (android.os.Build$VERSION.SDK_INT < 21) {
            String v4_4 = android.support.v4.text.ICUCompat.addLikelySubtags(p4);
            if (v4_4 == null) {
                return 0;
            } else {
                return android.support.v4.text.ICUCompat.getScript(v4_4);
            }
        } else {
            try {
                IllegalAccessException v1_2 = new Object[1];
                v1_2[0] = p4;
                String v4_2 = ((java.util.Locale) android.support.v4.text.ICUCompat.sAddLikelySubtagsMethod.invoke(0, v1_2)).getScript();
                return v4_2;
            } catch (IllegalAccessException v1_6) {
                android.util.Log.w("ICUCompat", v1_6);
                return v4_2.getScript();
            } catch (IllegalAccessException v1_5) {
                android.util.Log.w("ICUCompat", v1_5);
                return v4_2.getScript();
            }
        }
    }

Method android.support.v4.text.ICUCompat.getScript() calling method java.lang.reflect.Method.invoke()


    private static String getScript(String p4)
    {
        try {
            if (android.support.v4.text.ICUCompat.sGetScriptMethod != null) {
                Object[] v2_0 = new Object[1];
                v2_0[0] = p4;
                return ((String) android.support.v4.text.ICUCompat.sGetScriptMethod.invoke(0, v2_0));
            }
        } catch (String v4_5) {
            android.util.Log.w("ICUCompat", v4_5);
        } catch (String v4_4) {
            android.util.Log.w("ICUCompat", v4_4);
        }
        return 0;
    }

Method android.support.v4.text.ICUCompat.addLikelySubtags() calling method java.lang.reflect.Method.invoke()


    private static String addLikelySubtags(java.util.Locale p4)
    {
        String v4_1 = p4.toString();
        try {
            if (android.support.v4.text.ICUCompat.sAddLikelySubtagsMethod != null) {
                String v1_1 = new Object[1];
                v1_1[0] = v4_1;
                return ((String) android.support.v4.text.ICUCompat.sAddLikelySubtagsMethod.invoke(0, v1_1));
            }
        } catch (String v1_6) {
            android.util.Log.w("ICUCompat", v1_6);
        } catch (String v1_5) {
            android.util.Log.w("ICUCompat", v1_5);
        }
        return v4_1;
    }

Method android.support.v4.preference.PreferenceManagerCompat.setPreferences() calling method java.lang.reflect.Method.invoke()


    static boolean setPreferences(android.preference.PreferenceManager p6, android.preference.PreferenceScreen p7)
    {
        try {
            Class[] v4 = new Class[1];
            v4[0] = android.preference.PreferenceScreen;
            String v1_2 = android.preference.PreferenceManager.getDeclaredMethod("setPreferences", v4);
            v1_2.setAccessible(1);
            Object[] v2_0 = new Object[1];
            v2_0[0] = p7;
            return ((Boolean) v1_2.invoke(p6, v2_0)).booleanValue();
        } catch (Exception v6_4) {
            android.util.Log.w(android.support.v4.preference.PreferenceManagerCompat.TAG, "Couldn\'t call PreferenceManager.setPreferences by reflection", v6_4);
            return 0;
        }
    }

Method android.support.v4.preference.PreferenceManagerCompat.inflateFromResource() calling method java.lang.reflect.Method.invoke()


    static android.preference.PreferenceScreen inflateFromResource(android.preference.PreferenceManager p8, android.app.Activity p9, int p10, android.preference.PreferenceScreen p11)
    {
        try {
            Class[] v3 = new Class[3];
            v3[0] = android.content.Context;
            v3[1] = Integer.TYPE;
            v3[2] = android.preference.PreferenceScreen;
            reflect.Method v0_1 = android.preference.PreferenceManager.getDeclaredMethod("inflateFromResource", v3);
            v0_1.setAccessible(1);
            Object[] v1_1 = new Object[3];
            v1_1[0] = p9;
            v1_1[1] = Integer.valueOf(p10);
            v1_1[2] = p11;
            return ((android.preference.PreferenceScreen) v0_1.invoke(p8, v1_1));
        } catch (int v8_3) {
            android.util.Log.w(android.support.v4.preference.PreferenceManagerCompat.TAG, "Couldn\'t call PreferenceManager.inflateFromResource by reflection", v8_3);
            return 0;
        }
    }

Method android.support.v4.preference.PreferenceManagerCompat.inflateFromIntent() calling method java.lang.reflect.Method.invoke()


    static android.preference.PreferenceScreen inflateFromIntent(android.preference.PreferenceManager p7, android.content.Intent p8, android.preference.PreferenceScreen p9)
    {
        try {
            Class[] v3 = new Class[2];
            v3[0] = android.content.Intent;
            v3[1] = android.preference.PreferenceScreen;
            reflect.Method v0_1 = android.preference.PreferenceManager.getDeclaredMethod("inflateFromIntent", v3);
            v0_1.setAccessible(1);
            Object[] v1_1 = new Object[2];
            v1_1[0] = p8;
            v1_1[1] = p9;
            return ((android.preference.PreferenceScreen) v0_1.invoke(p7, v1_1));
        } catch (int v7_3) {
            android.util.Log.w(android.support.v4.preference.PreferenceManagerCompat.TAG, "Couldn\'t call PreferenceManager.inflateFromIntent by reflection", v7_3);
            return 0;
        }
    }

Method android.support.v4.preference.PreferenceManagerCompat.getPreferenceScreen() calling method java.lang.reflect.Method.invoke()


    static android.preference.PreferenceScreen getPreferenceScreen(android.preference.PreferenceManager p4)
    {
        try {
            Class[] v3 = new Class[0];
            String v0_2 = android.preference.PreferenceManager.getDeclaredMethod("getPreferenceScreen", v3);
            v0_2.setAccessible(1);
            String v1_3 = new Object[0];
            return ((android.preference.PreferenceScreen) v0_2.invoke(p4, v1_3));
        } catch (int v4_3) {
            android.util.Log.w(android.support.v4.preference.PreferenceManagerCompat.TAG, "Couldn\'t call PreferenceManager.getPreferenceScreen by reflection", v4_3);
            return 0;
        }
    }

Method android.support.v4.preference.PreferenceManagerCompat.dispatchActivityStop() calling method java.lang.reflect.Method.invoke()


    static void dispatchActivityStop(android.preference.PreferenceManager p4)
    {
        try {
            Class[] v3 = new Class[0];
            String v0_2 = android.preference.PreferenceManager.getDeclaredMethod("dispatchActivityStop", v3);
            v0_2.setAccessible(1);
            String v1_3 = new Object[0];
            v0_2.invoke(p4, v1_3);
        } catch (Exception v4_1) {
            android.util.Log.w(android.support.v4.preference.PreferenceManagerCompat.TAG, "Couldn\'t call PreferenceManager.dispatchActivityStop by reflection", v4_1);
        }
        return;
    }

Method android.support.v4.preference.PreferenceManagerCompat.dispatchActivityResult() calling method java.lang.reflect.Method.invoke()


    static void dispatchActivityResult(android.preference.PreferenceManager p8, int p9, int p10, android.content.Intent p11)
    {
        try {
            Class[] v3 = new Class[3];
            v3[0] = Integer.TYPE;
            v3[1] = Integer.TYPE;
            v3[2] = android.content.Intent;
            reflect.Method v0_1 = android.preference.PreferenceManager.getDeclaredMethod("dispatchActivityResult", v3);
            v0_1.setAccessible(1);
            Object[] v1_1 = new Object[3];
            v1_1[0] = Integer.valueOf(p9);
            v1_1[1] = Integer.valueOf(p10);
            v1_1[2] = p11;
            v0_1.invoke(p8, v1_1);
        } catch (Exception v8_1) {
            android.util.Log.w(android.support.v4.preference.PreferenceManagerCompat.TAG, "Couldn\'t call PreferenceManager.dispatchActivityResult by reflection", v8_1);
        }
        return;
    }

Method android.support.v4.preference.PreferenceManagerCompat.dispatchActivityDestroy() calling method java.lang.reflect.Method.invoke()


    static void dispatchActivityDestroy(android.preference.PreferenceManager p4)
    {
        try {
            Class[] v3 = new Class[0];
            String v0_2 = android.preference.PreferenceManager.getDeclaredMethod("dispatchActivityDestroy", v3);
            v0_2.setAccessible(1);
            String v1_3 = new Object[0];
            v0_2.invoke(p4, v1_3);
        } catch (Exception v4_1) {
            android.util.Log.w(android.support.v4.preference.PreferenceManagerCompat.TAG, "Couldn\'t call PreferenceManager.dispatchActivityDestroy by reflection", v4_1);
        }
        return;
    }

Method android.support.v4.graphics.drawable.DrawableCompat.setLayoutDirection() calling method java.lang.reflect.Method.invoke()


    public static boolean setLayoutDirection(android.graphics.drawable.Drawable p6, int p7)
    {
        reflect.Method v0_0 = android.os.Build$VERSION.SDK_INT;
        if (v0_0 < 23) {
            if (v0_0 >= 17) {
                if (!android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethodFetched) {
                    try {
                        Object[] v4_0 = new Class[1];
                        v4_0[0] = Integer.TYPE;
                    } catch (reflect.Method v0_4) {
                        android.util.Log.i("DrawableCompat", "Failed to retrieve setLayoutDirection(int) method", v0_4);
                        android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethodFetched = 1;
                    }
                    android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethod = android.graphics.drawable.Drawable.getDeclaredMethod("setLayoutDirection", v4_0);
                    android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethod.setAccessible(1);
                }
                reflect.Method v0_5 = android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethod;
                if (v0_5 != null) {
                    try {
                        Object[] v4_2 = new Object[1];
                        v4_2[0] = Integer.valueOf(p7);
                        v0_5.invoke(p6, v4_2);
                        return 1;
                    } catch (int v6_1) {
                        android.util.Log.i("DrawableCompat", "Failed to invoke setLayoutDirection(int) via reflection", v6_1);
                        android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethod = 0;
                    }
                }
            }
            return 0;
        } else {
            return p6.setLayoutDirection(p7);
        }
    }

Method android.support.v4.graphics.drawable.DrawableCompat.getLayoutDirection() calling method java.lang.reflect.Method.invoke()


    public static int getLayoutDirection(android.graphics.drawable.Drawable p6)
    {
        String v0_0 = android.os.Build$VERSION.SDK_INT;
        if (v0_0 < 23) {
            if (v0_0 >= 17) {
                if (!android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethodFetched) {
                    try {
                        String v4_0 = new Class[0];
                    } catch (reflect.Method v3_3) {
                        android.util.Log.i("DrawableCompat", "Failed to retrieve getLayoutDirection() method", v3_3);
                        android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethodFetched = 1;
                    }
                    android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethod = android.graphics.drawable.Drawable.getDeclaredMethod("getLayoutDirection", v4_0);
                    android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethod.setAccessible(1);
                }
                String v0_1 = android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethod;
                if (v0_1 != null) {
                    try {
                        reflect.Method v3_4 = new Object[0];
                        return ((Integer) v0_1.invoke(p6, v3_4)).intValue();
                    } catch (int v6_4) {
                        android.util.Log.i("DrawableCompat", "Failed to invoke getLayoutDirection() via reflection", v6_4);
                        android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethod = 0;
                    }
                }
            }
            return 0;
        } else {
            return p6.getLayoutDirection();
        }
    }

Method android.support.v4.app.NotificationManagerCompat.areNotificationsEnabled() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method android.support.v4.app.BundleCompat$BundleCompatBaseImpl.putBinder() calling method java.lang.reflect.Method.invoke()


    public static void putBinder(android.os.Bundle p8, String p9, android.os.IBinder p10)
    {
        if (!android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethodFetched) {
            try {
                Class[] v6 = new Class[2];
                v6[0] = String;
                v6[1] = android.os.IBinder;
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod = android.os.Bundle.getMethod("putIBinder", v6);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod.setAccessible(1);
            } catch (NoSuchMethodException v0_3) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to retrieve putIBinder method", v0_3);
            }
            android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethodFetched = 1;
        }
        NoSuchMethodException v0_4 = android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod;
        if (v0_4 != null) {
            try {
                Object[] v3_0 = new Object[2];
                v3_0[0] = p9;
                v3_0[1] = p10;
                v0_4.invoke(p8, v3_0);
            } catch (int v8_1) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to invoke putIBinder via reflection", v8_1);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod = 0;
            } catch (int v8_1) {
            } catch (int v8_1) {
            }
        }
        return;
    }

Method android.support.v4.app.BundleCompat$BundleCompatBaseImpl.getBinder() calling method java.lang.reflect.Method.invoke()


    public static android.os.IBinder getBinder(android.os.Bundle p7, String p8)
    {
        if (!android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethodFetched) {
            try {
                Class[] v5 = new Class[1];
                v5[0] = String;
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod = android.os.Bundle.getMethod("getIBinder", v5);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod.setAccessible(1);
            } catch (NoSuchMethodException v0_3) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to retrieve getIBinder method", v0_3);
            }
            android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethodFetched = 1;
        }
        NoSuchMethodException v0_4 = android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod;
        if (v0_4 != null) {
            try {
                Object[] v3_0 = new Object[1];
                v3_0[0] = p8;
                return ((android.os.IBinder) v0_4.invoke(p7, v3_0));
            } catch (IllegalArgumentException v7_3) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to invoke getIBinder via reflection", v7_3);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod = 0;
            } catch (IllegalArgumentException v7_3) {
            } catch (IllegalArgumentException v7_3) {
            }
        }
        return 0;
    }

Method android.support.transition.ViewGroupUtilsApi18.suppressLayout() calling method java.lang.reflect.Method.invoke()


    static void suppressLayout(android.view.ViewGroup p4, boolean p5)
    {
        android.support.transition.ViewGroupUtilsApi18.fetchSuppressLayoutMethod();
        reflect.Method v1 = android.support.transition.ViewGroupUtilsApi18.sSuppressLayoutMethod;
        if (v1 != null) {
            try {
                Object[] v2_1 = new Object[1];
                v2_1[0] = Boolean.valueOf(p5);
                v1.invoke(p4, v2_1);
            } catch (reflect.InvocationTargetException v4_2) {
                android.util.Log.i("ViewUtilsApi18", "Failed to invoke suppressLayout method", v4_2);
            } catch (reflect.InvocationTargetException v4_1) {
                android.util.Log.i("ViewUtilsApi18", "Error invoking suppressLayout method", v4_1);
            }
        }
        return;
    }

Method android.support.transition.ViewGroupUtilsApi14.cancelLayoutTransition() calling method java.lang.reflect.Method.invoke()


    private static void cancelLayoutTransition(android.animation.LayoutTransition p7)
    {
        if (!android.support.transition.ViewGroupUtilsApi14.sCancelMethodFetched) {
            try {
                Class[] v6 = new Class[0];
                android.support.transition.ViewGroupUtilsApi14.sCancelMethod = android.animation.LayoutTransition.getDeclaredMethod("cancel", v6);
                android.support.transition.ViewGroupUtilsApi14.sCancelMethod.setAccessible(1);
            } catch (NoSuchMethodException) {
                android.util.Log.i("ViewGroupUtilsApi14", "Failed to access cancel method by reflection");
            }
            android.support.transition.ViewGroupUtilsApi14.sCancelMethodFetched = 1;
        }
        reflect.Method v0_1 = android.support.transition.ViewGroupUtilsApi14.sCancelMethod;
        if (v0_1 != null) {
            try {
                Object[] v2_0 = new Object[0];
                v0_1.invoke(p7, v2_0);
            } catch (IllegalAccessException) {
                android.util.Log.i("ViewGroupUtilsApi14", "Failed to access cancel method by reflection");
            } catch (reflect.InvocationTargetException) {
                android.util.Log.i("ViewGroupUtilsApi14", "Failed to invoke cancel method by reflection");
            }
        }
        return;
    }

Method android.arch.lifecycle.ClassesInfoCache$MethodReference.invokeCallback() calling method java.lang.reflect.Method.invoke()


    void invokeCallback(android.arch.lifecycle.LifecycleOwner p5, android.arch.lifecycle.Lifecycle$Event p6, Object p7)
    {
        try {
            reflect.Method v0_0 = this.mCallType;
        } catch (reflect.Method v5_2) {
            throw new RuntimeException("Failed to call observer method", v5_2.getCause());
        } catch (reflect.Method v5_1) {
            throw new RuntimeException(v5_1);
        }
        if (v0_0 == null) {
            reflect.Method v6_5 = new Object[0];
            this.mMethod.invoke(p7, v6_5);
        } else {
            if (v0_0 == 1) {
                reflect.Method v6_6 = this.mMethod;
                reflect.Method v0_2 = new Object[1];
                v0_2[0] = p5;
                v6_6.invoke(p7, v0_2);
            } else {
                if (v0_0 == 2) {
                    reflect.Method v0_1 = this.mMethod;
                    Object[] v3_1 = new Object[2];
                    v3_1[0] = p5;
                    v3_1[1] = p6;
                    v0_1.invoke(p7, v3_1);
                } else {
                }
            }
        }
        return;
    }