J'essaye de montrer un DialogFragment presque plein écran. Mais je ne suis pas en mesure de le faire.

La façon dont je montre le fragment provient directement de la documentation du développeur Android

FragmentManager f = ((Activity)getContext()).getFragmentManager();
FragmentTransaction ft = f.beginTransaction();
Fragment prev = f.findFragmentByTag("dialog");
if (prev != null) {
    ft.remove(prev);
}
ft.addToBackStack(null);

// Create and show the dialog.
DialogFragment newFragment = new DetailsDialogFragment();
newFragment.show(ft, "dialog");

Je sais naïvement essayé de définir le RelativeLayout dans le fragment sur fill_parent et certains minWidth et minHeight.

<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"  
    android:minWidth="1000px" 
    android:minHeight="600px"
    android:background="#ff0000">

Je saurais m'attendre à ce que DialogFragment remplisse la majorité de l'écran. Mais je ne semble redimensionner que verticalement mais seulement jusqu'à une certaine largeur fixe horizontalement.

J'ai également essayé de définir les attributs de fenêtre dans le code, comme suggéré ici: http://groups.google.com/group/android-developers/browse_thread/thread/f0bb813f643604ec . Mais cela n'a pas aidé non plus.

Je ne comprends probablement pas quelque chose sur la façon dont Android gère les dialogues, car je suis tout nouveau dans ce domaine. Comment puis-je faire quelque chose comme ça? Existe-t-il d'autres moyens d'atteindre mon objectif?

Appareil Android:
Asus EeePad Transformer
Android 3.0.1

Mise à jour: j'ai maintenant réussi à le mettre en plein écran, avec le code suivant dans le fragment

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setStyle(STYLE_NO_FRAME, android.R.style.Theme_Holo_Light);
}

Malheureusement, ce n'est pas tout à fait ce que je veux. J'ai vraiment besoin d'un petit "rembourrage" autour de la boîte de dialogue pour afficher l'arrière-plan.

Des idées pour y parvenir?

Essayez de passer à un LinearLayoutau lieu de RelativeLayout. Je visais l'API 3.0 Honeycomb lors des tests.

public class FragmentDialog extends Activity {

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

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

@Override
public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
}

void showDialog() {
    FragmentTransaction ft = getFragmentManager().beginTransaction();
    DialogFragment newFragment = MyDialogFragment.newInstance();
    newFragment.show(ft, "dialog");
}

public static class MyDialogFragment extends DialogFragment {

    static MyDialogFragment newInstance() {
        MyDialogFragment f = new MyDialogFragment();
        return f;
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.fragment_dialog, container, false);
        return v;
    }

}
}

et les mises en page : fragment_dialog.xml

<?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:minWidth="1000dp"  
    android:minHeight="1000dp"> 
 </LinearLayout> 

main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" 
    android:layout_width="match_parent" 
    android:layout_height="match_parent"
    android:background="#ffffff">
    <Button android:id="@+id/show"
        android:layout_width="wrap_content" 
        android:layout_height="wrap_content"
        android:layout_weight="0"
        android:text="show">
    </Button>
</LinearLayout>

Pour afficher DialogFragment en plein écran

Remplacez onStartvotre DialogFragment comme ceci:

@Override
public void onStart()
{
    super.onStart();
    Dialog dialog = getDialog();
    if (dialog != null)
    {
        int width = ViewGroup.LayoutParams.MATCH_PARENT;
        int height = ViewGroup.LayoutParams.MATCH_PARENT;
        dialog.getWindow().setLayout(width, height);
    }
}

Et merci beaucoup à ce post: Le-mystère-des-androïdes-fragments-de-dialogue-plein-écran

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

    setStyle(DialogFragment.STYLE_NORMAL,
             android.R.style.Theme_Black_NoTitleBar_Fullscreen);
}

Selon ce lien, le plein écran de DialogFragment montre un rembourrage sur les côtés, cela fonctionnera comme un charme.

@Override
public Dialog onCreateDialog(final Bundle savedInstanceState) {

    // the content
    final RelativeLayout root = new RelativeLayout(getActivity());
    root.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));

    // creating the fullscreen dialog
    final Dialog dialog = new Dialog(getActivity());
    dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
    dialog.setContentView(root);
    dialog.getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
    dialog.getWindow().setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);

    return dialog;
}

Créer un DialogFragment plein écran en utilisant uniquement le style

Première solution

    <style name="FullScreenDialog" parent="Theme.AppCompat.Light.Dialog">
        <item name="android:backgroundDimEnabled">false</item>
        <item name="android:windowNoTitle">true</item>
        <item name="android:padding">0dp</item>
        <item name="android:windowIsFloating">false</item>
        <item name="android:windowBackground">@android:color/transparent</item>
        <item name="android:windowCloseOnTouchOutside">false</item>
    </style>

2. Ajoutez à votre DialogFragment:

@Override
public int getTheme() {
    return R.style.FullScreenDialog;
}

Solution alternative

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    setStyle(DialogFragment.STYLE_NO_FRAME, R.style.FullScreenDialog)
}

Dans mon cas, j'ai utilisé l'approche suivante:

    @Override
    public void onStart() {
        super.onStart();
        getDialog().getWindow().setLayout(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
    }
}

De plus LinearLayout pour remplir tout l'espace avec du contenu.

Mais il y avait encore de petits écarts entre les bords gauche et droit de la boîte de dialogue et les bords de l'écran sur certains appareils Lollipop + (par exemple Nexus 9).

Ce n'était pas évident mais j'ai finalement compris que pour le rendre pleine largeur sur tous les appareils et plates-formes , l'arrière-plan de la fenêtre devrait être spécifié à l'intérieur de styles.xml comme suit:

<style name="Dialog.NoTitle" parent="Theme.AppCompat.Dialog">
    <item name="android:windowNoTitle">true</item>
    <item name="android:padding">0dp</item>
    <item name="android:windowBackground">@color/window_bg</item>
</style>

Et bien sûr, ce style doit être utilisé lorsque nous créons la boîte de dialogue comme suit:

    public static DialogFragment createNoTitleDlg() {
        DialogFragment frag = new Some_Dialog_Frag();
        frag.setStyle(DialogFragment.STYLE_NO_TITLE, R.style.Dialog_NoTitle);
        return frag;
}

J'ai rencontré le problème avant lors de l'utilisation d'une boîte de dialogue plein écran Fragment: il y a toujours un rembourrage tout en ayant défini le plein écran. essayez ce code dans la méthode onActivityCreated () de dialogFragment:

public void onActivityCreated(Bundle savedInstanceState)
{   
    super.onActivityCreated(savedInstanceState);
    Window window = getDialog().getWindow();
    LayoutParams attributes = window.getAttributes();
    //must setBackgroundDrawable(TRANSPARENT) in onActivityCreated()
    window.setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
    if (needFullScreen)
    {
        window.setLayout(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
    }
}

Dans la mesure où l'API Android a été mise à jour, la méthode suggérée pour afficher une boîte de dialogue en plein écran est la suivante:

FragmentTransaction transaction = this.mFragmentManager.beginTransaction();
// For a little polish, specify a transition animation
transaction.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
// To make it fullscreen, use the 'content' root view as the container
// for the fragment, which is always the root view for the activity
transaction.add(android.R.id.content, this.mFragmentToShow).commit();

sinon, si vous ne voulez pas qu'il soit affiché en plein écran, vous pouvez faire de cette façon:

this.mFragmentToShow.show(this.mFragmentManager, LOGTAG);

J'espère que ça aide.

ÉDITER

Sachez que la solution que j'ai donnée fonctionne mais présente une faiblesse qui peut parfois être gênante. L'ajout de DialogFragment au android.R.id.contentconteneur ne vous permettra pas de gérer DialogFragment#setCancelable()correctement la fonctionnalité et pourrait également entraîner des comportements inattendus lors de l'ajout du DialogFragment lui-même à la pile arrière.

Je vous ai donc suggéré de changer simplement le style de votre DialogFragment dans la méthode onCreate comme suit:

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setStyle(DialogFragment.STYLE_NORMAL, android.R.style.Theme_Translucent_NoTitleBar);
}

J'espère que ça aide.

Essayez d'utiliser setStyle () dans onCreate et remplacez onCreateDialog make dialog sans titre

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);    
    setStyle(DialogFragment.STYLE_NORMAL, android.R.style.Theme);        
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    Dialog dialog = super.onCreateDialog(savedInstanceState);
    dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);        
    return dialog;
}

ou remplacez simplement onCreate () et setStyle avec le code.

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);    
    setStyle(DialogFragment.STYLE_NO_TITLE, android.R.style.Theme);        
}

Cela peut en effet dépendre de la manière dont la mise en page est définie. Mais pour s'assurer que la boîte de dialogue obtient la taille requise, la meilleure solution est de fournir les LayoutParams une fois la boîte de dialogue affichée (et non lors de la création). Sur un DialogFragment, la boîte de dialogue est affichée sur la méthode onStart , donc une méthode valide pour obtenir la pleine largeur est:

@Override public void onStart() {
    super.onStart();
    Dialog d = getDialog();
    if (d!=null){
        d.getWindow().setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
    }
}

Pour fournir également un thème, ou un style, comme un style NO_TITLE, le meilleur emplacement est sur la méthode onCreate :

@Override public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setStyle(STYLE_NO_TITLE, android.R.style.Theme_Holo_Light_Dialog);
}

Remarque: même on peut trouver la bonne réponse ici. Mais je veux clarifier une confusion.

Utilisez le code ci-dessous pour android.app.DialogFragment

@Override
public void onStart()
{
    super.onStart();
    Dialog dialog = getDialog();
    if (dialog != null)
    {
        int width = ViewGroup.LayoutParams.MATCH_PARENT;
        int height = ViewGroup.LayoutParams.MATCH_PARENT;
        dialog.getWindow().setLayout(width, height);
    }
}

Utilisez le code ci-dessous pour android.support.v4.app.DialogFragment

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setStyle(DialogFragment.STYLE_NORMAL, android.R.style.Theme_Black_NoTitleBar_Fullscreen);
}

Et la version kotlin!

override fun onStart() {
    super.onStart()
    dialog?.let {
        val width = ViewGroup.LayoutParams.MATCH_PARENT
        val height = ViewGroup.LayoutParams.MATCH_PARENT
        it.window?.setLayout(width, height)
    }
}

Voici la solution pour résoudre ce problème:

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    Dialog dialog = super.onCreateDialog(savedInstanceState);    
    dialog.getWindow().requestFeature(Window.FEATURE_NO_TITLE);   

    return dialog;
}

@Override
public void onStart() {
    super.onStart();
    Dialog dialog = getDialog();
    if (dialog != null) {
            dialog.getWindow().setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
            dialog.getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
    }
}

Créez le thème ci-dessous dans votre style.xml:

<style name="DialogTheme" parent="Theme.AppCompat.Light.DarkActionBar">
   <item name="android:paddingRight">0dp</item>
   <item name="android:paddingLeft">0dp</item>
   <item name="android:layout_width">match_parent</item>
   <item name="android:windowNoTitle">true</item>
</style>

puis définissez le style dans DialogFragment

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setStyle(DialogFragment.STYLE_NO_TITLE, R.style.DialogTheme);
}

Chirag Nagariya a raison sauf l'ajout '_Fullscreen'. il peut être résolu en utilisant n'importe quel style de base qui n'est pas dérivé du style Dialog. «android.R.style.Theme_Black_NoTitleBar» peut également être utilisé.

Au cas où quelqu'un d'autre rencontrerait cela, j'ai eu une expérience similaire à celle-ci, mais il s'avère que le problème était que j'avais oublié de renvoyer la vue gonflée à partir de onCreateView (à la place, en retournant le super.onCreateView par défaut). J'ai simplement renvoyé la vue gonflée correcte et cela a résolu le problème.

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    Dialog dialog = new Dialog(getActivity(), android.R.style.Theme_Holo_Light);
    dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);

    return dialog;
}

Cette solution applique un thème plein écran sur la boîte de dialogue, qui est similaire au setStyle de Chirag dans onCreate. Un inconvénient est que savedInstanceState n'est pas utilisé.

Essayez ceci pour une boîte de dialogue de fragment commune pour plusieurs utilisations. J'espère que cela vous aidera à parier

public class DialogFragment extends DialogFragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View rootView = inflater.inflate(R.layout.fragment_visit_history_main, container, false);

        getDialog().getWindow().requestFeature(Window.FEATURE_NO_TITLE);
        getDialog().getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
        initializeUI(rootView);
        return rootView;
    }

    @Override
    public void onStart() {
        super.onStart();
        Dialog dialog = getDialog();
        if (dialog != null) {
            int width = ViewGroup.LayoutParams.MATCH_PARENT;
            int height = ViewGroup.LayoutParams.MATCH_PARENT;
            dialog.getWindow().setLayout(width, height);
        }
    }
    private void initializeUI(View rootView) {
    //getChildFragmentManager().beginTransaction().replace(R.id.fv_container,FragmentVisitHistory.getInstance(), AppConstant.FRAGMENT_VISIT_HISTORY).commit();
    }
}

Voici ce que vous devez définir pour fragmenter:

/* theme is optional, I am using leanback... */
setStyle(STYLE_NORMAL, R.style.AppTheme_Leanback);

Dans ton cas:

DialogFragment newFragment = new DetailsDialogFragment();
newFragment.setStyle(STYLE_NORMAL, R.style.AppTheme_Leanback);
newFragment.show(ft, "dialog");

Et pourquoi? Parce que DialogFragment (lorsqu'il n'est pas indiqué explicitement), utilisera ses styles internes qui y envelopperont votre mise en page personnalisée (pas de plein écran, etc.).

Et la mise en page? Aucun moyen de piratage nécessaire, cela fonctionne très bien:

<?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="match_parent">
    ...
</RelativeLayout>

Prendre plaisir

Je suis très en retard pour répondre à cette question mais je veux partager cette réponse afin qu'à l'avenir tout le monde puisse l'utiliser.

J'ai utilisé ce code dans mon projet, il fonctionne en version inférieure ainsi qu'en version supérieure.

Utilisez simplement ce thème dans onCreateDialog () comme ceci:

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {

    View view = getActivity().getLayoutInflater().inflate(R.layout.dialog_pump_details, null);

    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity(), android.R.style.Theme_Black_NoTitleBar_Fullscreen);
    return builder.create();
}

android.R.style.Theme_Black_NoTitleBar_Fullscreen - Voici le code source de ce thème que vous pouvez voir que ce thème suffit à faire apparaître DialogFragment en plein écran.

<!-- Variant of {@link #Theme_Black} that has no title bar and
     no status bar.  This theme
     sets {@link android.R.attr#windowFullscreen} to true.  -->
<style name="Theme.Black.NoTitleBar.Fullscreen">
    <item name="windowFullscreen">true</item>
    <item name="windowContentOverlay">@null</item>
</style>

S'il vous plaît laissez-moi savoir si quelqu'un est confronté à un problème. J'espère que cela est utile. Merci :)

La méthode suivante fonctionnera même si vous travaillez sur une mise en page relative. Suivez les étapes suivantes:

1. Accédez à l'éditeur de thème (disponible sous Outils-> Android -> Éditeur de thème)
2. Sélectionnez Afficher tous les thèmes. Sélectionnez celui avec AppCompat.Dialog
3. Choisissez l'option arrière-plan de la fenêtre android si vous voulez qu'il soit d'un arrière-plan coloré spécifique ou transparent.
4. Sélectionnez la couleur et cliquez sur OK.Sélectionnez un nom pour le nouveau thème.

5. Allez dans styles.xml puis sous le thème que vous venez d'ajouter, ajoutez ces deux attributs:

   <item name="android:windowNoTitle">true</item>
   <item name="android:windowIsFloating">false</item>

Mon paramètre de thème pour la boîte de dialogue est le suivant:

<style name="DialogTheme" parent="Theme.AppCompat.Dialog" >
    <item name="android:layout_width">match_parent</item>
    <item name="android:layout_height">match_parent</item>
    <item name="android:windowBackground">@android:color/transparent</item>
    <item name="android:windowNoTitle">true</item>
    <item name="android:windowIsFloating">false</item>

Assurez-vous que le thème a un parent comme Theme.AppCompat.Dialog Une autre façon serait de simplement créer un nouveau style dans styles.xml et de le modifier selon le code ci-dessus.

6. Accédez à votre classe Fragment de dialogue et dans le méthode onCreate () , définissez le style de votre Dialog comme:

   @Override public void onCreate (@Nullable Bundle savedInstanceState) {super.onCreate (savedInstanceState); setStyle (DialogFragment.STYLE_NORMAL, R.style.DialogTheme); }

Ajoutez ceci ci-dessous les lignes dans le style de la boîte de dialogue plein écran.

<item name="android:windowNoTitle">true</item>
    <item name="android:windowFullscreen">true</item>
    <item name="android:windowIsFloating">false</item>

window.setLayout ne suffit pas pour les appareils plus anciens.

Voici ce que je fais:

try {
    ViewGroup parent = (ViewGroup) view;
    do {
        parent = (ViewGroup) parent.getParent();
        if (parent == null)
            break;

        parent.getLayoutParams().height = ViewGroup.LayoutParams.MATCH_PARENT;
        parent.getLayoutParams().width = ViewGroup.LayoutParams.MATCH_PARENT;
        parent.requestLayout();
    } while (true);
} catch (Exception e){}

This below answer works for me in fragment dialog.  


  Dialog dialog = getDialog();
        if (dialog != null)
        {
            int width = ViewGroup.LayoutParams.MATCH_PARENT;
            int height = ViewGroup.LayoutParams.MATCH_PARENT;
            dialog.getWindow().setLayout(width, height);
        }

Une solution en utilisant le nouveau ConstraintLayoutconsiste à envelopper le ConstraintLayoutdans un LinearLayoutavec minHeight et minWidth fixés. Sans le wrapping, ConstraintLayout n'obtient pas la bonne taille pour le Dialog.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:minWidth="1000dp"
    android:minHeight="1000dp"
    android:orientation="vertical">

    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/background_color"
        android:orientation="vertical">
        <!-- some constrained views -->
    </androidx.constraintlayout.widget.ConstraintLayout>

</LinearLayout>

A travaillé pour moi à Kotlin,

 override fun onActivityCreated(savedInstanceState: Bundle?) {
    super.onActivityCreated(savedInstanceState)

    dialog?.window?.setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)

}

la solution suivante a fonctionné pour moi, une autre solution m'a donné un peu d'espace sur les côtés, c'est-à-dire pas en plein écran

Vous devez apporter des modifications aux méthodes onStart et onCreate

@Override
public void onStart() {
    super.onStart();
    Dialog dialog = getDialog();
    if (dialog != null)
    {
        int width = ViewGroup.LayoutParams.MATCH_PARENT;
        int height = ViewGroup.LayoutParams.MATCH_PARENT;
        dialog.getWindow().setLayout(width, height);
    }
}


 public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
    final Dialog dialog = new Dialog(requireContext());
    dialog.getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
 }