- 作 者
- 花想
- 中文名称
- Fragment
- 主 角
- 亞瑟.柯克蘭,伊莉莎白。女王 [1]
- 连载平台
- 晋江文学网
- 连载状态
- 连载中 [1]
-
Fragment
2016-05-17 15:58:04Fragment 一、Fragment的概念和用法: (一)、概念: Fragment是在Android 3.0 (API level 11)开始引入新的API技术。 为了提高代码重用性和改善用户体验,我们将Activity中的UI组件进行...Fragment
一、Fragment的概念和用法:(一)、概念:Fragment是在Android 3.0 (API level 11)开始引入新的API技术。为了提高代码重用性和改善用户体验,我们将Activity中的UI组件进行分组和模块化管理。这些分组后的UI组件就是Fragment。一个Activity页面中可以包含多个Fragment模块,而同一个Fragment模块也可以被多个Activity使用。每个Fragment有自己的布局,有自己的生命周期。虽然Fragment拥有自己的生命周期,但因为Fragment必须被嵌入到Activity中使用,因此Fragment的生命周期是受其Activity宿主的生命周期所控制的。当Activity暂停时,该Activtiy内的所有Fragment都会暂停;当Activity被销毁时,该Activity内的所有Fragment都会被销毁。
(二)、Fragment为什么能改善用户体验,另外Fragment能用于平板电脑,那么普通的手机屏幕适用吗?
下图是一个“AndroidManual学习手册浏览界面”的效果图:
如上图所示,“平板电脑”中,在一个Activity布局中放了两个Fragment:左侧是文章标题列表Fragment,右侧是文章内容展示的Fragment。左侧的标题列表不变,点击每条列表项,右侧的文章内容发生变化。点击和浏览内容都在同一个页面中发生,避免了页面切换和点击“返回键”返回的操作。用户感觉自然方便和快捷。那么Fragment组件适用于普通屏幕的手机吗?答案是肯定的。Fragment本身是可复用的组件。是否在一个Activity页面中放置多个Fragment取决了屏幕的大小,如果屏幕大小不够,那么就可以在Activity A中只包含Fragment A,在Activity B中只包含Fragment B,点击A中的item跳转到B就可以。
(三)、Fragment要点:【重点】1、Fragment作为Activity界面的一部分组成出现;2、可以在一个Activity中同时出现多个Fragment,并且,一个Fragment亦可在多个Activity中使用;3、在Activity运行过程中,可以添加、移除、替换、隐藏、显示Fragment(add()、remove()、replace()、hide()、show());4、Fragment可以响应自己的输入事件,并且有自己的生命周期,当然,它们的生命周期直接受其所属的宿主Activity的生命周期控制。5、FragmenetTransaction的方法:
- 使用add()加入fragment时将触发onAttach(),使用attach()不会触发onAttach()
- 使用replace()替换后会将之前的fragment的view从viewtree中删除
- 触发顺序:
- detach()->onPause()->onStop()->onDestroyView()
- attach()->onCreateView()->onActivityCreated()->onStart()->onResume()
- 使用hide()方法只是隐藏了fragment的view并没有将view从viewtree中删除,随后可用show()方法将view设置为显示
- 而使用detach()会将view从viewtree中删除,和remove()不同,此时fragment的状态依然保持着,在使用 attach()时会再次调用onCreateView()来重绘视图,注意使用detach()后fragment.isAdded()方法将返回 false,在使用attach()还原fragment后isAdded()会依然返回false(需要再次确认)
- 执行detach()和replace()后要还原视图的话, 可以在相应的fragment中保持相应的view,并在onCreateView()方法中通过view的parent的removeView()方法将view和parent的关联删除后返回
(四)、Fragment家族常用的API1、Fragment常用的三个类:- android.app.Fragment 主要用于定义Fragment
- android.app.FragmentManager 主要用于在Activity中操作Fragment
- android.app.FragmentTransaction
2、获取FragmentManage的方式:getFragmentManager() // v4中,getSupportFragmentManager
3、主要的操作都是FragmentTransaction的方法FragmentTransaction transaction = fm.benginTransatcion();//开启一个事务- transaction.add() 往Activity中添加一个Fragment
- transaction.remove() 从Activity中移除一个Fragment,如果被移除的Fragment没有添加到回退栈,这个Fragment实例将会被销毁。
- transaction.replace() 使用另一个Fragment替换当前的,实际上就是remove()+add()的合体
- transaction.hide() 隐藏当前的Fragment,仅仅是设为不可见,并不会销毁
- transaction.show() 显示之前隐藏的Fragment
- transaction.detach() 会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护
- transaction.attach() 重建view视图,附加到UI上并显示
- transatcion.commit() 提交一个事务
- fragment.isAdded() 判断一个Fragment是否已经被添加到事务中
二、Fragment生命周期:
(一)、Fragment基本状态:
1、活动状态:Resumed 当前Fragment位于前台,用户可见,可以获得焦点;
2、暂停状态: Paused 另一个Activity处于前台并拥有焦点, 但是该Fragment所在的Activity仍然可见(前台Activity局部透明或者没有覆盖整个屏幕),不过不能获得焦点;
3、停止状态:Stopped
要么是宿主Activity已经被停止, 要么是Fragment从Activity被移除但被添加到回退栈中;
停止状态的Fragment仍然活着(所有状态和成员信息被系统保持着)。 然而, 它对用户不再可见, 并且如果Activity被销毁,它也会被销毁;
4、销毁状态:Destroyed 只能等待被回收。
(二)、Fragment生命周期:【重点】
方法 描述 onAttach(Activity) 当前Fragment与Activity关联,调用!
onCreate() 完成fragment的初始化创建
onCreateView() 创建并返回与当前fragment相关联的层次视图view
onActivityCreated() 主activity的onCreate()执行完后,该方法才执行
onStart() fragment可见,当主activity处于started状态后执行
onResume() fragment能与用户交互,当主activity处于resumed状态后执行
onPause() fragment不在与用户交互,可能在主activity将要处于paused前执行,可能该fragment被修改
onStop() fragment不在可见,可能在主activity将要处于stopped前执行,可能该fragment被修改
onDestroyView() 允许该fragment清理视图相关资源
onDestroy() 清理掉视图state信息
onDetach() 该fragment不在于activity关联
1、onAttach(): 当该Fragment被添加到Activity时被回调。该方法只会被调用一次;
2、onCreate(): 当创建Fragment时被回调。该方法只会被调用一次;
3、onCreateView():每次创建、绘制该Fragment的View组件时回调该方法,Fragment将会显示该方法返回的View 组件;
4、onActivityCreated(): 当Fragment的宿主Activity被启动完成后回调该方法;
5、onStart(): 启动Fragment时被回调;
6、onResume(): onStart()方法后一定会回调onResume()方法;
7、onPause(): 暂停Fragment时被回调;
8、onStop(): 停止Fragment时被回调;
9、onDestroyView(): 销毁该Fragment所包含的View组件时调用;
10、onDestroy(): 销毁Fragment时被回调。该方法只会被调用一次;
11、onDetach(): 将Fragment从Activity中删除、替换完成时调用该方法。onDestroy()方法后一定会回调onDetach()方法。该方法只会被调用一次。
12、onInflate():
13、onViewCreated():
【备注:】其中大多数程序必须实现Fragment的三个回调方法分别为:
onCreate :系统创建Fragments 时调用,可做执行初始化工作或者当程序被暂停或停止时用来恢复状态,跟Activity 中的onCreate相当。
onCreateView :用于首次绘制用户界面的回调方法,必须返回要创建的Fragment 视图UI。假如你不希望提供Fragment用户界面则可以返回NULL。
onPause : 当用户离开这个Fragment的时候调用,这时你要提交任何应该持久的变化,因为用户可能不会回来。
(三)、示例代码:
1、Fragment的布局文件:
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<TextView
android:id="@+id/text_leftfragment_info"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="这是leftFragment中的textview"/>
</LinearLayout>
2、MainActivity的布局文件:
<RelativeLayoutxmlns: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">
<fragment
android:id="@+id/fragment_left_newstitle"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:name="com.steven.android24_fragmentlifecycle.LeftFragment"/>
</RelativeLayout>
3、Fragment文件中的java代码:
publicclass LeftFragment extends Fragment {
privatestaticfinal String TAG = "LeftFragment";
@Override
publicvoid onInflate(Activity activity, AttributeSet attrs,
Bundle savedInstanceState) {
Log.i(TAG, "==onInflate()执行了");
super.onInflate(activity, attrs, savedInstanceState);
}
@Override
publicvoid onAttach(Activity activity) {
Log.i(TAG, "==onAttach()执行了");
super.onAttach(activity);
}
@Override
publicvoid onCreate(Bundle savedInstanceState) {
Log.i(TAG, "==onCreate()执行了");
super.onCreate(savedInstanceState);
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
Log.i(TAG, "==onCreateView()执行了");
// inflater.inflate(resource, null);
return inflater.inflate(R.layout.fragment_left, container, false);
}
@Override
publicvoid onViewCreated(View view, Bundle savedInstanceState) {
Log.i(TAG, "==onViewCreated()执行了");
super.onViewCreated(view, savedInstanceState);
}
@Override
publicvoid onActivityCreated(Bundle savedInstanceState) {
Log.i(TAG, "==onActivityCreated()执行了");
super.onActivityCreated(savedInstanceState);
}
@Override
publicvoid onStart() {
Log.i(TAG, "==onStart()执行了");
super.onStart();
}
@Override
publicvoid onResume() {
Log.i(TAG, "==onResume()执行了");
super.onResume();
}
@Override
publicvoid onPause() {
Log.i(TAG, "==onPause()执行了");
super.onPause();
}
@Override
publicvoid onStop() {
Log.i(TAG, "==onStop()执行了");
super.onStop();
}
@Override
publicvoid onDestroyView() {
Log.i(TAG, "==onDestroyView()执行了");
super.onDestroyView();
}
@Override
publicvoid onDestroy() {
Log.i(TAG, "==onDestroy()执行了");
super.onDestroy();
}
@Override
publicvoid onDetach() {
Log.i(TAG, "==onDetach()执行了");
super.onDetach();
}
@Override
publicvoid onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
super.onCreateOptionsMenu(menu, inflater);
}
@Override
publicvoid onCreateContextMenu(ContextMenu menu, View v,
ContextMenuInfo menuInfo) {
super.onCreateContextMenu(menu, v, menuInfo);
}
}
(四)、运行结果观察:
1、第一次加载Fragment:
2、在MainActivity中,点击“返回键”退出程序:
3、在MainActivity中,点击“HOME键”退出程序:
【备注:】请注意第二种和第三种情况的区别。如果点HOME键退出,则少调用了onDestroyView()、onDestroy()、onDetach()三个回调方法。
4、点击“下一页”,进入NextActivity页面:
5、在NextActivity页面中,点击“HOME键”退出程序:
6、上次HOME键退出后,重新进入程序:【因为上次是从NextActivity页面按HOME退出,所以此时直接进入 NextActivity页面 】
(五)、跟Fragment生命周期相关的其他方法:
1、onInflate():在onCreate()方法之前调用,这时窗体上的控件都没有被创建,所以不能通过getActivity().findViewById(),因为此时getActivity()返回null。
2、onViewCreated():在onCreateView()方法后会立刻调用onViewCreated()方法。通常在该方法中完成创建Fragment的最后工作,然后系统就开始调用onCreate()方法对窗体初始化。
(六)、如果Activity生命周期和Fragment生命周期的Log都开启,那么依次会如何输出信息呢?
1、第一次加载MainActivity页面:
2、在MainActivity页面中,点击“返回键”退出程序:
3、在MainActivity中,点击“HOME键”退出程序:
【备注:】请同学们注意观察Activity回调方法和Fragment回调方法执行的顺序。请设想各种操作步骤,写出生命周期回调方法执行的顺序。
【特别强调:】
当Activity的onCreate()方法中,如果将Log的位置放在setContentView(R.layout.activity_main)之前,那么Activity的onCreate()方法就会在最先执行,如果将日志写在setContentView(R.layout.activity_main)之后,那么Activity的onCreate()方法就会在Fragment的onViewCreated()之后执行。
4、分析生命周期执行过程的案例:
开启一个包含有Fragment的Activity页面,然后点击“返回键”退出,然后再次启动该Activity页面,请描述完整的生命周期回调方法。
参考答案:
04:36:31.282: MainActivity: ==onCreate()
04:36:31.502: LeftFragment: ==onInflate()执行了
04:36:31.502: LeftFragment: ==onAttach()执行了
04:36:31.513: LeftFragment: ==onCreate()执行了
04:36:31.513: LeftFragment: ==onCreateView()执行了
04:36:31.533: LeftFragment: ==onViewCreated()执行了
04:36:31.542: LeftFragment: ==onActivityCreated()执行了
04:36:31.542: MainActivity: ==onStart()
04:36:31.552: LeftFragment: ==onStart()执行了
04:36:31.563: MainActivity: ==onResume()
04:36:31.563: LeftFragment: ==onResume()执行了
04:37:20.133: LeftFragment: ==onPause()执行了
04:37:20.142: MainActivity: ==onPause()
04:37:21.932: LeftFragment: ==onStop()执行了
04:37:21.932: MainActivity: ==onStop()
04:37:21.942: LeftFragment: ==onDestroyView()执行了
04:37:21.952: LeftFragment: ==onDestroy()执行了
04:37:21.952: LeftFragment: ==onDetach()执行了
04:37:21.952: MainActivity: ==onDestroy()
04:39:20.763: MainActivity: ==onCreate()
04:39:21.552: LeftFragment: ==onInflate()执行了
04:39:21.635: LeftFragment: ==onAttach()执行了
04:39:21.635: LeftFragment: ==onCreate()执行了
04:39:21.652: LeftFragment: ==onCreateView()执行了
04:39:21.652: LeftFragment: ==onViewCreated()执行了
04:39:21.842: LeftFragment: ==onActivityCreated()执行了
04:39:21.842: MainActivity: ==onStart()
04:39:21.908: LeftFragment: ==onStart()执行了
04:39:21.912: MainActivity: ==onResume()
04:39:21.932: LeftFragment: ==onResume()执行了
三、创建Fragment:
(一)、创建Fragment的步骤:【只需要两步】
1、创建一个Fragment,必须继承Fragment 这个基类或其子类;
【备注:】除了继承基类 Fragment , 还有一些子类你可能会继承,是哪些子类呢?
DialogFragment- 显示一个浮动的对话框. 用这个类来创建一个对话框,是使用在Activity类的对话框工具方法之外的一个好的选择,因为你可以将一个fragment对话框合并到activity管理的fragment back stack中,允许用户返回到一个之前曾被摒弃的fragment.
- 显示一个由一个adapter(例如 SimpleCursorAdapter)管理的项目的列表, 类似于ListActivity。它提供一些方法来管理一个list view, 例如 onListItemClick()回调来处理点击事件.
- 显示一个 Preference对象的层次结构的列表, 类似于PreferenceActivity。这在为你的应用创建一个"设置"activity时有用处.
2、实现回调方法:
Fragment类的代码看起来很像 Activity 。它包含了和activity类似的回调方法, 例如onCreate()、 onStart()、onPause()以及 onStop()。事实上,,如果你准备将一个现成的Android应用转换到使用Fragment,可能只需要将代码从你的Activity的回调方法中分别移动到你的Fragment的回调方法即可。
通常,应当至少实现如下的生命周期方法:
onCreate()
当创建fragment时, 系统调用该方法.
在实现代码中,应当初始化想要在fragment中保持的必要组件, 当fragment被暂停或者停止后可以恢复.
onCreateView()
fragment第一次绘制它的用户界面的时候, 系统会调用此方法. 为了绘制fragment的UI,此方法必须返回一个View, 这个view是你的fragment布局的根view. 如果fragment不提供UI, 可以返回null.
onPause()
用户将要离开fragment时,系统调用这个方法作为第一个指示(然而它不总是意味着fragment将被销毁.) 。在当前用户会话结束之前,通常应当在这里提交任何应该持久化的变化(因为用户有可能不会返回).
【备注:】对于大部分Fragment而言,通常实现三个回调方法即可。但是实际开发中可以根据需要重写Fragment生命周期中的任意回调方法。
(二)、Fragment实例:
1、描述:以“ 影视介绍 ”为例,无需页面切换,点击左侧影视名称,在右侧区域显示影视内容介绍。
2、主页面布局及Fragment布局文件代码:
//activity_main.xml布局文件:
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<fragment
android:id="@+id/fragment_left_title"
android:layout_width="0dp"
android:layout_height="fill_parent"
android:layout_weight="1"
class="com.steven.android24_fragmentmovie.LeftFragment"/>
<fragment
android:id="@+id/fragment_right_detail"
android:layout_width="0dp"
android:layout_height="fill_parent"
android:layout_weight="3"
class="com.steven.android24_fragmentmovie.RightFragment"/>
</LinearLayout>
//LeftFragment的布局文件:
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<ListView
android:id="@+id/listView_fragment_left"
android:layout_width="match_parent"
android:layout_height="wrap_content">
</ListView>
</LinearLayout>
//RightFragment的布局文件:
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<TextView
android:id="@+id/text_fragment_right"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="请点击左侧列表"/>
</LinearLayout>
【备注:】
<fragment>标签的android:id 和 android:tag属性必须至少有一个,同一个xml文件中id或tag必须唯一;
<fragment>标签的class 和 android:name属性功能完全相同,使用其中任何一个即可。
3、LeftFragment核心代码:
publicclass LeftFragment extends Fragment {
private ListView listView_fragment_left;
private String[] arr_data = new String[] { "扫毒", " 功夫战斗机", "顶楼的大象", "狂爱恶徒",
"兽性窥视", "新金瓶梅" };
private TextView text_fragment_right;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_left, null);
listView_fragment_left = (ListView) view
.findViewById(R.id.listView_fragment_left);
ArrayAdapter<String> adapter = new ArrayAdapter<String>(getActivity(),
android.R.layout.simple_list_item_1, arr_data);
listView_fragment_left.setAdapter(adapter);
listView_fragment_left
.setOnItemClickListener(new OnItemClickListener() {
@Override
publicvoid onItemClick(AdapterView<?> parent, View view,
int position, long id) {
InputStream is;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
String data = "";
try {
is = getActivity().getResources().getAssets()
.open("movie" + position + ".txt");
byte[] buffer = newbyte[1024];
int c = 0;
while ((c = is.read(buffer)) != -1) {
baos.write(buffer, 0, c);
baos.flush();
}
data = new String(baos.toByteArray(), "utf-8");
} catch (IOException e) {
e.printStackTrace();
}
TextView text_fragment_right = (TextView) getActivity()
.findViewById(R.id.text_fragment_right);
if (text_fragment_right != null) {
text_fragment_right.setText(data);
} else {
Intent intent = new Intent(getActivity(),
DetailActivity.class);
intent.putExtra("detail", data);
startActivity(intent);
}
}
});
return view;
}
}
【备注:】本例子中的数据源是assets目录下的文本文件。通过本例,也复习了assets资产文件的访问方式。
4、平板和手机适配:
如果想在平板和手机中显示不同的效果。则可以新建布局目录:layout-sw600dp.
三、动态创建Fragment:
(一)、概念:
如果将Fragment写在布局文件中,那么就是静态创建fragment;如果没有在布局文件中写<fragment>标签,而是在java文件中通过实例化Fragment创建Fragment的方式就是动态创建Fragment。
(二)、动态创建Fragment的步骤:
1、步骤:
2、Activity布局文件代码:
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical">
<Button
android:id="@+id/button_main_submit"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="clickButton"
android:text="点击发送消息"/>
<!-- fragment
android:id="@+id/fragment_content"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:name="com.steven.android24_fragmentarguments.DetailFragment" /-->
<LinearLayout
android:id="@+id/layout_container_fragment"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
</LinearLayout>
</LinearLayout>
3、MainActivity文件代码:
FragmentManager manager = getFragmentManager();
DetailFragment fragment = new DetailFragment();
FragmentTransaction transaction = manager.beginTransaction();
transaction.add(R.id.layout_container_fragment, fragment, "content_fragment");
transaction.commit();
四、Activity与Fragment之间的数据交互:
(一)、Activity向Fragment传递数据:Arguments
1、做法:
可以通过Fragment.setArguments()方法向Fragment传递数据,并且通过getArguments()方法获取传递的数据。
2、MainActivity文件代码:
publicclass MainActivity extends Activity {
privatestaticfinal String TAG = "MainActivity";
@Override
protectedvoid onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.i(TAG, "==onCreate()执行");
FragmentManager manager = getFragmentManager();
DetailFragment fragment = new DetailFragment();
Bundle bundle = new Bundle();
bundle.putString("msg", "Hello Fragment!!!");
fragment.setArguments(bundle);
FragmentTransaction transaction = manager.beginTransaction();
transaction.add(R.id.layout_container_fragment, fragment,
"content_fragment");
transaction.commit();
}
}
3、DetailFragment文件代码:
publicclass DetailFragment extends Fragment {
private TextView text_fragment_detail;
private Button button_fragment_get;
@Override
publicvoid onAttach(Activity activity) {
super.onAttach(activity);
Log.i("DetailFragment", "==onAttach()");
}
@Override
publicvoid onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view = inflater
.inflate(R.layout.fragment_detail, container, false);
text_fragment_detail = (TextView) view
.findViewById(R.id.text_fragment_detail);
button_fragment_get = (Button) view
.findViewById(R.id.button_fragment_get);
Bundle bundle = getArguments();
if (bundle != null) {
text_fragment_detail.setText(bundle.getString("msg"));
} else {
text_fragment_detail.setText("没有收到信息!");
}
return view;
}
}
4、注意事项:
Supply the construction arguments for this fragment. This can only be called before the fragment has been attached to its activity; that is, you should call it immediately after constructing the fragment. The arguments supplied here will be retained across fragment destroy and creation.
翻译:setArguments(bundle)为fragment提供构造的参数。它只能在fragment回调onAttach()方法之前调用。就是说,你应该在构造完fragment之后立刻调用它。提供的这些参数将在Fragment被销毁前一直保留。
在布局文件中使用<fragment>标签声明的Fragment(也就是静态生成的Fragment),都不能使用setArguments方法设置Bundle对象。
(二)、Fragment向宿主Activity回传信息:(Fragment回调机制)
1、原则:
Fragment类要尽量保证其独立性,Fragment类中不应该有访问其他Fragment和Activity中资源的代码,否则这个Fragment就不能在不改动代码的情况下用在其他地方。
如何让多个Fragment之间可以独立多次使用,而不是紧密地绑定到一起?通常的做法就是在Fragment类中编写一个接口,然后在该Fragment的宿主窗口类中实现该接口。这样Fragment与其宿主就实现了信息交互。
2、Fragment接口回调的步骤:(五步曲)
在Fragment文件中定义接口:OnItemClickedListener,定义抽象方法onClick(String info);
在Fragment文件中定义属性:private OnItemClickedListener mylistener;
在Fragment文件中的onAttach()方法中执行:mylistener = (OnItemClickedListener) getActivity();
在Fragment文件中,给某个控件增加监听器,在监听器中执行:mylistener.onClick(“需要传递的数据”);
将MainActivity实现OnItemClickedListener,重写onClick(String info)方法。参数就是Fragment传递的数据信息,在该方法中执行希望的逻辑操作。
3、DetailFragment的核心代码:
publicclass DetailFragment extends Fragment {
private TextView text_fragment_detail;
private Button button_fragment_get;
private Button button_fragment_send;
private OnItemClickedListener mylistener;
publicinterface OnItemClickedListener {
publicvoid onClick(String info);
}
@Override
publicvoid onAttach(Activity activity) {
super.onAttach(activity);
Log.i("DetailFragment", "==onAttach()");
if (getActivity() instanceof OnItemClickedListener) {
mylistener = (OnItemClickedListener) getActivity();
}
}
@Override
publicvoid onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view = inflater
.inflate(R.layout.fragment_detail, container, false);
text_fragment_detail = (TextView) view
.findViewById(R.id.text_fragment_detail);
button_fragment_get = (Button) view
.findViewById(R.id.button_fragment_get);
button_fragment_send = (Button) view
.findViewById(R.id.button_fragment_send);
button_fragment_get.setOnClickListener(new OnClickListener() {
@Override
publicvoid onClick(View v) {
Bundle bundle = getArguments();
if (bundle != null) {
text_fragment_detail.setText(bundle.getString("msg"));
} else {
text_fragment_detail.setText("没有收到信息!");
}
}
});
button_fragment_send.setOnClickListener(new OnClickListener() {
@Override
publicvoid onClick(View v) {
mylistener.onClick(“我是fragment传递给宿主的信息!");
}
});
return view;
}
}
4、MainActivity的核心代码:
publicclass MainActivity extends Activity implements OnItemClickedListener {
privatestaticfinal String TAG = "MainActivity";
@Override
protectedvoid onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.i(TAG, "==onCreate()执行");
FragmentManager manager = getFragmentManager();
DetailFragment fragment = new DetailFragment();
Bundle bundle = new Bundle();
bundle.putString("msg", "Hello Fragment!!!");
fragment.setArguments(bundle);
FragmentTransaction transaction = manager.beginTransaction();
transaction.add(R.id.layout_container_fragment, fragment,
"content_fragment");
transaction.commit();
}
@Override
publicvoid onClick(String info) {
// 拿到Fragment传递过来的数据,显示在Title上。
// 实际项目中,我们是将Fragment_A传给宿主的信息拿到后,再通过setArguments()传递给Fragment_B。这样就实现了两个Fragment之间的数据传递。
setTitle(info);
}
}
五、FragmentManager与Fragment事务: 【重要】
(一)、概念:
Activity管理Fragment主要依靠FragmentManager。FragmentManager可以完成以下几方面的功能:使用findFragmentById()或findFragmentByTag()方法来获取指定Fragment;
调用popBackStack()方法将Fragment从回退栈中弹出(如同用户按下“返回键”的效果);
调用addOnBackStackChangeListener()注册一个监听器,用于监听回退栈的变化情况。
在Activity中使用Fragment,一个很明显的特性是:根据用户的交互情况,可以对Fragment进行添加、移除、替换,以及执行其他动作,提交给Activity的每一套变化被称为一个事务。Fragment事务代表了Activity对Fragment执行的多个改变操作。实现事务借助于FragmentTransaction对象。我们可以保存每一个事务到一个Activity管理的backstack,这样用户就能由Fragment的变化返回导航。
(二)、Fragment与回退栈(导航):
1、回退栈的概念:BackStack
在Activity中已经探讨过回退栈,这种数据结构用来存放创建的窗口对象,并根据一定的规则决定哪些窗口对象应该出栈,凡是出栈的窗口对象将被销毁,也就是说窗口对象从入栈到出栈完成了窗口的整个生命周期。回退栈不仅能存储窗口对象,还可以存储Fragment对象。
(三)、FragmentManager与FragmentTransaction示例代码:
Fragment的布局文件:
// 构建Bundle对象,将文章id放在其中。
Bundle bundle = new Bundle();
bundle.putString("titleId", id);
// 构建文章内容的Fragment
RightFragment fragment = new RightFragment();
// 通过fragment对象的setArguments(bundle)方法将数据传输给其他Fragment。
fragment.setArguments(bundle);
// 通过getFragmentManager()方法构建FragmentManager对象
FragmentManager fragManager = getFragmentManager();
// 通过FragmentManager对象的beginTransaction()方法构建FragmentTransaction对象
FragmentTransaction trans = fragManager.beginTransaction();
// 将主页面布局文件中的ViewGroup容器替换成文章内容Fragment
trans.replace(R.id.fragment_content, fragment);
trans.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
// 将事务添加到回退栈,这样用户就可以通过“返回键”回到替换Fragment的上一个状态
trans.addToBackStack(null);
// 提交事务
trans.commit();
六、 FragmentTransaction中的replace方法与add、hide、show方法的区别:【重要】
示例代码如下:
- private void initData() {
- fragmentManager = getSupportFragmentManager();
- // 初始化碎片集合
- listFragments = new ArrayList<Fragment>();
- listFragments.add(new FragmentOne());
- listFragments.add(new FragmentTwo());
- listFragments.add(new FragmentThree());
- // 在指定位置默认加载第一个碎片
- transaction = fragmentManager.beginTransaction();
- transaction.add(R.id.layout_container, listFragments.get(0));
- transaction.commit();
- }
- // 点击选项TAB按钮,执行碎片切换
- public void clickButton(View view) {
- switch (view.getId()) {
- case R.id.button_one:
- switchFragment(0);
- break;
- case R.id.button_two:
- switchFragment(1);
- break;
- case R.id.button_three:
- switchFragment(2);
- break;
- }
- }
- /*
- * 使用replace()方法实现。 每次replace都会将当前的碎片进行销毁,新创建一个碎片将原有的进行替换
- * 当TAB菜单切换到之前的选项时,虽然对应的碎片已经被创建过,但是因为销毁了而需要重新创建一次,因此会造成性能浪费
- */
- private void replaceFragment(int tabindex) {
- if (currentTabIndex != tabindex) {
- transaction = fragmentManager.beginTransaction();
- transaction.replace(R.id.layout_container,
- listFragments.get(tabindex));
- transaction.addToBackStack(null);
- transaction.commit();
- currentTabIndex = tabindex;
- }
- }
- /*
- * 使用add()、hide()、show()方法实现。被加载出来的碎片在导航切换过程中不会被销毁,只是在隐藏和显示两个状态切换而已。
- * 因为切换过的碎片不被销毁,自然会有内存占用上的开销,但是因为不用重新加载碎片而在性能上是优于replace的。
- */
- private void switchFragment(int tabindex) {
- if (currentTabIndex != tabindex) {
- transaction = fragmentManager.beginTransaction();
- // 定义当前碎片与即将加载的碎片
- Fragment fromFragment = listFragments.get(currentTabIndex);
- Fragment toFragment = listFragments.get(tabindex);
- if (!toFragment.isAdded()) {
- // 如果该碎片还没有被添加到事务中,则新添加到事务
- transaction.hide(fromFragment).add(R.id.layout_container,
- toFragment);
- } else {
- // 如果该碎片已经被添加到事务中,则从事务中取出该碎片进行显示即可。无需销毁再重新创建。
- transaction.hide(fromFragment).show(toFragment);
- }
- // 提交执行过的事务
- transaction.addToBackStack(null);
- transaction.commit();
- currentTabIndex = tabindex;
- }
- }
-
Android Fragment 真正的完全解析(上)
2014-07-20 11:22:09本篇博客力求为大家说明Fragment如何产生,什么是Fragment,Fragment生命周期,如何静态和动态的使用Fragment,Fragment回退栈,Fragment事务;以及Fragment的一些特殊用途,例如:没有布局的Frag转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/37970961
自从Fragment出现,曾经有段时间,感觉大家谈什么都能跟Fragment谈上关系,做什么都要问下Fragment能实现不~~~哈哈,是不是有点过~~~
本篇博客力求为大家说明Fragment如何产生,什么是Fragment,Fragment生命周期,如何静态和动态的使用Fragment,Fragment回退栈,Fragment事务;以及Fragment的一些特殊用途,例如:没有布局的Fragment有何用处?Fragment如何与Activity交互?Fragment如何创建对话框?Fragment如何与ActionBar集成等等。
1、Fragment的产生与介绍
Android运行在各种各样的设备中,有小屏幕的手机,超大屏的平板甚至电视。针对屏幕尺寸的差距,很多情况下,都是先针对手机开发一套App,然后拷贝一份,修改布局以适应平板神马超级大屏的。难道无法做到一个App可以同时适应手机和平板么,当然了,必须有啊。Fragment的出现就是为了解决这样的问题。你可以把Fragment当成Activity的一个界面的一个组成部分,甚至Activity的界面可以完全有不同的Fragment组成,更帅气的是Fragment拥有自己的生命周期和接收、处理用户的事件,这样就不必在Activity写一堆控件的事件处理的代码了。更为重要的是,你可以动态的添加、替换和移除某个Fragment。
2、Fragment的生命周期
Fragment必须是依存与Activity而存在的,因此Activity的生命周期会直接影响到Fragment的生命周期。官网这张图很好的说明了两者生命周期的关系:
可以看到Fragment比Activity多了几个额外的生命周期回调方法:
onAttach(Activity)
当Fragment与Activity发生关联时调用。
onCreateView(LayoutInflater, ViewGroup,Bundle)
创建该Fragment的视图
onActivityCreated(Bundle)
当Activity的onCreate方法返回时调用
onDestoryView()
与onCreateView想对应,当该Fragment的视图被移除时调用
onDetach()
与onAttach相对应,当Fragment与Activity关联被取消时调用
注意:除了onCreateView,其他的所有方法如果你重写了,必须调用父类对于该方法的实现,3、静态的使用Fragment
嘿嘿,终于到使用的时刻了~~
这是使用Fragment最简单的一种方式,把Fragment当成普通的控件,直接写在Activity的布局文件中。步骤:
1、继承Fragment,重写onCreateView决定Fragemnt的布局
2、在Activity中声明此Fragment,就当和普通的View一样
下面展示一个例子(我使用2个Fragment作为Activity的布局,一个Fragment用于标题布局,一个Fragment用于内容布局):
TitleFragment的布局文件:
<?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="45dp" android:background="@drawable/title_bar" > <ImageButton android:id="@+id/id_title_left_btn" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerVertical="true" android:layout_marginLeft="3dp" android:background="@drawable/showleft_selector" /> <TextView android:layout_width="fill_parent" android:layout_height="fill_parent" android:gravity="center" android:text="我不是微信" android:textColor="#fff" android:textSize="20sp" android:textStyle="bold" /> </RelativeLayout>
TitleFragmentpackage com.zhy.zhy_fragments; import android.app.Fragment; import android.os.Bundle; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.ImageButton; import android.widget.Toast; public class TitleFragment extends Fragment { private ImageButton mLeftMenu; @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = inflater.inflate(R.layout.fragment_title, container, false); mLeftMenu = (ImageButton) view.findViewById(R.id.id_title_left_btn); mLeftMenu.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { Toast.makeText(getActivity(), "i am an ImageButton in TitleFragment ! ", Toast.LENGTH_SHORT).show(); } }); return view; } }
同理还有ContentFragment的其布局文件:<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical" > <TextView android:layout_width="fill_parent" android:layout_height="fill_parent" android:gravity="center" android:text="使用Fragment做主面板" android:textSize="20sp" android:textStyle="bold" /> </LinearLayout>
package com.zhy.zhy_fragments; import android.app.Fragment; import android.os.Bundle; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; public class ContentFragment extends Fragment { @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { return inflater.inflate(R.layout.fragment_content, container, false); } }
MainActivitypackage com.zhy.zhy_fragments; import android.app.Activity; import android.os.Bundle; import android.view.Window; public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE); setContentView(R.layout.activity_main); } }
Activity的布局文件:<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" > <fragment android:id="@+id/id_fragment_title" android:name="com.zhy.zhy_fragments.TitleFragment" android:layout_width="fill_parent" android:layout_height="45dp" /> <fragment android:layout_below="@id/id_fragment_title" android:id="@+id/id_fragment_content" android:name="com.zhy.zhy_fragments.ContentFragment" android:layout_width="fill_parent" android:layout_height="fill_parent" /> </RelativeLayout>
是不是把Fragment当成普通的View一样声明在Activity的布局文件中,然后所有控件的事件处理等代码都由各自的Fragment去处理,瞬间觉得Activity好干净有木有~~代码的可读性、复用性以及可维护性是不是瞬间提升了~~~下面看下效果图:4、动态的使用Fragment
上面已经演示了,最简单的使用Fragment的方式~下面介绍如何动态的添加、更新、以及删除Fragment
为了动态使用Fragment,我们修改一下Actvity的布局文件,中间使用一个FrameLayout,下面添加四个按钮~~~嘿嘿~~不是微信的按钮- -!
<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" > <fragment android:id="@+id/id_fragment_title" android:name="com.zhy.zhy_fragments.TitleFragment" android:layout_width="fill_parent" android:layout_height="45dp" /> <include android:id="@+id/id_ly_bottombar" android:layout_width="fill_parent" android:layout_height="55dp" android:layout_alignParentBottom="true" layout="@layout/bottombar" /> <FrameLayout android:id="@+id/id_content" android:layout_width="fill_parent" android:layout_height="fill_parent" android:layout_above="@id/id_ly_bottombar" android:layout_below="@id/id_fragment_title" /> </RelativeLayout>
底部四个按钮的布局就不贴了,到时看效果图就明白了~~下面主Activity
package com.zhy.zhy_fragments; import android.app.Activity; import android.app.FragmentManager; import android.app.FragmentTransaction; import android.os.Bundle; import android.view.View; import android.view.View.OnClickListener; import android.view.Window; import android.widget.LinearLayout; public class MainActivity extends Activity implements OnClickListener { private LinearLayout mTabWeixin; private LinearLayout mTabFriend; private ContentFragment mWeixin; private FriendFragment mFriend; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE); setContentView(R.layout.activity_main); // 初始化控件和声明事件 mTabWeixin = (LinearLayout) findViewById(R.id.tab_bottom_weixin); mTabFriend = (LinearLayout) findViewById(R.id.tab_bottom_friend); mTabWeixin.setOnClickListener(this); mTabFriend.setOnClickListener(this); // 设置默认的Fragment setDefaultFragment(); } private void setDefaultFragment() { FragmentManager fm = getFragmentManager(); FragmentTransaction transaction = fm.beginTransaction(); mWeixin = new ContentFragment(); transaction.replace(R.id.id_content, mWeixin); transaction.commit(); } @Override public void onClick(View v) { FragmentManager fm = getFragmentManager(); // 开启Fragment事务 FragmentTransaction transaction = fm.beginTransaction(); switch (v.getId()) { case R.id.tab_bottom_weixin: if (mWeixin == null) { mWeixin = new ContentFragment(); } // 使用当前Fragment的布局替代id_content的控件 transaction.replace(R.id.id_content, mWeixin); break; case R.id.tab_bottom_friend: if (mFriend == null) { mFriend = new FriendFragment(); } transaction.replace(R.id.id_content, mFriend); break; } // transaction.addToBackStack(); // 事务提交 transaction.commit(); } }
可以看到我们使用FragmentManager对Fragment进行了动态的加载,这里使用的是replace方法~~下一节我会详细介绍FragmentManager的常用API。注:如果使用Android3.0以下的版本,需要引入v4的包,然后Activity继承FragmentActivity,然后通过getSupportFragmentManager获得FragmentManager。不过还是建议版Menifest文件的uses-sdk的minSdkVersion和targetSdkVersion都改为11以上,这样就不必引入v4包了。
代码中间还有两个Fragment的子类,ContentFragment上面已经见过,FriendFragment其实类似:
package com.zhy.zhy_fragments; import android.app.Fragment; import android.os.Bundle; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; public class FriendFragment extends Fragment { @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { return inflater.inflate(R.layout.fragment_friend, container, false); } }
效果图:可以看到很好的实现了效果,其实这个效果以前的博客中也出现过,在博客:Android项目Tab类型主界面大总结 Fragment+TabPageIndicator+ViewPager,有兴趣可以看看。ps:为了代码的简洁,就不添加按钮的点击变化什么的了,主要讲解功能了~~~
5、Fragment家族常用的API
Fragment常用的三个类:
android.app.Fragment 主要用于定义Fragment
android.app.FragmentManager 主要用于在Activity中操作Fragment
android.app.FragmentTransaction 保证一些列Fragment操作的原子性,熟悉事务这个词,一定能明白~
a、获取FragmentManage的方式:
getFragmentManager() // v4中,getSupportFragmentManager
b、主要的操作都是FragmentTransaction的方法
FragmentTransaction transaction = fm.benginTransatcion();//开启一个事务
transaction.add()
往Activity中添加一个Fragment
transaction.remove()
从Activity中移除一个Fragment,如果被移除的Fragment没有添加到回退栈(回退栈后面会详细说),这个Fragment实例将会被销毁。
transaction.replace()
使用另一个Fragment替换当前的,实际上就是remove()然后add()的合体~
transaction.hide()
隐藏当前的Fragment,仅仅是设为不可见,并不会销毁
transaction.show()
显示之前隐藏的Fragment
detach()
会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护。
attach()
重建view视图,附加到UI上并显示。
transatcion.commit()//提交一个事务
注意:常用Fragment的哥们,可能会经常遇到这样Activity状态不一致:State loss这样的错误。主要是因为:commit方法一定要在Activity.onSaveInstance()之前调用。
上述,基本是操作Fragment的所有的方式了,在一个事务开启到提交可以进行多个的添加、移除、替换等操作。
值得注意的是:如果你喜欢使用Fragment,一定要清楚这些方法,哪个会销毁视图,哪个会销毁实例,哪个仅仅只是隐藏,这样才能更好的使用它们。
a、比如:我在FragmentA中的EditText填了一些数据,当切换到FragmentB时,如果希望会到A还能看到数据,则适合你的就是hide和show;也就是说,希望保留用户操作的面板,你可以使用hide和show,当然了不要使劲在那new实例,进行下非null判断。
b、再比如:我不希望保留用户操作,你可以使用remove(),然后add();或者使用replace()这个和remove,add是相同的效果。
c、remove和detach有一点细微的区别,在不考虑回退栈的情况下,remove会销毁整个Fragment实例,而detach则只是销毁其视图结构,实例并不会被销毁。那么二者怎么取舍使用呢?如果你的当前Activity一直存在,那么在不希望保留用户操作的时候,你可以优先使用detach。
上述已经介绍完成了Fragment常用的一些方法,相信看完,大家一定清楚了Fragment的产生理由,以及如何使用Fragment,再根据API的讲解,也能明白,曾经为何觉得Fragment会出现一些列乱七八槽的问题,终究是因为没有弄清楚其生命周期。
由于篇幅原因,剩下的内容留到下一篇了。在下一篇,会介绍:
1、如何管理Fragment回退栈
2、Fragment如何与Activity交互
3、Fragment与Activity交互的最佳实践
4、没有视图的Fragment的用处
5、使用Fragment创建对话框
6、如何与ActionBar,MenuItem集成等~~
下一篇:Android Fragment 真正的完全解析(下)
好了,有任何问题请留言~~
会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护。 -
Fragment详解之三——管理Fragment(1)
2015-04-07 23:00:47前言:follow your heart,be your own king 相关文章: 1、《Fragment详解之一——概述》 2、《Fragment详解之二——基本使用方法》 ...5、《Fragment详解之五——Fragment间参数传递》6、《Frag...前言:follow your heart,be your own king
相关文章:
1、《Fragment详解之一——概述》
2、《Fragment详解之二——基本使用方法》
3、《Fragment详解之三——管理Fragment(1)》
4、《Fragment详解之四——管理Fragment(2)》
5、《Fragment详解之五——Fragment间参数传递》
6、《Fragment详解之六——如何监听fragment中的回退事件与怎样保存fragment状态》前面给大家稍微看了要怎么使用fragment,在上篇中,我们也初步接触到了add,replace这些fragment操作的函数,下面就再详细讲讲如何管理Fragment页面吧。
一、概述
1、FragmentManager
要管理activity中的fragments,你就需要使用FragmentManager。通过getFragmentManager()或getSupportFragmentManager()获得
常用的方法有:manager.findFragmentById(); //根据ID来找到对应的Fragment实例,主要用在静态添加fragment的布局中,因为静态添加的fragment才会有ID manager.findFragmentByTag();//根据TAG找到对应的Fragment实例,主要用于在动态添加的fragment中,根据TAG来找到fragment实例 manager.getFragments();//获取所有被ADD进Activity中的Fragment
2、FragmentTransaction
一般用来对当前的Fragment进行管理,包括add,replace,remove;
常用的针对Fragment的方法有://将一个fragment实例添加到Activity的最上层 add(int containerViewId, Fragment fragment, String tag); //将一个fragment实例从Activity的fragment队列中删除 remove(Fragment fragment); //替换containerViewId中的fragment实例,注意,它首先把containerViewId中所有fragment删除,然后再add进去当前的fragment replace(int containerViewId, Fragment fragment);
还有hide()、show()、detach()、attach()这些函数,我们下篇再讲,这节先对Fragment的用法有一个初步了解;
二、add()、replace()、remove()使用方法示例
下面就通过例子来看看以上几个函数的使用方法吧。
效果图如下:- 点击“ADD Fragment1”,在将Fragment1添加到Activity的container中;
- 点击“ADD Fragment2”,将Fragment2添加到Activity的container中;
- 点击“Remove Fragment2”,将Fragment2的实例从container中移除,移除之后,就显示出其下方的fragment1的视图出来了。
- 再点击”replace Fragment1”,将container中的视图移除,然后添加上fragment2的视图。
那现在我们从头开始构建这个工程:
1、新建两个fragment1.xml 和 fragment2.xml:
从效果图中也可以看出,这两个XML什么都没有,只是通过背景色和文字来区别当前是哪个Fragment的XML布局文件而已,他们的布局代码如下:
fragment1.xml:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:background="#ff00f0" android:orientation="vertical" > <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="This is fragment 1" android:textColor="#000000" android:textSize="25sp" /> </LinearLayout>
fragment2.xml:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:background="#ffff00" android:orientation="vertical" > <TextView android:id="@+id/fragment2_tv" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="This is fragment 2" android:textColor="#000000" android:textSize="25sp" /> </LinearLayout>
2、建立对应的Fragment类:Fragment1和Fragment2
Fragment1:
import android.os.Bundle; import android.support.v4.app.Fragment; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; public class Fragment1 extends Fragment { @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { return inflater.inflate(R.layout.fragment1, container, false); } }
与上一篇一样,也只是在onCreateView()时返回对应的布局。同样,Fragment2的定义如下:
import android.os.Bundle; import android.support.v4.app.Fragment; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; public class Fragment2 extends Fragment { @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { return inflater.inflate(R.layout.fragment2, container, false); } }
3、MainActivity的布局
从上面的的效果图中也可以看出大概的布局,首先是三个Button,最下方是一个FrameLayout布局,它是用来做为container动态盛装fragment的;它就像是一个占位符,你设置多大,它其中的fragment就最大能有多大。记住,fragment也是Activity中的一个普通控件而已,只不过它可以像Activity一样用于显示的同时还能用来盛装其它控件!作为fragment的容器,即可以用FrameLayout也可以用LinearLayout或者RelativeLayout,都是一样的。activity_main.xml的布局代码如下:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical"> <Button android:id="@+id/btn_add_frag1" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="ADD Fragment1" /> <Button android:id="@+id/btn_add_frag2" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="ADD Fragment2" /> <Button android:id="@+id/btn_remove_frag2" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Remove Fragment2" /> <Button android:id="@+id/btn_repalce_frag1" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="replace Fragment1" /> <FrameLayout android:id="@+id/fragment_container" android:layout_width="match_parent" android:layout_height="match_parent"/> </LinearLayout>
4、MainActivity的实现:
(1)首先,先写一个添加fragment到Activity中的函数:
private void addFragment(Fragment fragment, String tag) { FragmentManager manager = getSupportFragmentManager(); FragmentTransaction transaction = manager.beginTransaction(); transaction.add(R.id.fragment_container, fragment, tag); transaction.commit(); }
- 先是传进来两个参数,一个是要添加的fragment实例,另一个是一个TAG
- 至于FragmentManager、FragmentTransaction就没什么好讲的,这是这么个流程,要获取它们的实例就得调用这些函数。
- 然后是add(R.id.fragment_container, fragment, tag)函数:第一个参数是要将fragment盛装的container,即我们上面的FrameLayout!第三个参数是tag,当传进去这个TAG,它就会跟这个fragment关联起来,当我们通过findFragmentByTag()时,根据这个TAG就能找到这个Fragment实例。进而对它进行操作,比如,我们下面的remove();
- 在通过transaction对Fragment操作完以后,一定要记得调用transaction.commit(),这样才会将操作提交到系统中,这里的代码才会最终起作用。
有没有觉得这个流程挺像数据库的回滚操作!对,其实就是这样的,这里其实就是一个针对Fragment的回滚操作,首先通过beginTransaction()来定义回滚的开始,然后通过transaction对Fragment进行一系列操作(我们这里只是进行了ADD,其实可以做一串操作),等操作完了利用commit()提交。这里就先初步讲到这,下节会细讲有关transaction的回滚过程。
(2)添加Fragment1和Fragment2:
好了,上面我们写好了一个函数addFragment(Fragment fragment, String tag),下面我们就要通过这个函数来添加Fragment1和Fragment2的实例了。
当点击“ADD Fragment1”按钮时:Fragment1 fragment1 = new Fragment1(); addFragment(fragment1, "fragment1");
当点击“ADD Fragment2”按钮时:
Fragment2 fragment2 = new Fragment2(); addFragment(fragment2, "fragment2");
这里需要注意的是,当我们添加每个Fragment实例时,都传进去一个对应的TAG,fragment1对应的是“fragment1”,fragment2对应的是“fragment2”,通过这些TAG,我们就可以通过findFragmentByTag()来获取它们了。
(3)RemoveFragment2:
下面就是当点击“RemoveFragment2”按钮时的代码操作了:private void removeFragment2() { FragmentManager manager = getSupportFragmentManager(); Fragment fragment = manager.findFragmentByTag("fragment2"); FragmentTransaction transaction = manager.beginTransaction(); transaction.remove(fragment); transaction.commit(); }
首先是通过
Fragment fragment = manager.findFragmentByTag("fragment2");
找到我们当时ADD进Activity的fragment2实例,然后通过transaction.remove(fragment);将它删除;从效果图中可以看到,由于我们移除了fragment2的实例,而又由于fragment2是在界面最上方的,所以把它删除了之后,自然就剩下了fragment1在最上方了,所以我们就看到了fragment1的界面。那如果我们移除的是fragment1呢?答案是界面没有任何变化!因为fragment1的实例是在fragment2的下方的,我们是根本看不到它的。
(4)ReplaceFragment1:最后一个操作:ReplaceFragment1:
咱们先回到上面的RemoveFragment2操作,在RemoveFragment2之后,要知道我们的Activity的ADD队列中,就只有fragment1了。知道这一点之后,咱们看下面ReplaceFragment1的代码:
private void replaceFragment1() { FragmentManager manager = getSupportFragmentManager(); Fragment2 fragment2 = new Fragment2(); FragmentTransaction transaction = manager.beginTransaction(); transaction.replace(R.id.fragment_container, fragment2); transaction.commit(); }
这里有个注意的问题:
transaction.replace(R.id.fragment_container, fragment2);
这里replace传进去的第一个参数是容器ID,第二个参数是要新增的fragment。既然要replace(),那它是针对哪个fragment进行replace()呢?怎么没有指定要替换的fragment!为什么这里的第一个参数是盛装Activity中所有Fragment的container的ID呢?没错,这里的replace操作会把这个cotainer中所有fragment清空!!!!然后再把fragment2添加进去!
从上面的的讲解,大家可能也已经觉查到FragmentTransaction的Add()操作是维持着一个队列的,在这个队列中,根据ADD进去的先后顺序形成了一个链表,我们上面的操作在这个列表中的形式变化如下图所示:源码在文章最底部给出
到这里add,replace,remove的使用方法就讲完了,但这里有个问题,必须根大家讲一下:我们上面说过replace操作会把container中的所有fragment全部删除,然后再将指定的fragment添加进去!但Android在实现时出现了BUG!在replace()时,并不能把以前所有Fragment清空,就因为这个系统工程产了BUG就会导致add()和Replace()不能共用!关于add()和Replace()不能共用的问题,我们会在下篇再讲。下面先给大家说说有关回滚的问题。
三、有关回滚——FragmentTransaction
1、FragmentTransaction事务回滚使用方法:
上部分,我们讲了有关添加、删除Fragment的操作,想将上一次commit的操作返回时,要怎么做呢。这就需要FragmentTransaction的回滚功能了。
要使用回滚功能,只需要要使用下面两个代码:
在transaction.commit()之前,使用addToBackStack()将其添加到回退栈中。transaction.addToBackStack(String tag);
在需要回退时,使用popBackStack()将最上层的操作弹出回退栈。
manager.popBackStack();
这里的popBackStack()是弹出默认的最上层的栈顶内容。
当栈中有多层时,我们可以根据id或TAG标识来指定弹出到的操作所在层。函数如下:void popBackStack(int id, int flags); void popBackStack(String name, int flags);
其中
- 参数int id是当提交变更时transaction.commit()的返回值。
- 参数string name是transaction.addToBackStack(String tag)中的tag值;
- 至于int flags有两个取值:0或FragmentManager.POP_BACK_STACK_INCLUSIVE;
- 当取值0时,表示除了参数一指定这一层之上的所有层都退出栈,指定的这一层为栈顶层;
- 当取值POP_BACK_STACK_INCLUSIVE时,表示连着参数一指定的这一层一起退出栈;
- 除了这几个函数,还有下面几个函数:有关他们的使用,我们在这小部分结尾时会提到
popBackStackImmediate() popBackStackImmediate(String tag) popBackStackImmediate(String tag, int flag) popBackStackImmediate(int id, int flag)
下面我们就通过一个例子来讲解一下有关回退栈中的操作过程:
先看下效果图:
整体流程是这样的:
1、逐个将Fragment1,2,3,4添加到窗口中,在添加时,每添加一个Fragment要利用transaction的addToBackStack将此次操作加入到回退栈中。
2、然后点击"PopBackStack"方法,将栈顶最上层的操作回退。退将最后一次添加回退出来,显示Fragment3.
3、点击“ADD Fragment4”将栈还原到1,2,3,4依次ADD进栈的状态,即操作1完成后的栈状态,然后点击“BackToStack2_0”,其实调用的方法是:manager.popBackStack("fragment2",0);//方法一,通过TAG回退
从这里可以看出,要回退到添加ADD Fragment2的状态,注意最后一个参数,这里设为0,表明,要回退ADD Fragment2的之后的操作,将ADD Fragment2的操作置为栈顶。从效果图中也可以看出,点击后的视图在Fragment2的位置
4、最后仍然是先点击"Add Fragment3"和"ADD Fragment4",将栈还原到操作1完成后的栈状态。然后点击“BackToStack2_INCLUSIVE”;其调用的方法是:manager.popBackStack("fragment2",FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法一,通过TAG回退
这里与上面的主要不同点在于第二个参数,这里设置为POP_BACK_STACK_INCLUSIVE,即在出栈时连带ADD Fragment2的操作一块出栈,放在栈顶的是ADD Fragment1的操作,所以放在界面上就是显示的是Fragment1的视图。
下面我们看看具体实现:
(1)、首先,与上部分一样,先添加四个Fragment,并用背景色和文字来区分。这部分代码我们就不讲了。
主要看看点击按钮的代码处理方法。
(2)、首先是添加Fragment1:Fragment1 fragment1 = new Fragment1(); stackID1 = addFragment(fragment1,"fragment1");
其中:
private int stackID1,stackID2,stackID3,stackID4;
private int addFragment(Fragment fragment,String stackName){ FragmentManager manager = getSupportFragmentManager(); FragmentTransaction transaction = manager.beginTransaction(); transaction.add(R.id.fragment_container,fragment); transaction.addToBackStack(stackName); return transaction.commit(); }
首先,这里的stackID1,stackID2,stackID3,stackID4是用来保存每次commit()后返回的Transaction的ID值。在void popBackStack(int id, int flags);时,其中的参数id就是这个值
然后在每次ADD操作后,利用addToBackStack(string name)将每次ADD操作添加进回退栈中;
同样,添加Fragment2的代码如下,添加Fragment3,Fragment4的方法同理Fragment2 fragment2 = new Fragment2(); stackID2 = addFragment(fragment2,"fragment2");
(3)、然后是回退栈顶内容:
private void popBackStack(){ FragmentManager manager = getSupportFragmentManager(); manager.popBackStack(); }
(4)、接着是点击BackToFrag2_0按钮的内容,这里有两种方法实现,一种是指定TAG,一种是利用Commit()返回的ID
private void popBackStackToFrag2_0(){ FragmentManager manager = getSupportFragmentManager(); manager.popBackStack("fragment2",0);//方法一,通过TAG回退 // manager.popBackStack(stackID2,0);//方法二,通过Transaction ID回退 }
(5)、最后是点击BackToFrag2_INCLUSIVE按钮的代码:
private void popBackStackToFrag2_Inclusive(){ FragmentManager manager = getSupportFragmentManager(); manager.popBackStack("fragment2",FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法一,通过TAG回退 // manager.popBackStack(stackID2,FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法二,通过Transaction ID回退 }
好了,到这里,有关回滚的基本使用就结束了,需要要注意的是:
使用popBackStack()来弹出栈内容的话,调用该方法后会将事物操作插入到FragmentManager的操作队列,只有当轮询到该事物时才能执行。如果想立即执行事物的话,需要使用下面几个对应的方法:popBackStackImmediate() popBackStackImmediate(String tag) popBackStackImmediate(String tag, int flag) popBackStackImmediate(int id, int flag)
2、回退栈(back stack)状态改变监听
FragmentManager还为我们提供了监控回退栈状态改变的方法:
FragmentManager::addOnBackStackChangedListener(listener);//添加监听器 FragmentManager::removeOnBackStackChangedListener(listener);//移除监听器
通过添加监听器,就可以在回退栈内容改变时,及时收到通知;
我们在上面代码的基础上,在MainAcitivy中为FragmentManager添加一个监听器,当回退栈状态改变时,打出一个LOG。具体实现如下:
(1)、OnCreate()中:
为fragmentManger添加一个监听器:FragmentManager manager = getSupportFragmentManager(); listener = new FragmentManager.OnBackStackChangedListener() { @Override public void onBackStackChanged() { // TODO Auto-generated method stub Log.d("qijian","backstack changed"); } }; manager.addOnBackStackChangedListener(listener);
(2)、当onDestory()中将监听器remove掉:
protected void onDestroy() { // TODO Auto-generated method stub super.onDestroy(); FragmentManager manager = getSupportFragmentManager(); manager.removeOnBackStackChangedListener(listener); }
大家一定要注意,不管是这里的回退栈的监听还是其它的监听器,在页面对应的销毁时,都要记得remove掉,不然会造成页面不释放,这也是造成OOM的问题之一。
这样当回退栈内容出现变动时,变会打LOG出来,如图:
源码在文章底部给出
3、Transaction事务回退的原则
这里我们着重讲一下,回退是以commit()提交的一次事务为单位的,而不是以其中的add,replace等等操作为单位回退的,即,如果我们在一次提交是添加了fragment2,fragment3,fragment4,那么回退时,会依据添加时的顺序,将它们一个个删除,返回到没有添加fragment4,fragment3,fragment2的状态。
下面我们仍然写一个例子来讲明一下事务的回退原则,效果图如下:- 1、首先,添加Fragment1,提交一次事务
- 2、然后,一次添加Fragment2,Fragment3,Fragment4,然后提交一次事务
- 3、利用popBackStack()将顶层事务出栈,可以看到把Fragment2,Fragment3,Fragment4一次出栈,界面显示在了Fragment1的位置,这就充分说明了,回滚是以提交的事务为单位进行的!
下面是代码实现部分:
1、同样,新建四个Fragment,分别利用背景色和文字来表明之间的不同。
2、然后添加Fragment1的代码如下:private void addFragment1() { Fragment1 fragment1 = new Fragment1(); FragmentManager manager = getSupportFragmentManager(); FragmentTransaction transaction = manager.beginTransaction(); transaction.add(R.id.fragment_container, fragment1); transaction.addToBackStack("fragment1"); transaction.commit(); }
3、然后是添加其它三个Fragment的代码如下:
private void addOtherFragments() { Fragment2 fragment2 = new Fragment2(); Fragment3 fragment3 = new Fragment3(); Fragment4 fragment4 = new Fragment4(); FragmentManager manager = getSupportFragmentManager(); FragmentTransaction transaction = manager.beginTransaction(); transaction.add(R.id.fragment_container, fragment2); transaction.add(R.id.fragment_container, fragment3); transaction.add(R.id.fragment_container, fragment4); transaction.addToBackStack("other fragments"); transaction.commit(); }
再一次重申,从代码中也可以看到,是依次将Fragment2、Fragment3、Fragment4加入容器之后,再提交一次事务,所以下面回滚时,会将他们反顺序的依次删除。即remove(fragment4)、remove(fragment3)、remove(fragment2)
4、点击popBackStack按钮时的代码private void popBackStack() { FragmentManager manager = getSupportFragmentManager(); manager.popBackStack(); }
好了,到这里这篇文章就结束了,这篇文章太TM长了……大家估计看得也快要吐了……知识点太多,又想能给大家讲的浅显易懂就只有拉长篇幅了……
源码中有三个工程:
1、《harvicBlog3_1》:对应第二部分:add()、replace()、remove()使用方法示例
2、《harvicBlog3_2》:对应第三部分《有关回滚——FragmentTransaction》中的:FragmentTransaction事务回滚使用方法和回退栈内容监听部分
3、《harvicBlog3_3》:对应第三部分《有关回滚——FragmentTransaction》中的:Transaction事务回退的原则部分如果本文有帮到你,记得加关注哦
源码下载地址:http://download.csdn.net/detail/harvic880925/8578519
请大家尊重原创者版权,转载请标明出处:http://blog.csdn.net/harvic880925/article/details/44927375, 谢谢!
如果你喜欢我的文章,你可能更喜欢我的公众号
-
Android Fragment 真正的完全解析(下)
2014-07-21 09:09:56上篇博客中已经介绍了Fragment产生原因,以及一些基本的用法和各种API,如果你还不了解,请看:Android Fragment 真正的完全解析(上)。 本篇将介绍上篇博客提到的:如何管理Fragment回退栈,Fragment如何与...转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/37992017
上篇博客中已经介绍了Fragment产生原因,以及一些基本的用法和各种API,如果你还不了解,请看:Android Fragment 真正的完全解析(上)。
本篇将介绍上篇博客提到的:如何管理Fragment回退栈,Fragment如何与Activity交互,Fragment与Activity交互的最佳实践,没有视图的Fragment的用处,使用Fragment创建对话框,如何与ActionBar,MenuItem集成等~~
1、管理Fragment回退栈
类似与Android系统为Activity维护一个任务栈,我们也可以通过Activity维护一个回退栈来保存每次Fragment事务发生的变化。如果你将Fragment任务添加到回退栈,当用户点击后退按钮时,将看到上一次的保存的Fragment。一旦Fragment完全从后退栈中弹出,用户再次点击后退键,则退出当前Activity。
看这样一个效果图:
点击第一个按钮,切换到第二个界面,点击第二个按钮,切换到第三个界面,然后点击Back键依次回退。这像不像初学Android时的Activity跳转,当然了,这里肯定不是,不然我就跪了。这里是Fragment实现的,用户点击Back,实际是Fragment回退栈不断的弹栈。
如何添加一个Fragment事务到回退栈:
FragmentTransaction.addToBackStack(String)
下面讲解代码:很明显一共是3个Fragment和一个Activity.
先看Activity的布局文件:
不同的Fragment就在这个FrameLayout中显示。<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/id_content" android:layout_width="fill_parent" android:layout_height="fill_parent" > </FrameLayout> </RelativeLayout>
MainActivity.java
很简单,直接将FragmentOne添加到布局文件中的FrameLayout中,注意这里并没有调用FragmentTransaction.addToBackStack(String),因为我不喜欢在当前显示时,点击Back键出现白板。而是正确的相应Back键,即退出我们的Activity.package com.zhy.zhy_fragments; import android.app.Activity; import android.app.FragmentManager; import android.app.FragmentTransaction; import android.os.Bundle; import android.view.Window; public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE); setContentView(R.layout.activity_main); FragmentManager fm = getFragmentManager(); FragmentTransaction tx = fm.beginTransaction(); tx.add(R.id.id_content, new FragmentOne(),"ONE"); tx.commit(); } }
下面是FragmentOne
package com.zhy.zhy_fragments; import android.app.Fragment; import android.app.FragmentManager; import android.app.FragmentTransaction; import android.os.Bundle; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.Button; public class FragmentOne extends Fragment implements OnClickListener { private Button mBtn; @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = inflater.inflate(R.layout.fragment_one, container, false); mBtn = (Button) view.findViewById(R.id.id_fragment_one_btn); mBtn.setOnClickListener(this); return view; } @Override public void onClick(View v) { FragmentTwo fTwo = new FragmentTwo(); FragmentManager fm = getFragmentManager(); FragmentTransaction tx = fm.beginTransaction(); tx.replace(R.id.id_content, fTwo, "TWO"); tx.addToBackStack(null); tx.commit(); } }
我们在点击FragmentOne中的按钮时,使用了replace方法,如果你看了前一篇博客,一定记得replace是remove和add的合体,并且如果不添加事务到回退栈,前一个Fragment实例会被销毁。这里很明显,我们调用tx.addToBackStack(null);将当前的事务添加到了回退栈,所以FragmentOne实例不会被销毁,但是视图层次依然会被销毁,即会调用onDestoryView和onCreateView,证据就是:仔细看上面的效果图,我们在跳转前在文本框输入的内容,在用户Back得到第一个界面的时候不见了。接下来FragmentTwo
package com.zhy.zhy_fragments; import android.app.Fragment; import android.app.FragmentManager; import android.app.FragmentTransaction; import android.os.Bundle; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.Button; public class FragmentTwo extends Fragment implements OnClickListener { private Button mBtn ; @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = inflater.inflate(R.layout.fragment_two, container, false); mBtn = (Button) view.findViewById(R.id.id_fragment_two_btn); mBtn.setOnClickListener(this); return view ; } @Override public void onClick(View v) { FragmentThree fThree = new FragmentThree(); FragmentManager fm = getFragmentManager(); FragmentTransaction tx = fm.beginTransaction(); tx.hide(this); tx.add(R.id.id_content , fThree, "THREE"); // tx.replace(R.id.id_content, fThree, "THREE"); tx.addToBackStack(null); tx.commit(); } }
这里点击时,我们没有使用replace,而是先隐藏了当前的Fragment,然后添加了FragmentThree的实例,最后将事务添加到回退栈。这样做的目的是为了给大家提供一种方案:如果不希望视图重绘该怎么做,请再次仔细看效果图,我们在FragmentTwo的EditText填写的内容,用户Back回来时,数据还在~~~最后FragmentThree就是简单的Toast了:
package com.zhy.zhy_fragments; import android.app.Fragment; import android.os.Bundle; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.Button; import android.widget.Toast; public class FragmentThree extends Fragment implements OnClickListener { private Button mBtn; @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = inflater.inflate(R.layout.fragment_three, container, false); mBtn = (Button) view.findViewById(R.id.id_fragment_three_btn); mBtn.setOnClickListener(this); return view; } @Override public void onClick(View v) { Toast.makeText(getActivity(), " i am a btn in Fragment three", Toast.LENGTH_SHORT).show(); } }
好了,经过上面的介绍,应该已经知道Fragment回退栈是怎么一回事了,以及hide,replace等各自的应用的场景。这里极其注意一点:上面的整体代码不具有任何参考价值,纯粹为了显示回退栈,在后面讲解了Fragment与Activity通信以后,会重构上面的代码!
2、Fragment与Activity通信
因为所有的Fragment都是依附于Activity的,所以通信起来并不复杂,大概归纳为:
a、如果你Activity中包含自己管理的Fragment的引用,可以通过引用直接访问所有的Fragment的public方法
b、如果Activity中未保存任何Fragment的引用,那么没关系,每个Fragment都有一个唯一的TAG或者ID,可以通过getFragmentManager.findFragmentByTag()或者findFragmentById()获得任何Fragment实例,然后进行操作。
c、在Fragment中可以通过getActivity得到当前绑定的Activity的实例,然后进行操作。
注:如果在Fragment中需要Context,可以通过调用getActivity(),如果该Context需要在Activity被销毁后还存在,则使用getActivity().getApplicationContext()。
3、Fragment与Activity通信的最佳实践
因为要考虑Fragment的重复使用,所以必须降低Fragment与Activity的耦合,而且Fragment更不应该直接操作别的Fragment,毕竟Fragment操作应该由它的管理者Activity来决定。
下面我通过两种方式的代码,分别重构,FragmentOne和FragmentTwo的点击事件,以及Activity对点击事件的响应:
首先看FragmentOne
package com.zhy.zhy_fragments; import android.app.Fragment; import android.os.Bundle; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.Button; public class FragmentOne extends Fragment implements OnClickListener { private Button mBtn; /** * 设置按钮点击的回调 * @author zhy * */ public interface FOneBtnClickListener { void onFOneBtnClick(); } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = inflater.inflate(R.layout.fragment_one, container, false); mBtn = (Button) view.findViewById(R.id.id_fragment_one_btn); mBtn.setOnClickListener(this); return view; } /** * 交给宿主Activity处理,如果它希望处理 */ @Override public void onClick(View v) { if (getActivity() instanceof FOneBtnClickListener) { ((FOneBtnClickListener) getActivity()).onFOneBtnClick(); } } }
可以看到现在的FragmentOne不和任何Activity耦合,任何Activity都可以使用;并且我们声明了一个接口,来回调其点击事件,想要管理其点击事件的Activity实现此接口就即可。可以看到我们在onClick中首先判断了当前绑定的Activity是否实现了该接口,如果实现了则调用。再看FragmentTwo
package com.zhy.zhy_fragments; import android.app.Fragment; import android.os.Bundle; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; import android.widget.Button; public class FragmentTwo extends Fragment implements OnClickListener { private Button mBtn ; private FTwoBtnClickListener fTwoBtnClickListener ; public interface FTwoBtnClickListener { void onFTwoBtnClick(); } //设置回调接口 public void setfTwoBtnClickListener(FTwoBtnClickListener fTwoBtnClickListener) { this.fTwoBtnClickListener = fTwoBtnClickListener; } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = inflater.inflate(R.layout.fragment_two, container, false); mBtn = (Button) view.findViewById(R.id.id_fragment_two_btn); mBtn.setOnClickListener(this); return view ; } @Override public void onClick(View v) { if(fTwoBtnClickListener != null) { fTwoBtnClickListener.onFTwoBtnClick(); } } }
与FragmentOne极其类似,但是我们提供了setListener这样的方法,意味着Activity不仅需要实现该接口,还必须显示调用mFTwo.setfTwoBtnClickListener(this)。最后看Activity :
package com.zhy.zhy_fragments; import android.app.Activity; import android.app.FragmentManager; import android.app.FragmentTransaction; import android.os.Bundle; import android.view.Window; import com.zhy.zhy_fragments.FragmentOne.FOneBtnClickListener; import com.zhy.zhy_fragments.FragmentTwo.FTwoBtnClickListener; public class MainActivity extends Activity implements FOneBtnClickListener, FTwoBtnClickListener { private FragmentOne mFOne; private FragmentTwo mFTwo; private FragmentThree mFThree; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE); setContentView(R.layout.activity_main); mFOne = new FragmentOne(); FragmentManager fm = getFragmentManager(); FragmentTransaction tx = fm.beginTransaction(); tx.add(R.id.id_content, mFOne, "ONE"); tx.commit(); } /** * FragmentOne 按钮点击时的回调 */ @Override public void onFOneBtnClick() { if (mFTwo == null) { mFTwo = new FragmentTwo(); mFTwo.setfTwoBtnClickListener(this); } FragmentManager fm = getFragmentManager(); FragmentTransaction tx = fm.beginTransaction(); tx.replace(R.id.id_content, mFTwo, "TWO"); tx.addToBackStack(null); tx.commit(); } /** * FragmentTwo 按钮点击时的回调 */ @Override public void onFTwoBtnClick() { if (mFThree == null) { mFThree = new FragmentThree(); } FragmentManager fm = getFragmentManager(); FragmentTransaction tx = fm.beginTransaction(); tx.hide(mFTwo); tx.add(R.id.id_content, mFThree, "THREE"); // tx.replace(R.id.id_content, fThree, "THREE"); tx.addToBackStack(null); tx.commit(); } }
代码重构结束,与开始的效果一模一样。上面两种通信方式都是值得推荐的,随便选择一种自己喜欢的。这里再提一下:虽然Fragment和Activity可以通过getActivity与findFragmentByTag或者findFragmentById,进行任何操作,甚至在Fragment里面操作另外的Fragment,但是没有特殊理由是绝对不提倡的。Activity担任的是Fragment间类似总线一样的角色,应当由它决定Fragment如何操作。另外虽然Fragment不能响应Intent打开,但是Activity可以,Activity可以接收Intent,然后根据参数判断显示哪个Fragment。4、如何处理运行时配置发生变化
运行时配置发生变化,最常见的就是屏幕发生旋转,如果你不知道如何处理屏幕变化可以参考:Android 屏幕旋转 处理 AsyncTask 和 ProgressDialog 的最佳方案
这里提一下:很多人觉得强制设置屏幕的方向就可以了,但是有一点,当你的应用被至于后台(例如用户点击了home),长时间没有返回的时候,你的应用也会被重新启动。比如上例:如果你把上面的例子你至于FragmentThree界面,然后处于后台状态,长时间后你会发现当你再次通过home打开时,上面FragmentThree与FragmentOne叠加在一起,这就是因为你的Activity重新启动,在原来的FragmentThree上又绘制了一个FragmentOne。
好了,下面看一段代码:
Activity:
package com.zhy.zhy_fragments; import android.app.Activity; import android.app.FragmentManager; import android.app.FragmentTransaction; import android.os.Bundle; import android.view.Window; public class MainActivity extends Activity { private FragmentOne mFOne; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE); setContentView(R.layout.activity_main); mFOne = new FragmentOne(); FragmentManager fm = getFragmentManager(); FragmentTransaction tx = fm.beginTransaction(); tx.add(R.id.id_content, mFOne, "ONE"); tx.commit(); } }
Fragmentpackage com.zhy.zhy_fragments; import android.app.Fragment; import android.os.Bundle; import android.util.Log; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; 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 view = inflater.inflate(R.layout.fragment_one, container, false); return view; } @Override public void onCreate(Bundle savedInstanceState) { // TODO Auto-generated method stub super.onCreate(savedInstanceState); Log.e(TAG, "onCreate"); } @Override public void onDestroyView() { // TODO Auto-generated method stub super.onDestroyView(); Log.e(TAG, "onDestroyView"); } @Override public void onDestroy() { // TODO Auto-generated method stub super.onDestroy(); Log.e(TAG, "onDestroy"); } }
很简单的代码,当你运行之后,不断的旋转屏幕,你会发现每旋转一次屏幕,屏幕上就多了一个FragmentOne的实例,并且后台log会打印出许多套生命周期的回调。类似:
07-20 08:18:46.651: E/FragmentOne(1633): onCreate 07-20 08:18:46.651: E/FragmentOne(1633): onCreate 07-20 08:18:46.651: E/FragmentOne(1633): onCreate 07-20 08:18:46.681: E/FragmentOne(1633): onCreateView 07-20 08:18:46.831: E/FragmentOne(1633): onCreateView 07-20 08:18:46.891: E/FragmentOne(1633): onCreateView
这是为什么呢,因为当屏幕发生旋转,Activity发生重新启动,默认的Activity中的Fragment也会跟着Activity重新创建;这样造成当旋转的时候,本身存在的Fragment会重新启动,然后当执行Activity的onCreate时,又会再次实例化一个新的Fragment,这就是出现的原因。那么如何解决呢:
其实通过检查onCreate的参数Bundle savedInstanceState就可以判断,当前是否发生Activity的重新创建:
默认的savedInstanceState会存储一些数据,包括Fragment的实例:通过打印可以看出:
所以,我们简单改一下代码,只有在savedInstanceState==null时,才进行创建Fragment实例:07-20 08:23:12.952: E/FragmentOne(1782): Bundle[{android:fragments=android.app.FragmentManagerState@40d0b7b8, android:viewHierarchyState=Bundle[{android:focusedViewId=2131230721, android:views=android.util.SparseArray@40d0af68}]}]
package com.zhy.zhy_fragments; import android.app.Activity; import android.app.FragmentManager; import android.app.FragmentTransaction; import android.os.Bundle; import android.util.Log; import android.view.Window; public class MainActivity extends Activity { private static final String TAG = "FragmentOne"; private FragmentOne mFOne; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE); setContentView(R.layout.activity_main); Log.e(TAG, savedInstanceState+""); if(savedInstanceState == null) { mFOne = new FragmentOne(); FragmentManager fm = getFragmentManager(); FragmentTransaction tx = fm.beginTransaction(); tx.add(R.id.id_content, mFOne, "ONE"); tx.commit(); } } }
现在无论进行多次旋转都只会有一个Fragment实例在Activity中。现在还存在一个问题,就是重新绘制时,Fragment发生重建,原本的数据如何保持?
其实和Activity类似,Fragment也有onSaveInstanceState的方法,在此方法中进行保存数据,然后在onCreate或者onCreateView或者onActivityCreated进行恢复都可以。
由于篇幅原因,就不贴测试代码了。
5、Fragmeny与ActionBar和MenuItem集成
Fragment可以添加自己的MenuItem到Activity的ActionBar或者可选菜单中。
a、在Fragment的onCreate中调用 setHasOptionsMenu(true);
b、然后在Fragment子类中实现onCreateOptionsMenu
c、如果希望在Fragment中处理MenuItem的点击,也可以实现onOptionsItemSelected;当然了Activity也可以直接处理该MenuItem的点击事件。
代码:
Fragment
package com.zhy.zhy_fragments; import android.app.Fragment; import android.os.Bundle; import android.view.LayoutInflater; import android.view.Menu; import android.view.MenuInflater; import android.view.MenuItem; import android.view.View; import android.view.ViewGroup; import android.widget.Toast; 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 view = inflater.inflate(R.layout.fragment_one, container, false); return view; } @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.id_menu_fra_test: Toast.makeText(getActivity(), "FragmentMenuItem1", Toast.LENGTH_SHORT).show(); break; } return true; } }
Activitypackage com.zhy.zhy_fragments; import android.app.Activity; import android.app.FragmentManager; import android.app.FragmentTransaction; import android.os.Bundle; import android.util.Log; import android.view.Menu; import android.view.MenuItem; import android.view.Window; import android.widget.Toast; public class MainActivity extends Activity { private static final String TAG = "FragmentOne"; private FragmentOne mFOne; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE); setContentView(R.layout.activity_main); Log.e(TAG, savedInstanceState + ""); if (savedInstanceState == null) { mFOne = new FragmentOne(); FragmentManager fm = getFragmentManager(); FragmentTransaction tx = fm.beginTransaction(); tx.add(R.id.id_content, mFOne, "ONE"); tx.commit(); } } @Override public boolean onCreateOptionsMenu(Menu menu) { super.onCreateOptionsMenu(menu); getMenuInflater().inflate(R.menu.main, menu); return true; } @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.action_settings: Toast.makeText(this, "setting", Toast.LENGTH_SHORT).show(); return true; default: //如果希望Fragment自己处理MenuItem点击事件,一定不要忘了调用super.xxx return super.onOptionsItemSelected(item); } } }
效果图:好了,可以很好的看到,Fragment可以添加MenuItem,也可以自己处理点击~~~
6、没有布局的Fragment的作用
没有布局文件Fragment实际上是为了保存,当Activity重启时,保存大量数据准备的
请参考博客:Android 屏幕旋转 处理 AsyncTask 和 ProgressDialog 的最佳方案
7、使用Fragment创建对话框
这是Google推荐的方式,我也单独写过博客介绍,请参考:Android 官方推荐 : DialogFragment 创建对话框
好了,终于把Fragment相关的联系到一起了,上述基本包含了Fragment所有的用法~~~相信大家如果能够看完,一定有不少的收获~~~
有任何问题,欢迎留言~~~
两篇结束,相信你对Fragment已经有了一定的了解,那么在项目中的最佳实践是什么呢?请移步:Android Fragment 你应该知道的一切
-
Fragment详解之五——Fragment间参数传递
2015-04-09 22:36:28前言:依然没有前言…… 相关文章: 1、《Fragment详解之一——概述》 2、《Fragment详解之二——基本...5、《Fragment详解之五——Fragment间参数传递》6、《Fragment详解之六——如何监听fragment中的回退... -
Fragment嵌套Fragment
2019-04-01 12:57:45问题1、fragment嵌套fragment不显示问题 通常时候,我们制作底部Tab切换,会用到fragment。即一个Activity下,使用4种fragment。这次遇到的问题是关于fragment再次嵌套fragmen的问题,功能需要在其中一个fragment中... -
Android Fragment完全解析,关于碎片你所需知道的一切
2013-05-07 09:33:45我们都知道,Android上的界面展示都是通过Activity实现的,Activity实在是太常用了,我相信大家都已经非常熟悉了,这里就不再赘述。 但是Activity也有它的局限性,同样的界面在...因此,我们今天的主角Fragment登场了 -
Fragment+FragmentTabHost实现仿新浪微博底部菜单栏效果(源码)
2013-06-03 21:34:43Fragment+FragmentTabHost实现仿新浪微博底部菜单栏效果(源码) -
activity嵌套fragment,fragment内嵌fragment之间传值切换fragment
2016-06-07 16:49:25至于fragment的用法,fragment+viewpager的滑动切换代码请参考博文 Android基础:翻页控件Viewpager的使用方法,viewpager+fragment混合使用 fragment与Activity 当在使用activity嵌套fragment,... -
Fragment详解之六——如何监听fragment中的回退事件与怎样保存fragment状态
2015-04-12 20:36:18前言:计划总是赶不上变化,无论结局怎样,只要一直跟随自己的内心,不放弃,总有...3、《Fragment详解之三——管理Fragment(1)》 4、《Fragment详解之四——管理Fragment(2)》 5、《Fragment详解之五——Fragme... -
Fragment Fragment生命周期 Fragment详解 Fragment生命周期详解
2016-03-02 13:50:49Fragment Fragment生命周期 Fragment详解 Fragment生命周期详解 -
fragment实现选项卡界面
2013-11-24 19:34:56在android 2.x时代,我们可能会地使用ActivityGroup来实现这种,但是随着jelly bean的市场份额超过50%,我们会发现有一种新的组建出现了,它叫Fragment...而这种底部选项卡的风格界面的实现也由ActivityGroup转向了... -
Fragment里边嵌套Fragment
2018-09-24 12:08:55一、如何切换Fragment ①、了解FragmentManager FragmentManager fm = getSupportFragmentManager(); 作用:管理Fragment的显示,存储。 FragmentManger中有三个容器。 第一个用来存储,Fragment的View,并控制... -
安卓fragment跳转activity,fragment跳转fragment,activity跳转fragment
2016-03-28 22:05:33Activity中加载不同的fragment /Fragment中加载不同的fragment主Activity中加载(切换)多个fragment(也可以理解为activity跳转fragment)或主fragment中加载(切换)多个fragmentActivity布局中要有一个fragment... -
fragment内嵌fragment之间传值+切换fragment
2018-05-30 11:59:42跳转: 从一个Fragment跳转到另一个Fragment android从fragment跳转到...activity嵌套fragment,fragment内嵌fragment之间传值切换fragment 嵌套Fragment的使用及常见错误 android 布局中Fragment嵌套Fragmen... -
ViewPager 详解(五)-----使用Fragment实现ViewPager滑动
2014-08-18 15:03:51前言:前几篇文章讲解了ViewPager的普通实现方法,但android官方最推荐的一种实现方法却是使用fragment,下面我们使用fragment来重新实现一下第一篇《ViewPager 详解(一)---基本入门》所实现的效果。 系列文章... -
Fragment详解之四——管理Fragment(2)
2015-04-08 22:32:31前言:这篇依然没有前言…… 相关文章: 1、《Fragment详解之一——概述》 2、《Fragment详解之二——基本...5、《Fragment详解之五——Fragment间参数传递》6、《Fragment详解之六——如何监听fragment中的... -
Android Fragment 你应该知道的一切
2015-01-12 01:56:32转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/42628537,本文出自:【张鸿洋的博客】很久以前写过两篇Fragment的介绍,主要就是介绍其功能:Android Fragment 真正的完全解析(上)和Android... -
Fragment嵌套Fragment时候。子类fragment调用父容器Fragment方法
2017-08-11 12:07:36业务场景:有的时候我们的页面可能是Activity 嵌套多个Fragment ..其中某个Fragment 又嵌套多个Fragment。 其中某个子Fragment 定义为 NewsFragment 。父容器 Fragment 定义为 ShouYeMainFragment ... -
Fragment中套着Fragment如何在子Fragment中拿到父Fragment
2020-01-15 15:00:27一个Activity中套着一个Fragment Fragment又用 viewPager+TabHost(这都2020了) 领导们还坚持着用TabHost viewPager里面又套着Fragment 需求是要:要在ViewPager里面第三个Fragment上的控件点击后切换到第二个Tab .... -
Fragment 向Fragment传值
2019-01-07 18:08:33方式一:可以调用findFragmentById方法根据id获取到fragment的对象,调用fragment中的方法赋值 在LeftFragment传值 以下写法: RightFragment rightFragment = getFragmentManager().findFragmentById(R.id.fragm.... -
Fragment使用姿势之NoFragment
2017-01-15 15:39:36NoFragment支持传统Fragment用法,支持startFragmentForResult,支持一个Fragment启动多个实例,自持自动维护Back Stack,顺序不会错乱,支持Fragment中直接setToolbar()、setTitle()、displayHomeButton()、支持... -
Fragment 跳转到指定的Fragment 与 Activity跳转到指定的Fragment 的方法
2019-09-02 14:56:48Fragment 跳转到指定的Fragment 主要分为2中情况 1 同一个Activity上的Fragment 跳转到指定Fragment 例如MainActivity 上的Fragment 跳转问题 2 不在同一个Activity的2个Fragment 跳转 如果对Fragment 跳转问题... -
android中ViewPager+Fragment 中有fragment嵌套fragment
2016-10-08 07:35:55需求是 用ViewPager + Fragment(有3个Fragment) 实现页面滚动切换, 3个Fragment中其中有一个fragment中又嵌套了3个子fragment,最后滑动时, 界面出现了错位,要怎么解决 -
Fragment中嵌套Fragment
2016-12-02 11:30:57在fragment里面嵌套Fragment,最开始使用Fragment的hide,show等方法一直失败,,如图,message是一个fragment,在里面又有两个子fragment,(Firends和follow),后来把两个fragment改ViewPager方式进行切换,这 -
获取FragmentActivity当前的fragment是哪个fragment
2017-10-28 15:55:16现在的android主界面,普遍离不开FragmentActivity和Fragment。也经常会碰到这么一个问题,从其他界面跳回主界面时,无法分辨出回到了哪个fragment里面。一般我们会在fragment·的onResume 方法里面做一些处理,如果... -
Android进阶(十二)Fragment VS Activity
2015-06-14 21:11:14可以把Fragment想成Activity中的模块,这个模块有自己的布局,有自己的生命周期,单独处理自己的输入,在Activity运行的时候可以加载或者移除Fragment模块。 可以把Fragment设计成可以在多个Activity中复用 -
fragment怎么嵌套fragment
2015-10-19 02:48:01我弄了一个fragment,底部有3个页面,在第一个页面再加fragment做一个顶部的滑动导航,可是加了顶部导航的代码之后,底部第一个页面的replace、add、show都出错了,应该怎么办!!
-
Unity游戏开发之数字华容道
-
Ascend Pytorch算子功能验证
-
C++零基础学习的教程黑马程序员(11)P77-P85通讯录系统,添加修改,删除联系人,全局区,代码区
-
基于多尺度融合的深度人群计数算法
-
在windows10下的ubuntu启动docker
-
节省服务器内存空间:flask上传图片,MD5哈希,确保图片唯一
-
Cascading optofluidic phase modulators for performance enhancement in refractive adaptive optics
-
UE4游戏逆向与安全+FPS游戏逆向与安全
-
SubstancePainter插件开发-基础入门
-
TexLive与TexStudio2020下载,安装及配置(亲测莫问题)
-
镍钛合金激光选区熔化成形技术研究进展
-
转行做IT-第10章 常用类-String、static、Array等
-
算法导论(基础知识)——编程大牛的必经之路
-
扫雷,蜘蛛纸牌,可在win10上运行
-
python办公自动化技巧
-
PHP实现爬虫
-
balenaEtcher-Setup-1.5.115.exe
-
LED光源的光谱与色域面积关系
-
微信支付2021系列之扫码支付一学就会java版
-
Spring--整合Mybatis及声明式事务