`
疯狂的犀牛
  • 浏览: 34622 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

DialogFragment详解

DialogDialogFragmentFragment
阅读更多 


 


DialogFragment


一个片段显示一个对话窗口，漂浮在其活动的窗口之上。该片段包含一个Dialog的对象，它基于片段的状态适当地显示。应通过这里的API来控制对话框（什么时候显示，隐藏，消失），而不是直接调用对话框。

   实现类应该重写这个类，并实现onCreateView（LayoutInflater，ViewGroup的，Bundle）提供对话框的内容。此外，他们可以覆盖onCreateDialog（Bundle），以创建一个完全自定义的对话框，如作为一个有自身的内容的AlertDialog。


下面讨论以下几个方面：

1.生命周期
2.基本对话框
3.警告对话框
4.在对话框和嵌入之间选择


 


生命周期


    DialogFragment做各种事情保持片段的生命周期的驱动，而不是对话框。需要注意的是，对话框是一般自治实体 - 他们自己的窗口，接受自己的输入事件，往往决定自己何时消失（通过接收返回键的事件或用户点击一个按钮）。


    DialogFragment需求确保保持片段与对话框发生的状态的一致。要做到这一点，它观察来自对话框的撤销事件，并在他们出现的时候消除其自身的状态。这意味着你应该使用show（FragmentManager，String）或show（FragmentTransaction，String）添加一DialogFragment实例到你的UI，因为这些持续跟踪着当对话框被撤销DialogFragment应该如何删除它自己。


 


基本对话框
简单DialogFragment的用途是作为一个片段视图层次的浮动容器。一个简单的实现可能看起来像这样：


	1.主Activity：


 


public class FragementDialogTestActivity extends Activity {
	private int mStackLevel = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.fragment_dialog);

        View tv = findViewById(R.id.text);
        ((TextView)tv).setText("Example of displaying dialogs with a DialogFragment.  "
                + "Press the show button below to see the first dialog; pressing "
                + "successive show buttons will display other dialog styles as a "
                + "stack, with dismissing or back going to the previous dialog.");

        // Watch for button clicks.
        Button button = (Button)findViewById(R.id.show);
        button.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                showDialog();
            }
        });

        if (savedInstanceState != null) {
            mStackLevel = savedInstanceState.getInt("level");
        }
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putInt("level", mStackLevel);
    }
    
    
    void showDialog() {
        mStackLevel++;

        // DialogFragment.show() will take care of adding the fragment
        // in a transaction.  We also want to remove any currently showing
        // dialog, so make our own transaction and take care of that here.
        FragmentTransaction ft = getFragmentManager().beginTransaction();
        Fragment prev = getFragmentManager().findFragmentByTag("dialog");
        if (prev != null) {
            ft.remove(prev);
        }
        
        ft.addToBackStack(null);

        // Create and show the dialog.
        DialogFragment newFragment = MyDialogFragment.newInstance(mStackLevel);
        newFragment.show(ft, "dialog");
    }
}


 2.主Activity布局文件：


 


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello" />

    <Button
        android:id="@+id/show_dialog"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="显示对话框" />

</LinearLayout>


 3.对话框fragment类：


 


public class MyDialogFragment extends DialogFragment {
	int mNum;

    /**
     * Create a new instance of MyDialogFragment, providing "num"
     * as an argument.
     */
    static MyDialogFragment newInstance(int num) {
        MyDialogFragment f = new MyDialogFragment();

        // Supply num input as an argument.
        Bundle args = new Bundle();
        args.putInt("num", num);
        f.setArguments(args);

        return f;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mNum = getArguments().getInt("num");

        // Pick a style based on the num.
        int style = DialogFragment.STYLE_NORMAL, theme = 0;
        switch ((mNum-1)%6) {
            case 1: style = DialogFragment.STYLE_NO_TITLE; break;
            case 2: style = DialogFragment.STYLE_NO_FRAME; break;
            case 3: style = DialogFragment.STYLE_NO_INPUT; break;
            case 4: style = DialogFragment.STYLE_NORMAL; break;
            case 5: style = DialogFragment.STYLE_NORMAL; break;
            case 6: style = DialogFragment.STYLE_NO_TITLE; break;
            case 7: style = DialogFragment.STYLE_NO_FRAME; break;
            case 8: style = DialogFragment.STYLE_NORMAL; break;
        }
        switch ((mNum-1)%6) {
            case 4: theme = android.R.style.Theme_Holo; break;
            case 5: theme = android.R.style.Theme_Holo_Light_Dialog; break;
            case 6: theme = android.R.style.Theme_Holo_Light; break;
            case 7: theme = android.R.style.Theme_Holo_Light_Panel; break;
            case 8: theme = android.R.style.Theme_Holo_Light; break;
        }
        setStyle(style, theme);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.fragment_dialog, container, false);
        View tv = v.findViewById(R.id.text);
        ((TextView)tv).setText("Dialog #" + mNum + ": using style "
                + getNameForNum(mNum));

        // Watch for button clicks.
        Button button = (Button)v.findViewById(R.id.show);
        button.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                // When button is clicked, call up to owning activity.
                ((FragementDialogTestActivity)getActivity()).showDialog();
            }
        });

        return v;
    }
    
    public String getNameForNum(int num) {
        switch ((num-1)%6) {
            case 1: return "STYLE_NO_TITLE";
            case 2: return "STYLE_NO_FRAME";
            case 3: return "STYLE_NO_INPUT (this window can't receive input, so "
                    + "you will need to press the bottom show button)";
            case 4: return "STYLE_NORMAL with dark fullscreen theme";
            case 5: return "STYLE_NORMAL with light theme";
            case 6: return "STYLE_NO_TITLE with light theme";
            case 7: return "STYLE_NO_FRAME with light theme";
            case 8: return "STYLE_NORMAL with light fullscreen theme";
        }
        return "STYLE_NORMAL";
    }
    

}


 4.对话框fragment的布局文件：


 


<?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:id="@+id/text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textAppearance="?android:attr/textAppearanceLarge" />

    <Button
        android:id="@+id/show"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Button" />

</LinearLayout>


 


 


警告对话框

取代实现onCreateView（LayoutInflater，ViewGroup，Bundle）方法生成一个对话框内的视图层次，而是实现onCreateDialog（Bundle）创建自己的自定义对话框对象。

这是最有用的，创建一个AlertDialog，让您显示一个由fragment管理的标准的用户警告。一个简单的例子的实现是：


1.主Activity：


 


public class FragementDialogTestActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Watch for button clicks.
        Button button = (Button)findViewById(R.id.show_dialog);
        button.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                showDialog();
            }
        });
    }

   
    
    void showDialog() {
        DialogFragment newFragment = MyAlertDialogFragment.newInstance("Alert Dialog");
        newFragment.show(getFragmentManager(), "dialog");
    }

    public void doPositiveClick() {
        // Do stuff here.
        Log.i("FragmentAlertDialog", "Positive click!");
    }

    public void doNegativeClick() {
        // Do stuff here.
        Log.i("FragmentAlertDialog", "Negative click!");
    }
}


 2.主Activity布局文件：


 


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <TextView
        android:id="@+id/text"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="我的自定义警告框"/>

    <Button
        android:id="@+id/show_dialog"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="显示警告框" />

</LinearLayout>

 

3.我的Alert 对话框类：


 


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <TextView
        android:id="@+id/text"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="我的自定义警告框"/>

    <Button
        android:id="@+id/show_dialog"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="显示警告框" />

</LinearLayout>

 

对话和嵌入之间的选择



一个DialogFragment仍然可以使用作为一个正常的fragment，如果需要的话。如果你有一个片段，在某些情况下，应被视为一个对话框而在其他情况下嵌入在一个更大的用户界面中显示，这是非常有用的。这种行为通常会被自动为您选择，取决于你是如何使用片段的，但你也可以使用setShowsDialog(boolean)进行定制。

例如，这里是一个简单的对话片段：


 


public class MyDialogFragment extends DialogFragment {
    static MyDialogFragment newInstance() {
        return new MyDialogFragment();
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.hello_world, container, false);
        View tv = v.findViewById(R.id.text);
        ((TextView)tv).setText("This is an instance of MyDialogFragment");
        return v;
    }
}


 


一个fragment的实例可以被创建并被显示为一个对话框：


 


void showDialog() {
    // Create the fragment and show it as a dialog.
    DialogFragment newFragment = MyDialogFragment.newInstance();
    newFragment.show(getFragmentManager(), "dialog");
}

 

 


它也可以被当做内容添加到视图层次中：


 


FragmentTransaction ft = getFragmentManager().beginTransaction();
DialogFragment newFragment = MyDialogFragment.newInstance();
ft.add(R.id.embedded, newFragment);


 


 


总结：


 


1.




  


  

    
    
分享到：
      
      
    

  


  

    

      
      
      
    

  

  

        
  

    
  

    
评论

    
    
    
    
  


  

    
发表评论

            
   您还没有登录,请您登录后再发表评论 

      

  

  





  

    
相关推荐

    
    
    
        
        
    
          
    
            
            
    
              
                
                
                
    
                  
    
                    
                      详解Android应用中DialogFragment的基本用法
                    
                  
    
                  
    在Android开发中，DialogFragment是Android SDK提供的一种用于在应用程序中展示对话框的组件。它是一个Fragment的子类，能够方便地与Activity交互，并且具备了管理对话框生命周期的能力。相比传统的Dialog，...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      DialogFragment运行原理及使用方法详解
                    
                  
    
                  
    一、为什么要学习 DialogFragment 你还在用 Dialog 吗？你还在经常烦恼于屏幕翻转的时候，Dialog 的各种奇葩情况吗？你想降低耦合吗？如果你有其中的一个烦恼，那么恭喜你，遇见了 DialogFragment ，他恰巧就解决了...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Android各种控件详解
                    
                  
    
                  
    在Activity中，通过DialogFragment或AlertDialog.Builder来创建和显示对话框。  以上就是Android开发中常用的控件及其使用方式。熟练掌握这些控件的使用，可以创建出丰富多样的用户界面，提升应用的用户体验。
    
                
    
                
              
                
                
                
    
                  
    
                    
                      《详解Dialog——基础元素构建》源码
                    
                  
    
                  
    这篇博客《详解Dialog——基础元素构建》的源码深入探讨了如何创建和自定义Dialog，提供了丰富的实践案例。以下是根据博客内容和源码解析的一些关键知识点：  1. **Dialog基本使用**：  Android中的Dialog是基于...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Android Dialog使用详解
                    
                  
    
                  
    如果你需要一个具有特殊布局或行为的对话框，你可以继承`DialogFragment`类，并重写`onCreateDialog()`方法。在这个方法里，你可以使用LayoutInflater创建一个自定义的视图，然后返回一个使用该视图的Dialog。  ```...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Pro Android学习：Dialog小例子
                    
                  
    
                  
    在“ProDialogDemo”中，可能包含了如何在Fragment中展示DialogFragment的例子，这涉及到了`DialogFragment.show(FragmentManager, String)`方法的使用，以及如何在DialogFragment内处理用户交互。  此外，你可能还...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Android自适应屏幕大小和layout布局(横屏竖屏)
                    
                  
    
                  
    ### Android自适应屏幕大小与Layout布局详解  #### 一、不同屏幕尺寸的适应性设计  在Android应用开发中，为了确保应用能够在各种不同尺寸的屏幕上正常显示，开发者需要考虑多种屏幕分辨率的情况。例如，常见的屏幕...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      《详解Dialog 三   自定义对话框视图及参数传递》源码
                    
                  
    
                  
    在Android SDK中，Dialog通常通过继承`AlertDialog.Builder`或者直接使用`DialogFragment`来创建。基础的Dialog可以通过调用`setTitle()`, `setMessage()`, `setPositiveButton()`, `setNegativeButton()`等方法设置...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Android如何自定义升级对话框示例详解
                    
                  
    
                  
    想要使用做出这样一个DialogFragment ，需要自定义一个View，然后将该View传入到该Dialog中 先定义布局，一个TextView用于标题，一个TextView用于升级内容阐述，一个ImageView，一个确认升级的按钮  &lt;?xml ...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Android 日期和时间的使用实例详解
                    
                  
    
                  
     - 首先，创建一个继承自`DialogFragment`的类，并实现`TimePickerDialog.OnTimeSetListener`接口。在这个接口中，你需要定义`onTimeSet()`方法，该方法会在用户设置时间后被调用。  ```java  public static class ...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      自定义弹出确认框
                    
                  
    
                  
    通过自定义布局和DialogFragment，我们可以轻松实现各种功能和视觉效果，提升应用的整体质量。在`CustomDialog`项目中，你将找到具体的代码实现，可以作为自定义Dialog的一个起点，进一步扩展和优化以适应你的项目...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      android dialog自定义实例详解
                    
                  
    
                  
    接下来，我们需要创建一个自定义Dialog类，继承自`DialogFragment`。在这个类中，我们将初始化视图并设置按钮的点击事件。以下是一个基本的`MyDialog`类实现：  ```java public class MyDialog extends ...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Android 对话框(Dialog)大全详解及示例代码
                    
                  
    
                  
    DialogFragment允许你在单独的布局文件中定义对话框的内容，并提供更灵活的控制。  4. **对话框的生命周期**  对话框的生命周期与Activity紧密相关。当Activity销毁时，所有与之关联的Dialog也会被销毁。因此，你...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      详解Android中Fragment的两种创建方式
                    
                  
    
                  
    `DialogFragment`用于展示对话框样式界面，`ListFragment`包含一个列表视图，而`PreferenceFragment`则用于展示设置界面中的偏好项。  在实际开发中，通常需要至少实现`onCreate()`和`onCreateView()`方法。`...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      最新完整的android-support-v4
                    
                  
    
                  
    《Android Support Library v4详解》  Android Support Library v4，简称v4库，是Google为开发者提供的一款重要的兼容库，其主要目的是为了帮助开发者解决在不同版本Android系统间实现功能一致性的问题。它包含了...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      安卓app开发项目-所有Dialog对话框(源码).zip
                    
                  
    
                  
    以下是基于Dialog对话框的知识点详解：  1. **AlertDialog**：这是最常见的对话框类型，通常包含一个标题、一个信息文本、一个否定按钮和一个肯定按钮。开发者可以自定义标题、消息、按钮的文字和回调函数。  2. **...
    
                
    
                
              
            
    
          
    
        
    
    

  





  
    Magicbox
  













      

      
        

          

            

              

                

                
              

            

            


            

          

        

            
    

    
    
  

  



   Global site tag (gtag.js) - Google Analytics