6

我有一个使用 ICS 操作栏上的选项卡的应用程序，其中每个选项卡内部都有一个片段。在某些情况下，在我按下操作栏上的选项菜单上的按钮，然后旋转设备后，我会收到 NullPointerException。我可以使用相同的步骤可靠地重现它，但是在某些情况下（例如，如果我不按操作栏上的任何按钮）不会产生异常。该异常似乎没有引用我的代码中的任何行，并且在方向更改后重新创建活动期间发生。

这是一个例外：

09-18 20:56:22.357: E/AndroidRuntime(689): FATAL EXCEPTION: main
09-18 20:56:22.357: E/AndroidRuntime(689): java.lang.RuntimeException: Unable to start activity ComponentInfo{com.andavapps.flightbot/com.andavapps.flightbot.FlightBotActivity}: java.lang.NullPointerException
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:1956)
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:1981)
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.app.ActivityThread.handleRelaunchActivity(ActivityThread.java:3351)
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.app.ActivityThread.access$700(ActivityThread.java:123)
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1151)
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.os.Handler.dispatchMessage(Handler.java:99)
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.os.Looper.loop(Looper.java:137)
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.app.ActivityThread.main(ActivityThread.java:4424)
09-18 20:56:22.357: E/AndroidRuntime(689):     at java.lang.reflect.Method.invokeNative(Native Method)
09-18 20:56:22.357: E/AndroidRuntime(689):     at java.lang.reflect.Method.invoke(Method.java:511)
09-18 20:56:22.357: E/AndroidRuntime(689):     at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:784)
09-18 20:56:22.357: E/AndroidRuntime(689):     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:551)
09-18 20:56:22.357: E/AndroidRuntime(689):     at dalvik.system.NativeStart.main(Native Method)
09-18 20:56:22.357: E/AndroidRuntime(689): Caused by: java.lang.NullPointerException
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.app.FragmentManagerImpl.dispatchCreateOptionsMenu(FragmentManager.java:1831)
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.app.Activity.onCreatePanelMenu(Activity.java:2445)
09-18 20:56:22.357: E/AndroidRuntime(689):     at com.android.internal.policy.impl.PhoneWindow.preparePanel(PhoneWindow.java:388)
09-18 20:56:22.357: E/AndroidRuntime(689):     at com.android.internal.policy.impl.PhoneWindow.invalidatePanelMenu(PhoneWindow.java:739)
09-18 20:56:22.357: E/AndroidRuntime(689):     at com.android.internal.policy.impl.PhoneWindow.restorePanelState(PhoneWindow.java:1664)
09-18 20:56:22.357: E/AndroidRuntime(689):     at com.android.internal.policy.impl.PhoneWindow.restoreHierarchyState(PhoneWindow.java:1619)
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.app.Activity.onRestoreInstanceState(Activity.java:906)
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.app.Activity.performRestoreInstanceState(Activity.java:878)
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.app.Instrumentation.callActivityOnRestoreInstanceState(Instrumentation.java:1100)
09-18 20:56:22.357: E/AndroidRuntime(689):     at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:1934)
09-18 20:56:22.357: E/AndroidRuntime(689):     ... 12 more

这是我的活动代码（为了简单起见，删除了一些不相关的代码）

public class MyActivity extends Activity {

    private class MyTabListener<C extends MyFragment> implements ActionBar.TabListener {

        private Activity activity;
        private MyFragment fragmentMain;
        private MyFragment fragmentSide;
        private Class<C> cls;

        public MyTabListener(Activity a, Class<C> c) {
            activity = a;
            cls = c;
        }

        @Override
        public void onTabReselected(Tab tab, FragmentTransaction ft) { }

        @Override
        public void onTabSelected(Tab tab, FragmentTransaction ft) {
            if (sidebar) {
                if (fragmentSide == null) {
                    fragmentSide = (MyFragment) Fragment.instantiate(activity, cls.getName());
                    ft.add(c.SIDE_FRAME, fragmentSide, fragmentSide.getViewTag());
                } else
                    ft.attach(fragmentSide);
            } else {
                if (fragmentMain == null) {
                    fragmentMain = (MyFragment) Fragment.instantiate(activity, cls.getName());
                    ft.add(c.MAIN_FRAME, fragmentMain, fragmentMain.getViewTag());
                } else
                    ft.attach(fragmentMain);
            }
            selected = tabs.indexOf(tab);
            mainUp = false;
            if (setUpComplete)
                invalidateOptionsMenu();
        }

        @Override
        public void onTabUnselected(Tab tab, FragmentTransaction ft) {
            if (fragmentSide != null && !fragmentSide.isDetached())
                ft.detach(fragmentSide);
            if (fragmentMain != null && !fragmentMain.isDetached())
                ft.detach(fragmentMain);
        }

    }

    private class MyMainTabListener<C extends MyFragment> implements ActionBar.TabListener {

        private Activity activity;
        private MyFragment fragmentMain;
        private Class<C> cls;

        public MyMainTabListener(Activity a, Class<C> c) {
            activity = a;
            cls = c;
        }

        @Override
        public void onTabReselected(Tab tab, FragmentTransaction ft) { }

        @Override
        public void onTabSelected(Tab tab, FragmentTransaction ft) {
            if (fragmentMain == null) {
                fragmentMain = (MyFragment) Fragment.instantiate(activity, cls.getName());
                ft.add(c.MAIN_FRAME, fragmentMain, fragmentMain.getViewTag());
            } else if (fragmentMain.isDetached())
                ft.attach(fragmentMain);
            mainUp = !sidebar;
            if (setUpComplete)
                invalidateOptionsMenu();
        }

        @Override
        public void onTabUnselected(Tab tab, FragmentTransaction ft) {
            if (!sidebar && fragmentMain != null && !fragmentMain.isDetached())
                ft.detach(fragmentMain);
            else if (sidebar && (fragmentMain == null || fragmentMain.isDetached())) {
                if (fragmentMain == null) {
                    fragmentMain = (MyFragment) Fragment.instantiate(activity, cls.getName());
                    ft.add(c.MAIN_FRAME, fragmentMain, fragmentMain.getViewTag());
                } else if (fragmentMain.isDetached())
                    ft.attach(fragmentMain);
            }
        }

    }

    private static final class c {
        //A bunch of constants are defined here
    }

    private ArrayList<ActionBar.Tab> tabs = new ArrayList<ActionBar.Tab>();

    private int side;
    private int orient;
    private int selected;
    private boolean sidebar;
    private boolean mainUp;
    private boolean lock;
    private boolean setUpComplete = false;

    @Override
    public void onCreate(Bundle inState) {
        super.onCreate(inState);
        setContentView(R.layout.main_rel);

        orient = detectOrientation();

        if (inState != null) {
            selected = inState.getInt("selected", 1);
            side = inState.getInt("side", c.LEFT_SIDE);
            sidebar = inState.getBoolean("visible", true);
            mainUp = inState.getBoolean("mainup", !sidebar);
            lock = inState.getBoolean("lock", false);
        } else {
            selected = 1;
            side = c.LEFT_SIDE;
            sidebar = true;
            mainUp = false;
            lock = false;
        }

        ActionBar ab = getActionBar();
        ab.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);

        tabs.add(ab.newTab().setText(MainFragment.getTabText()).setTabListener(new MyMainTabListener<MainFragment>(this, MainFragment.class)));
        tabs.add(ab.newTab().setText(OtherFragment.getTabText()).setTabListener(new MyTabListener<OtherFragment>(this, OtherFragment.class)));
        tabs.add(ab.newTab().setText(AnotherFragment.getTabText()).setTabListener(new MyTabListener<AnotherFragment>(this, AnotherFragment.class)));
        tabs.add(ab.newTab().setText(YetAnotherFragment.getTabText()).setTabListener(new MyTabListener<YetAnotherFragment>(this, YetAnotherFragment.class)));
    }

    @Override
    protected void onStart() {
        super.onStart();

        if (!setUpComplete)
            setUp();
    }

    @Override
    protected void onResume() {
        super.onResume();

        if (!setUpComplete)
            setUp();
    }

    @Override
    protected void onPause() {
        super.onPause();
    }

    @Override
    protected void onStop() {
        super.onStop();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        setUpComplete = false;
        getActionBar().removeAllTabs();

        super.onSaveInstanceState(outState);
        outState.putInt("selected", selected);
        outState.putInt("side", side);
        outState.putBoolean("visible", sidebar);
        outState.putBoolean("mainup", mainUp);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu, menu);
        return true;
    }

    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        menu.findItem(R.id.menu_showhide).setTitle(c.MENU_SHOW_TEXT[(sidebar ? 1 : 0)]).setIcon(c.MENU_SHOW_DRAW[(sidebar ? 1 : 0)][side][orient][(mainUp ? 0 : 1)]);
        menu.findItem(R.id.menu_swapside).setTitle(c.MENU_SIDE_TEXT[side][orient]).setIcon(c.MENU_SIDE_DRAW[side][orient]);
        menu.findItem(R.id.menu_lock).setTitle(c.MENU_LOCK_TEXT[(lock ? 1 : 0)]).setIcon(c.MENU_LOCK_DRAW[(lock ? 0 : 1)]);
        if (!sidebar)
            menu.findItem(R.id.menu_swapside).setVisible(false).setEnabled(false);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.menu_swapside:
                toggleSide();
                return true;
            case R.id.menu_showhide:
                toggleVisibility();
                return true;
            case R.id.menu_lock:
                toggleRotation();
                return true;
            default:
                return super.onOptionsItemSelected(item);
        }
    }

    private int detectOrientation() {
            int o = getResources().getConfiguration().orientation;
            int r = getWindowManager().getDefaultDisplay().getRotation();

            if (o == Configuration.ORIENTATION_LANDSCAPE && (r == Surface.ROTATION_0 || r == Surface.ROTATION_90))
                return c.LAND_ORIENT;
            else if (o == Configuration.ORIENTATION_PORTRAIT && (r == Surface.ROTATION_90 || r == Surface.ROTATION_180))
                return c.RPORT_ORIENT;
            else if (o == Configuration.ORIENTATION_LANDSCAPE && (r == Surface.ROTATION_180 || r == Surface.ROTATION_270))
                return c.RLAND_ORIENT;
            else
                return c.PORT_ORIENT;
    }

    private void toggleVisibility() {
        sidebar = !sidebar;
        mainUp = !sidebar;
        invalidateOptionsMenu();
        setUpTabs();
    }

    private void toggleSide() {
        side = (side == c.RIGHT_SIDE ? c.LEFT_SIDE : c.RIGHT_SIDE);
        invalidateOptionsMenu();
        setUpSide();
    }

    private void toggleRotation() {
        lock = !lock;
        invalidateOptionsMenu();
        setUpLock();
    }

    private void setUp() {
        setUpTabs();
        setUpSide();
        setUpLock();
        setUpComplete = true;
    }

    private void setUpTabs() {
        ActionBar ab = getActionBar();
        ab.removeAllTabs();

        ab.addTab(tabs.get(0), sidebar || mainUp);
        if (sidebar)
            ab.removeTab(tabs.get(0));
        for (int i = 1; i < tabs.size(); i ++)
            ab.addTab(tabs.get(i), !mainUp && selected == i);
    }

    private void setUpSide() {
        RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT, RelativeLayout.LayoutParams.MATCH_PARENT);
        params.addRule(c.SIDE_RULE[side][orient], c.SIDE_FRAME);
        FrameLayout mf = (FrameLayout) findViewById(c.MAIN_FRAME);
        mf.setLayoutParams(params);

        params = new RelativeLayout.LayoutParams(c.LAYOUT_WIDTH[orient], c.LAYOUT_HEIGHT[orient]);
        params.addRule(c.ALIGN_RULE[side][orient]);
        FrameLayout sf = (FrameLayout) findViewById(c.SIDE_FRAME);
        sf.setLayoutParams(params);
    }

    private void setUpLock() {
        setRequestedOrientation((lock ? c.LOCK_ORIENT[orient] : ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED));
    }

}

关于我的应用程序和解释事情的代码的一些注释：

  • 该应用程序显示一个主片段和一个侧边栏片段
  • 选项菜单包含三个按钮：一个用于将侧边栏从屏幕一侧切换到另一侧，一个用于隐藏侧边栏，一个用于锁定方向
  • 主片段始终是选项卡列表中的第一个，并且始终是 MainFragment 类型
  • 我在运行 ICS（Asus Trans Prime，4.0.4；HTC Vivid，4.0.3）和模拟器（ICS 4.0.3 和 JB 4.1）的两台设备上运行它。这只发生在 ICS 上。

异常按以下顺序发生：

  • 启动应用程序
  • 按下按钮隐藏侧边栏
  • 旋转装置

如果在旋转设备之前发生任何其他事情，则不会发生异常。例如，如果侧边栏未隐藏，我不会得到异常。如果先旋转设备，则永远不会发生异常，因此即使隐藏侧边栏，再次旋转设备，我也不会收到异常。而且堆栈跟踪没有引用我的代码中的单个函数，所以我什至可以找到根本原因。

似乎这是 FragmentManager.java（android.app 包）中引发异常的函数：

1827     public boolean dispatchCreateOptionsMenu(Menu menu, MenuInflater inflater) {
1828         boolean show = false;
1829         ArrayList<Fragment> newMenus = null;
1830         if (mActive != null) {
1831             for (int i=0; i<mAdded.size(); i++) {
1832                 Fragment f = mAdded.get(i);
1833                 if (f != null && !f.mHidden && f.mHasMenu && f.mMenuVisible) {
1834                     show = true;
1835                     f.onCreateOptionsMenu(menu, inflater);
1836                     if (newMenus == null) {
1837                         newMenus = new ArrayList<Fragment>();
1838                     }
1839                     newMenus.add(f);
1840                 }
1841             }
1842         }
1843         
1844         if (mCreatedMenus != null) {
1845             for (int i=0; i<mCreatedMenus.size(); i++) {
1846                 Fragment f = mCreatedMenus.get(i);
1847                 if (newMenus == null || !newMenus.contains(f)) {
1848                     f.onDestroyOptionsMenu();
1849                 }
1850             }
1851         }
1852         
1853         mCreatedMenus = newMenus;
1854         
1855         return show;
1856     }

mAdded在尝试使用它之前没有空检查。JB 中的相同功能替换(mActive != null)为(mAdded != null). 但我不知道我可以为 ICS 做些什么来避免这种情况。

有人有什么想法吗？我已经搜索过 StackOverflow 寻找类似的问题，但到目前为止都是空的。谢谢！如果还有什么我需要发布的，请告诉我，我会添加它。

4

3 回答 3

3

我有一个使用工具栏的应用程序（基于 com.example.android.actionbarcompat 的代码），我遇到了同样的问题。在某些设备上，onCreateOptionsMenu() 不会在 onCreate() 之后被调用，这意味着操作栏未初始化，当我尝试更改图标时，应用程序崩溃了。

对我来说好消息是 onCreateOptionsMenu() 确实会在稍后调用，当它发生时，我会在 onCreateOptionsMenu() 中保留对菜单的引用。在他们对操作栏执行任何操作之前，我修改了其余的活动代码以检查此引用。这仍然执行得非常快，并且不影响用户体验。

我建议您也这样做并推迟一些初始化。

于 2012-12-16T17:39:11.203 回答
0

Fragments我在选项卡和 NPE 中轮换更改的应用程序中遇到了类似的问题。原因是有时Activity引用Fragments为空。Fragment's Activity我通过尽可能更改对应用程序上下文引用的引用以及测试 Fragments 中所有剩余的 Activity 引用是否为空来避免 NPE 问题：

if(getActivity() != null) { 
    getActivity.someMethod() 
};
于 2013-12-01T01:43:51.887 回答
0

将此添加到您的活动标签中：

android:configChanges="orientation"

并覆盖此方法：

public void onConfigurationChanged(Configuration newConfig)

您可以在以下位置找到更多信息：

http://developer.android.com/reference/android/app/Activity.html#onConfigurationChanged(android.content.res.Configuration )

http://developer.android.com/reference/android/R.attr.html#configChanges

于 2012-12-18T16:52:39.470 回答