Android 从活动调用片段中的方法时，菜单项为null

我的应用程序在纵向模式下使用

ViewPager

，在横向模式下使用双片段布局

我正在尝试启动一个

异步任务

，它位于

片段

，来自

活动

。

异步任务

通常从

操作栏

中的菜单项启动，但我需要从

活动

以编程方式启动它

菜单项是一个

ImageView

，我正在运行

AsyncTask

时对其进行动画设置。我的代码在双片段横向视图中运行良好，但在纵向模式下，菜单项上会出现

NullPointerException

活动

public class Main extends SherlockFragmentActivity
{
    private static List<Integer> mIds;
    private static SparseArray<Fragment> mPageReferenceMap = new SparseArray<Fragment>();

    @Override
    public void onCreate(final Bundle icicle)
    {    
        super.onCreate(icicle);

        setContentView(R.layout.main);

        mViewPager = (ViewPager)findViewById(R.id.viewpager); //view pager exists, so we are using the portait layout

        if (mViewPager != null)
        {
            mIds = new ArrayList<Integer>();

            mIds.add(0);
            mIds.add(1);
            mIds.add(2);

        }
        else //in landscape
        {           
            ListFragment lf = (ListFragment)getSupportFragmentManager().findFragmentById(R.id.fragmentList);

            if (lf == null)
                lf = new ListFragment();

            DetailFragment df = (DetailFragment)getSupportFragmentManager().findFragmentById(R.id.fragmentDetail);

            if (df == null)
            {
                df = new DetailFragment();
                df.setArguments(getIntent().getExtras());   
            }

            getSupportFragmentManager().beginTransaction().add(R.id.fragmentList, lf).commit();
            getSupportFragmentManager().beginTransaction().add(R.id.fragmentDetail, df).commit();

        }

        final MyFragmentPagerAdapter fpa = (MyFragmentPagerAdapter)mViewPager.getAdapter();
        ListFragment lf2 = (ListFragment)fpa.getFragment(0);

        //this works if I use:
        //(ListFragment)getSupportFragmentManager().findFragmentById(R.id.fragmentList);

        lf2.RunTask();
    }       

    private static class MyFragmentPagerAdapter extends FragmentStatePagerAdapter  {  

        public MyFragmentPagerAdapter(FragmentManager fm) {  
             super(fm);  
        }  

        @Override  
        public Fragment getItem(int index) {        
            if (index == 0)
            {
                ListFragment lf = ListFragment.newInstance();
                mPageReferenceMap.put(index, lf);
                return lf;
            }
            else
            {
                DetailFragment df = DetailFragment.newInstance(mIds.get(index-1));
                mPageReferenceMap.put(index, df);
                return df;
        }  

        public Fragment getFragment(int key) {
            return mPageReferenceMap.get(key);
        }

        public void destroyItem(View container, int position, Object object) {
            super.destroyItem(container, position, object);
            mPageReferenceMap.remove(position);
        }

        @Override
        public int getCount() {  
             return 4;
        }
   }  
}

public类主扩展SherlockFragmentActivity
{
私有静态列表MID；
私有静态SparseArray mPageReferenceMap=新SparseArray（）；
@凌驾
创建后的公共空间（最终捆绑冰柱）
{    
超级冰柱；
setContentView（R.layout.main）；
mViewPager=（ViewPager）findViewById（R.id.ViewPager）；//视图页面存在，因此我们使用的是portait布局
如果（mViewPager！=null）
{
mIds=新的阵列列表（）；
中加（0）；
中加（1）；
中加（2）；
}
景观设计
{           
ListFragment lf=（ListFragment）getSupportFragmentManager（）.findFragmentById（R.id.fragmentList）；
如果（lf==null）
lf=新的ListFragment（）；
DetailFragment df=（DetailFragment）getSupportFragmentManager（）.findFragmentById（R.id.fragmentDetail）；
如果（df==null）
{
df=新的DetailFragment（）；
setArguments（getIntent（）.getExtras（））；
}
getSupportFragmentManager（）.beginTransaction（）.add（R.id.fragmentList，lf.commit（）；
getSupportFragmentManager（）.beginTransaction（）.add（R.id.fragmentDetail，df.commit（）；
}
最终MyFragmentPagerAdapter fpa=（MyFragmentPagerAdapter）mviewPage.getAdapter（）；
ListFragment lf2=（ListFragment）fpa.getFragment（0）；
//如果我使用：
//（ListFragment）getSupportFragmentManager（）.findFragmentById（R.id.fragmentList）；
lf2.RunTask（）；
}       
私有静态类MyFragmentPagerAdapter扩展了FragmentStatePagerAdapter{
公共MyFragmentPagerAdapter（FragmentManager fm）{
超级（fm）；
}  
@凌驾
公共片段getItem（int索引）{
如果（索引==0）
{
ListFragment lf=ListFragment.newInstance（）；
mPageReferenceMap.put（索引，lf）；
返回lf；
}
其他的
{
DetailFragment df=DetailFragment.newInstance（mIds.get（index-1））；
mPageReferenceMap.put（索引，df）；
返回df；
}  
公共片段getFragment（int键）{
返回mPageReferenceMap.get（key）；
}
公共项（视图容器、int位置、对象）{
超级项目（容器、位置、对象）；
mPageReferenceMap.移除（位置）；
}
@凌驾
public int getCount（）{
返回4；
}
}  
}

片段

public class ListingFragment extends SherlockListFragment
{
    private MenuItem refreshItem;

    public static ListingFragment newInstance() {

        ListingFragment lf = new ListingFragment();

        return lf;
    }

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setHasOptionsMenu(true);
    }   

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {

        return inflater.inflate(R.layout.listing_layout, container, false);
    }

    private void StartAnimation() {
       final LayoutInflater inflater = (LayoutInflater)getActivity().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
       final ImageView ivRefresh = (ImageView)inflater.inflate(R.layout.refresh_view, null);

       final Animation rotation = AnimationUtils.loadAnimation(getActivity(), R.anim.refresh);
       ivRefresh.startAnimation(rotation);

        //this is null
       refreshItem.setActionView(ivRefresh);
    }

    public void StopAnimation()
    {
        if (refreshItem != null && refreshItem.getActionView() != null) 
        {
            refreshItem.getActionView().clearAnimation();
            refreshItem.setActionView(null);
        }
    }

    public void RunTask()
    {
        new GetItems().execute();
    }

    private class GetItems extends AsyncTask<Void, Void, Void> 
    {
        @Override
        protected void onPreExecute() 
        {
          StartAnimation();
        }

        @Override
        protected Void doInBackground(Void... unused)
        {
            ...
        }

        protected void onPostExecute(final Void unused)
        {
            StopAnimation();
        }
    }

    @Override
    public void onCreateOptionsMenu(final Menu menu, final MenuInflater inflater) {
        inflater.inflate(R.menu.keyword_menu, menu);

        refreshItem = menu.findItem(R.id.get);

        super.onCreateOptionsMenu(menu, inflater);
    }

    @Override
    public boolean onOptionsItemSelected(final MenuItem item) 
    {
        if (item.getItemId() == R.id.get) {
            gi = new GetItems(getActivity(), null);
            gi.execute();
            return true;
        } else {
            return super.onOptionsItemSelected(item);
        }
    }
}   

公共类ListingFragment扩展了SherlockListFragment
{
私有菜单项；
公共静态ListingFragment newInstance（）{
ListingFragment lf=新ListingFragment（）；
返回lf；
}
@凌驾
创建时的公共void（Bundle savedInstanceState）
{
super.onCreate（savedInstanceState）；
设置选项菜单（真）；
}   
@凌驾
CreateView上的公共视图（布局、充气机、视图组容器、捆绑包保存状态）{
返回充气机。充气（R.layout.u布局，容器，假）；
}
私有void StartAnimation（）{
最终LayoutFlater充气器=（LayoutFlater）getActivity（）.getSystemService（Context.LAYOUT\u充气器\u服务）；
最终ImageView ivRefresh=（ImageView）充气器。充气（R.layout.refresh\u视图，空）；
最终动画旋转=AnimationUtils.loadAnimation（getActivity（），R.anim.refresh）；
iv.启动（旋转）；
//这是空的
refreshItem.setActionView（ivRefresh）；
}
公共void StopAnimation（）
{
if（refreshItem！=null&&refreshItem.getActionView（）！=null）
{
refreshItem.getActionView（）.clearAnimation（）；
refreshItem.setActionView（空）；
}
}
public void RunTask（）
{
新建GetItems（）.execute（）；
}
私有类GetItems扩展异步任务
{
@凌驾
受保护的void onPreExecute（）
{
StartAnimation（）；
}
@凌驾
受保护的空位背景（空位…未使用）
{
...
}
后期执行时受保护的无效（最终无效未使用）
{
停止动画（）；
}
}
@凌驾
创建选项菜单（最终菜单菜单，最终菜单充气机）{
充气机。充气（右菜单。关键字菜单，菜单）；
refreshItem=menu.findItem（R.id.get）；
super.onCreateOptions菜单（菜单，充气机）；
}
@凌驾
公共布尔值OnOptionItemSelected（最终菜单项）
{
if（item.getItemId（）==R.id.get）{
gi=新的GetItems（getActivity（），null）；
gi.execute（）；
返回true；
}否则{
返回super.onOptionsItemSelected（项目）；
}
}
}   

我认为以下链接为您提供了如何避免空指针异常的答案。 Fragment的实例可以随时由系统重新创建，这就是为什么“保存对它们的引用”并不容易的原因