Estoy tratando de mostrar un DialogFragment de pantalla casi completa. Pero de alguna manera no puedo hacerlo.

La forma en que estoy mostrando el Fragmento es directamente de la documentación del desarrollador de 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");

Sé que ingenuamente intenté establecer RelativeLayout en el fragmento para fill_parent y algunos minWidth y 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">

Sabría esperar que el DialogFragment llene la mayoría de la pantalla. Pero solo parece cambiar el tamaño verticalmente, pero solo hasta un ancho fijo horizontalmente.

También traté de establecer los Atributos de la ventana en el código, como se sugiere aquí: http://groups.google.com/group/android-developers/browse_thread/thread/f0bb813f643604ec . Pero esto tampoco ayudó.

Probablemente estoy malinterpretando algo acerca de cómo Android maneja los Diálogos, ya que soy nuevo en esto. ¿Cómo puedo hacer algo como esto? ¿Hay alguna forma alternativa de alcanzar mi objetivo?

Dispositivo Android:
Asus EeePad Transformer
Android 3.0.1

Actualización: ahora logré ponerlo en pantalla completa, con el siguiente código en el fragmento

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

Desafortunadamente, esto no es exactamente lo que quiero. Definitivamente necesito un pequeño "relleno" alrededor del diálogo para mostrar el fondo.

¿Alguna idea de cómo lograr eso?

Intente cambiar a un en LinearLayoutlugar de RelativeLayout. Estaba apuntando a la API 3.0 Honeycomb cuando probaba.

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;
    }

}
}

y los diseños : 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>

Para obtener DialogFragment en pantalla completa

Anulación onStartde su DialogFragment de esta manera:

@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);
    }
}

Y muchas gracias a esta publicación: The-mystery-of-androids-full-screen-dialog-fragments

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

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

De acuerdo con este enlace, DialogFragment fullscreen muestra relleno en los lados, esto funcionará de maravilla .

@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;
}

Haga un DialogFragment de pantalla completa usando solo el estilo

Primera solución

1. Agregue a su style.xml:

    <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>
    </style>

2. Agregue a su DialogFragment:

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

Solución alternativa

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

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

¿Dónde AppThemeestá el tema que definiste en los estilos?

En mi caso utilicé el siguiente enfoque:

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

Además LinearLayout para llenar todo el espacio con contenido.

Pero todavía había pequeños espacios entre los bordes izquierdo y derecho del cuadro de diálogo y los bordes de la pantalla en algunos dispositivos Lollipop + (por ejemplo, Nexus 9).

No era obvio, pero finalmente descubrí que para hacer el ancho completo en todos los dispositivos y plataformas , el fondo de la ventana debería especificarse dentro de styles.xml de la siguiente manera:

<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>

Y, por supuesto, este estilo debe usarse cuando creamos el diálogo como el siguiente:

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

Conocí el problema antes al usar un cuadro de diálogo de pantalla completa Fragmento: siempre hay un relleno al configurar la pantalla completa. intente este código en el método 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);
    }
}

En cuanto se actualizó la API de Android, el método sugerido para mostrar un cuadro de diálogo de pantalla completa es el siguiente:

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();

de lo contrario, si no desea que se muestre a pantalla completa, puede hacerlo de esta manera:

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

Espero eso ayude.

EDITAR

Tenga en cuenta que la solución que le di funciona funciona pero tiene una debilidad que a veces podría ser problemática. Agregar el DialogFragment al android.R.id.contentcontenedor no le permitirá manejar la DialogFragment#setCancelable()función correctamente y podría conducir a comportamientos inesperados al agregar el DialogFragment en sí mismo a la pila posterior también.

Así que le sugerí que simplemente cambiara el estilo de su DialogFragment en el método onCreate de la siguiente manera:

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

Espero eso ayude.

Intente usar setStyle () en onCreate y anule onCreateDialog make dialog sin título

@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;
}

o simplemente anule onCreate () y setStyle con el código.

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

De hecho, depende de cómo se defina el diseño. Pero para garantizar que el cuadro de diálogo obtenga el tamaño requerido, la mejor solución es proporcionar los LayoutParams una vez que se muestra el cuadro de diálogo (y no en la creación). En un DialogFragment, el cuadro de diálogo se muestra en el método onStart , por lo que un método válido para obtener el ancho completo es:

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

Para proporcionar también un tema o estilo, como un estilo NO_TITLE, la mejor ubicación está en el método onCreate :

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

Nota: Incluso uno puede encontrar la respuesta correcta aquí. Pero quiero aclarar una confusión.

Use el siguiente código para 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);
    }
}

Use el siguiente código para 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);
}

¡Y la versión de 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)
    }
}

Esta es la solución de cómo resolví este problema:

@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));
    }
}

Cree el tema a continuación en su 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>

luego configure el estilo en DialogFragment

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

Chirag Nagariya tiene razón, excepto la adición '_Fullscreen'. Se puede resolver utilizando cualquier estilo base que no se derive del estilo de diálogo. 'android.R.style.Theme_Black_NoTitleBar' también se puede usar.

En caso de que alguien más se encuentre con esto, tuve una experiencia similar a esta, pero resulta que el problema fue que había olvidado devolver la vista inflada de onCreateView (en lugar de devolver el super.onCreateView predeterminado). Simplemente devolví la vista inflada correcta y eso resolvió el problema.

@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;
}

Esta solución aplica un tema de pantalla completa en el cuadro de diálogo, que es similar al setStyle de Chirag en onCreate. Una desventaja es que saveInstanceState no se usa.

Pruebe esto para el cuadro de diálogo de fragmentos comunes para múltiples usos. Espero que esto te ayude a apostar

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();
    }
}

Esto es lo que necesita configurar para fragmentar:

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

En tu caso:

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

¿Y por qué? Debido a que DialogFragment (cuando no se indica explícitamente), usará sus estilos internos que envolverán su diseño personalizado (sin pantalla completa, etc.).

¿Y el diseño? No se necesita una forma hacky, esto funciona 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>

Disfrutar

Llego muy tarde para responder esta pregunta, pero quiero compartir esta respuesta para que en el futuro cualquiera pueda usarla.

He usado este código en mi proyecto, funciona tanto en la versión inferior como en la versión superior.

Simplemente use este tema dentro de onCreateDialog () así:

@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: aquí está el código fuente de este tema, puede ver que solo este tema es suficiente para que DialogFragment aparezca en pantalla completa.

<!-- 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>

Avíseme si alguien tiene algún problema. Espero que esto sea útil. Gracias :)

La siguiente forma funcionará incluso si está trabajando en un diseño relativo. Siga los siguientes pasos:

1. Vaya al editor de temas (disponible en Herramientas-> Android -> Editor de temas)
2. Seleccione mostrar todos los temas. Seleccione el que tenga AppCompat.Dialog
3. Elija la opción de fondo de la ventana de Android si desea que sea de un fondo de color específico o transparente.
4. Selecciona el color y presiona OK. Selecciona un nombre para el nuevo tema.

5. Vaya a styles.xml y luego, bajo el tema que acaba de agregar, agregue estos dos atributos:

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

La configuración de mi tema para el diálogo es la siguiente:

<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>

Asegúrese de que el tema tenga un elemento primario como Theme.AppCompat.Dialog Otra forma sería crear un nuevo estilo en styles.xml y cambiarlo según el código anterior.

6. Vaya a su clase Fragmento de diálogo y en el método onCreate () , configure el estilo de su diálogo como:

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

Agregue estas líneas a continuación en el estilo del cuadro de diálogo de pantalla completa.

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

window.setLayout no es suficiente para dispositivos más antiguos.

Esto es lo que hago:

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);
        }

Una solución mediante el uso de la nueva ConstraintLayoutes envolver el ConstraintLayouten un LinearLayoutcon minHeight y minWidth fijos. Sin el ajuste, ConstraintLayout no está obteniendo el tamaño correcto para el Diálogo.

<?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>

Trabajó para mí en Kotlin,

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

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

}

la siguiente solución funcionó para mí otra solución me dio algo de espacio en los lados, es decir, no a pantalla completa

Debe realizar cambios en el método onStart y 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));
 }