Android BitmapFactory.decodeStream(is)返回Null android fragment回退栈

转载
mob6454cc77b8eb 2023-05-24 14:44:31
文章标签 ide 回退栈 android 文章分类 Android 移动开发
源代码参考：360云盘中---自己的学习资料---Android总结过的项目---FragmentDemo.rar

本篇将介绍上篇博客提到的：如何管理 Fragment 回退栈，Fragment 如何与 Activity 交互，Fragment 与 Activity 交互的最佳实践，没有视图的 Fragment 的用处，使用Fragment 创建对话框，如何与 ActionBar，MenuItem 集成等

一、管理 Fragment 回退栈

类似与 Android 系统为 Activity 维护一个任务栈，我们也可以通过 Activity 维护一个回退栈来保存每次 Fragment 事务发生的变化。如果你将 Fragment 任务添加到回退栈，当用户点击后退按钮时，将看到上一次的保存的 Fragment。一旦 Fragment 完全从后退栈中弹出，用户再次点击后退键，则退出当前 Activity。

看这样一个效果图

点击第一个按钮，切换到第二个界面，点击第二个按钮，切换到第三个界面，然后点击Back键依次回退。这像不像初学 Android 时的 Activity 跳转，当然了，这里肯定不是，不然我就跪了。这里是 Fragment 实现的，用户点击 Back，实际是 Fragment 回退栈不断的弹栈。
如何添加一个 Fragment 事务到回退栈：

FragmentTransaction.addToBackStack(String)

下面讲解代码：很明显一共是 3 个 Fragment 和一个 Activity.

先看 Activity 的布局文件：

<!-- Fragment 主布局 -->
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <FrameLayout
        android:id="@+id/flStackContent"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent" >
    </FrameLayout>

</RelativeLayout>

不同的 Fragment 就在这个 FrameLayout 中显示。

/**
 * Fragment 回退栈主界面
 */
public class FragmentStackActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        initControl();
    }

    /**
     * 加载控件
     */
    private void initControl() {

        setContentView(R.layout.activity_fragment_stack);

        FragmentManager tFManager = getFragmentManager();
        FragmentTransaction tFTransaction = tFManager.beginTransaction();
        tFTransaction.add(R.id.flStackContent, new FragmentOne(), "ONE");
        tFTransaction.commit();
    }
}

很简单，直接将 FragmentOne 添加到布局文件中的 FrameLayout 中，注意这里并没有调用 FragmentTransaction.addToBackStack(String)，因为我不喜欢在当前显示时，点击 Back 键出现白板。而是正确的相应 Back 键，即退出我们的 Activity.

/**
 * 第一个 Fragment
 */
public class FragmentOne extends Fragment implements OnClickListener {

    private Button mBtnStackOne;
    
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        
        View tView=inflater.inflate(R.layout.stack_fragement_one,container, false);
        
        mBtnStackOne=(Button) tView.findViewById(R.id.btnStackOne);
        mBtnStackOne.setOnClickListener(this);
        
        return tView;
    }
    
    @Override
    public void onClick(View v) {
        
        switch (v.getId()) {
        case R.id.btnStackOne:
            
            FragmentTwo tFragmentTwo=new FragmentTwo();
            FragmentManager tFragmentManager=getFragmentManager();
            FragmentTransaction tFTransaction=tFragmentManager.beginTransaction();
            tFTransaction.replace(R.id.flStackContent, tFragmentTwo,"Two");
            tFTransaction.addToBackStack(null);
            tFTransaction.commit();
            break;
        }
    }
}

我们在点击 FragmentOne 中的按钮时，使用了replace 方法，如果你看了前一篇博客，一定记得 replace 是 remove 和 add 的合体，并且如果不添加事务到回退栈，前一个 Fragment 实例会被销毁。这里很明显，我们调用 tx.addToBackStack(null); 将当前的事务添加到了回退栈，所以 FragmentOne 实例不会被销毁，但是视图层次依然会被销毁，即会调用 onDestoryView 和 onCreateView，证据就是：仔细看上面的效果图，我们在跳转前在文本框输入的内容，在用户 Back 得到第一个界面的时候不见了。

/**
 * 第二个 Fragment
 */
public class FragmentTwo extends Fragment implements OnClickListener {

    private Button mBtnStackTwo;

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

        View tView = inflater.inflate(R.layout.stack_fragement_two, container,
                false);

        mBtnStackTwo = (Button) tView.findViewById(R.id.btnStackTwo);
        mBtnStackTwo.setOnClickListener(this);

        return tView;
    }

    @Override
    public void onClick(View v) {

        switch (v.getId()) {
        case R.id.btnStackTwo:

            FragmentThree fThree = new FragmentThree();
            FragmentManager fm = getFragmentManager();
            FragmentTransaction tx = fm.beginTransaction();
            tx.hide(this);
            tx.add(R.id.flStackContent, fThree, "THREE");
            // tx.replace(R.id.id_content, fThree, "THREE");
            tx.addToBackStack(null);
            tx.commit();
            break;
        }
    }
}

这里点击时，我们没有使用 replace，而是先隐藏了当前的 Fragment，然后添加了 FragmentThree 的实例，最后将事务添加到回退栈。这样做的目的是为了给大家提供一种方案：如果不希望视图重绘该怎么做，请再次仔细看效果图，我们在 FragmentTwo 的 EditText 填写的内容，用户 Back 回来时，数据还在。

/**
 * 第三个 Fragment
 */
public class FragmentThree extends Fragment implements OnClickListener {

    private Button mBtnStackThree;

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

        View tView = inflater.inflate(R.layout.stack_fragement_three, container,
                false);

        mBtnStackThree = (Button) tView.findViewById(R.id.btnStackThree);
        mBtnStackThree.setOnClickListener(this);

        return tView;
    }

    @Override
    public void onClick(View v) {

        switch (v.getId()) {
        case R.id.btnStackThree:

            Toast.makeText(getActivity(), "i am a btn in Fragment three",
                    Toast.LENGTH_SHORT).show();
            break;
        }
    }
}

好了，经过上面的介绍，应该已经知道 Fragment 回退栈是怎么一回事了，以及 hide，replace 等各自的应用的场景。

这里极其注意一点：上面的整体代码不具有任何参考价值，纯粹为了显示回退栈，在后面讲解了 Fragment 与 Activity 通信以后，会重构上面的代码！

--------------------------------------------------------------------------------------------
二、Fragment 与 Activity 通信

因为所有的 Fragment 都是依附于 Activity 的，所以通信起来并不复杂，大概归纳为：

1.如果你 Activity 中包含自己管理的 Fragment 的引用，可以通过引用直接访问所有的 Fragment 的 public 方法

2.如果 Activity 中未保存任何 Fragment 的引用，那么没关系，每个 Fragment 都有一个唯一的TAG或者 ID,可以通过 getFragmentManager.findFragmentByTag() 或者 findFragmentById() 获得任何 Fragment 实例，然后进行操作。

3.在 Fragment 中可以通过 getActivity 得到当前绑定的 Activity 的实例，然后进行操作。

注：如果在 Fragment 中需要 Context，可以通过调用 getActivity(),如果该 Context 需要在 Activity 被销毁后还存在，则使用 getActivity().getApplicationContext()。

1.Fragment 与 Activity 通信的最佳实践

因为要考虑 Fragment 的重复使用，所以必须降低 Fragment 与 Activity 的耦合，而且 Fragment 更不应该直接操作别的 Fragment，毕竟 Fragment 操作应该由它的管理者Activity 来决定。

下面我通过两种方式的代码，分别重构，FragmentOne 和 FragmentTwo 的点击事件，以及 Activity 对点击事件的响应：

/**
 * 第一个 Fragment
 */
public class FragmentOne extends Fragment implements OnClickListener {

    private Button mBtnStackOne;

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

        View tView = inflater.inflate(R.layout.stack_fragement_one, container,
                false);

        mBtnStackOne = (Button) tView.findViewById(R.id.btnStackOne);
        mBtnStackOne.setOnClickListener(this);

        return tView;
    }

    @Override
    public void onClick(View v) {

        switch (v.getId()) {
        case R.id.btnStackOne:

            // 交给宿主Activity处理，如果它希望处理
            if (getActivity() instanceof FOneBtnClickListener) {

                ((FOneBtnClickListener) getActivity()).onFOneBtnClick();
            }
            break;
        }
    }

    /**
     * 设置按钮点击的回调
     * 
     * @author zhy
     * 
     */
    public interface FOneBtnClickListener {

        void onFOneBtnClick();
    }
}

可以看到现在的 FragmentOne 不和任何 Activity 耦合，任何 Activity 都可以使用；并且我们声明了一个接口，来回调其点击事件，想要管理其点击事件的 Activity 实现此接口就即可。可以看到我们在 onClick 中首先判断了当前绑定的 Activity 是否实现了该接口，如果实现了则调用。

/**
 * 第二个 Fragment
 */
public class FragmentTwo extends Fragment implements OnClickListener {

    private Button mBtnStackTwo;
    private FTwoBtnClickListener mFTwoBtnClickListener;

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

        View tView = inflater.inflate(R.layout.stack_fragement_two, container,
                false);

        mBtnStackTwo = (Button) tView.findViewById(R.id.btnStackTwo);
        mBtnStackTwo.setOnClickListener(this);

        return tView;
    }

    @Override
    public void onClick(View v) {

        switch (v.getId()) {
        
        case R.id.btnStackTwo:

            if (mFTwoBtnClickListener != null) {

                mFTwoBtnClickListener.onFTwoBtnClick();
            }
            break;
        }
    }

    // 设置回调接口
    public void setfTwoBtnClickListener(
            FTwoBtnClickListener fTwoBtnClickListener) {

        this.mFTwoBtnClickListener = fTwoBtnClickListener;
    }

    public interface FTwoBtnClickListener {

        void onFTwoBtnClick();
    }
}

与 FragmentOne 极其类似，但是我们提供了 setListener 这样的方法，意味着 Activity 不仅需要实现该接口，还必须显示调用 mFTwo.setfTwoBtnClickListener(this)。

/**
 * Fragment 与 Activity 通信主界面
 */
public class FragmentCommActivity extends Activity implements
        FOneBtnClickListener, FTwoBtnClickListener {

    private FragmentOne mFOne;
    private FragmentTwo mFTwo;
    private FragmentThree mFThree;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        initControl(); // 加载控件
    }

    /**
     * 加载控件
     */
    private void initControl() {

        setContentView(R.layout.activity_fragment_stack);

        mFOne = new FragmentOne();
        FragmentManager tFManager = getFragmentManager();
        FragmentTransaction tFTransaction = tFManager.beginTransaction();
        tFTransaction.add(R.id.flStackContent, mFOne, "ONE");
        tFTransaction.commit();

        mFTwo = new FragmentTwo();
        mFTwo.setfTwoBtnClickListener(this);

        mFThree = new FragmentThree();
    }

    /**
     * FragmentOne 按钮点击时的回调
     */
    @Override
    public void onFOneBtnClick() {

        FragmentManager tFManager = getFragmentManager();
        FragmentTransaction tFTransaction = tFManager.beginTransaction();
        tFTransaction.replace(R.id.flStackContent, mFTwo, "TWO");
        tFTransaction.addToBackStack(null);
        tFTransaction.commit();
    }

    /**
     * FragmentTwo 按钮点击时的回调
     */
    @Override
    public void onFTwoBtnClick() {

        FragmentManager tFManager = getFragmentManager();
        FragmentTransaction tFTransaction = tFManager.beginTransaction();
        tFTransaction.hide(mFTwo);
        tFTransaction.add(R.id.flStackContent, mFThree, "THREE");
        // tx.replace(R.id.id_content, fThree, "THREE");
        tFTransaction.addToBackStack(null);
        tFTransaction.commit();
    }
}

代码重构结束，与开始的效果一模一样。上面两种通信方式都是值得推荐的，随便选择一种自己喜欢的。这里再提一下：虽然 Fragment 和 Activity 可以通过 getActivity 与 findFragmentByTag 或者 findFragmentById，进行任何操作，甚至在 Fragment 里面操作另外的 Fragment，但是没有特殊理由是绝对不提倡的。Activity 担任的是 Fragment 间类似总线一样的角色，应当由它决定 Fragment 如何操作。另外虽然 Fragment 不能响应 Intent 打开，但是 Activity 可以，Activity 可以接收 Intent，然后根据参数判断显示哪个 Fragment。

--------------------------------------------------------------------------------------------
四、如何处理运行时配置发生变化

运行时配置发生变化，最常见的就是屏幕发生旋转，如果你不知道如何处理屏幕变化可以参考：Android 屏幕旋转 处理 AsyncTask 和 ProgressDialog 的最佳方案
这里提一下：很多人觉得强制设置屏幕的方向就可以了，但是有一点，当你的应用被至于后台（例如用户点击了home），长时间没有返回的时候，你的应用也会被重新启动。比如上例：如果你把上面的例子你至于 FragmentThree 界面，然后处于后台状态，长时间后你会发现当你再次通过 home 打开时，上面 FragmentThree 与 FragmentOne 叠加在一起，这就是因为你的 Activity 重新启动，在原来的 FragmentThree 上又绘制了一个 FragmentOne。
好了，下面看一段代码：

/**
 * 运行时配置发生变化 Test
 */
public class RunChangeActivity extends Activity {

    private FragmentOne mFOne;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        initControl(); // 加载控件
    }

    private void initControl() {

        setContentView(R.layout.activity_fragment_stack);

        mFOne = new FragmentOne();
        FragmentManager tFManager = getFragmentManager();
        FragmentTransaction tFTransaction = tFManager.beginTransaction();
        tFTransaction.add(R.id.flStackContent, mFOne, "ONE");
        tFTransaction.commit();
    }
}

/**
 * 第一个 Fragment
 */
public class FragmentOne extends Fragment {

    private static final String TAG = "@@@FragmentOne";

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

        Log.e(TAG, "onCreateView");
        View tView = inflater.inflate(R.layout.stack_fragement_one, container,
                false);

        return tView;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        Log.e(TAG, "onCreate");
    }

    @Override
    public void onDestroyView() {

        super.onDestroyView();

        Log.e(TAG, "onDestroyView");
    }

    @Override
    public void onDestroy() {

        super.onDestroy();

        Log.e(TAG, "onDestroy");
    }
}

很简单的代码，当你运行之后，不断的旋转屏幕，你会发现每旋转一次屏幕，屏幕上就多了一个 FragmentOne 的实例，并且后台 log 会打印出许多套生命周期的回调。

初次运行：

左旋转——横屏：

只要切换屏幕打印的 Log 与第二个一样。

这是为什么呢，因为当屏幕发生旋转，Activity 发生重新启动，默认的 Activity 中的 Fragment 也会跟着 Activity 重新创建；这样造成当旋转的时候，本身存在的 Fragment 会重新启动，然后当执行 Activity 的 onCreate 时，又会再次实例化一个新的 Fragment，这就是出现的原因。
那么如何解决呢：
其实通过检查 onCreate 的参数 Bundle savedInstanceState 就可以判断，当前是否发生 Activity 的重新创建：
默认的 savedInstanceState 会存储一些数据，包括 Fragment 的实例：通过打印可以看出：

所以，我们简单改一下代码，只有在savedInstanceState==null时，才进行创建Fragment实例：
/**
 * 运行时配置发生变化 Test
 */
public class RunChangeActivity extends Activity {

    private static final String TAG = "@@@RunChangeActivity";
    private FragmentOne mFOne;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Log.e(TAG, savedInstanceState + "");
        initControl(savedInstanceState); // 加载控件
    }

    private void initControl(Bundle savedInstanceState) {

        setContentView(R.layout.activity_fragment_stack);

        if (savedInstanceState == null) {

            mFOne = new FragmentOne();
            FragmentManager tFManager = getFragmentManager();
            FragmentTransaction tFTransaction = tFManager.beginTransaction();
            tFTransaction.add(R.id.flStackContent, mFOne, "ONE");
            tFTransaction.commit();
        }
    }
}

初次运行：

左旋转——横屏：

只要切换屏幕打印的 Log 与第二个一样。


现在无论进行多次旋转都只会有一个Fragment实例在Activity中。

现在还存在一个问题，就是重新绘制时，Fragment发生重建，原本的数据如何保持？

其实和 Activity 类似，Fragment 也有 onSaveInstanceState 的方法，在此方法中进行保存数据，然后在 onCreate 或者 onCreateView 或者 onActivityCreated 进行恢复都可以。

--------------------------------------------------------------------------------------------
五、Fragmeny 与 ActionBar 和 MenuItem 集成

一、Fragment 可以添加自己的 MenuItem 到 Activity 的 ActionBar 或者可选菜单中。

1、在 Fragment 的 onCreate 中调用 setHasOptionsMenu(true);

2、然后在 Fragment 子类中实现 onCreateOptionsMenu

3、如果希望在 Fragment 中处理 MenuItem 的点击，也可以实现 onOptionsItemSelected；当然了 Activity 也可以直接处理该 MenuItem 的点击事件。

二、代码

/**
 * 第一个 Fragment
 */
public class FragmentOne extends Fragment {

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

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

        View tView = inflater.inflate(R.layout.stack_fragement_one, container,
                false);
        return tView;
    }

    /**
     * 这个在主 Activity 中设置，或在此设置一样。
     */
    @Override
    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {

        inflater.inflate(R.menu.fragment_menu, menu);
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {

        switch (item.getItemId()) {
        case R.id.menu_fra_text:

            Toast.makeText(getActivity(), "您点击了第一个 Fragment",
                    Toast.LENGTH_SHORT).show();
            break;
        }

        return true;
    }
}

/**
 * Fragment 与 ActionBar 和 MenuItem 集成
 */
public class ActionActivity extends Activity {

    private FragmentOne mFOne;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        initControl(savedInstanceState);
    }

    private void initControl(Bundle savedInstanceState) {

        setContentView(R.layout.activity_fragment_stack);

        if (savedInstanceState == null) {

            mFOne = new FragmentOne();
            FragmentManager tFManager = getFragmentManager();
            FragmentTransaction tFTransaction = tFManager.beginTransaction();
            tFTransaction.add(R.id.flStackContent, mFOne, "ONE");
            tFTransaction.commit();
        }
    }

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

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {

        switch (item.getItemId()) {
        case R.id.menu_settings:

            Toast.makeText(this, "设置", Toast.LENGTH_SHORT).show();
            return true;

        default:

            // 如果希望 Fragment 自己处理 MenuItem 点击事件，一定不要忘了调用 super.xxx
            return super.onOptionsItemSelected(item);
        }
    }
}

好了，可以很好的看到，Fragment 可以添加 MenuItem，也可以自己处理点击

--------------------------------------------------------------------------------------------
六、没有布局的 Fragment 的作用

没有布局文件 Fragment 实际上是为了保存，当 Activity 重启时，保存大量数据准备的
请参考博客：Android 屏幕旋转 处理 AsyncTask 和 ProgressDialog 的最佳方案

--------------------------------------------------------------------------------------------
七、使用 Fragment 创建对话框

这是Google推荐的方式，我也单独写过博客介绍，请参考：Android 官方推荐 : DialogFragment 创建对话框

好了，终于把 Fragment 相关的联系到一起了，上述基本包含了 Fragment 所有的用法~~~相信大家如果能够看完，一定有不少的收获
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。