Sto cercando di mostrare un DialogFragment quasi a schermo intero. Ma in qualche modo non sono in grado di farlo.

Il modo in cui sto mostrando il frammento è direttamente dalla documentazione per sviluppatori 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");

So che ingenuamente ho cercato di impostare RelativeLayout nel frammento su fill_parent e alcuni minWidth e 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">

Saprei aspettarmi che DialogFragment riempia la maggior parte dello schermo. Ma mi sembra di ridimensionare solo in verticale, ma solo fino a quando una larghezza fissa in orizzontale.

Ho anche provato a impostare gli attributi della finestra nel codice, come suggerito qui: http://groups.google.com/group/android-developers/browse_thread/thread/f0bb813f643604ec . Ma questo non ha aiutato neanche.

Probabilmente sto fraintendendo qualcosa su come Android gestisce i dialoghi, dato che sono nuovo di zecca. Come posso fare qualcosa del genere? Ci sono modi alternativi per raggiungere il mio obiettivo?

Dispositivo Android:
Asus EeePad Transformer
Android 3.0.1

Aggiornamento: ora sono riuscito a farlo a schermo intero, con il seguente codice nel frammento

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

Sfortunatamente, questo non è proprio quello che voglio. Ho sicuramente bisogno di una piccola "imbottitura" attorno alla finestra di dialogo per mostrare lo sfondo.

Qualche idea su come realizzarlo?

Prova a passare a a LinearLayoutinvece di RelativeLayout. Stavo prendendo di mira l'API a nido d'ape 3.0 durante il test.

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

}
}

e i layout : 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>

Per ottenere DialogFragment a schermo intero

Sostituisci onStartDialogFragment in questo modo:

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

E grazie mille a questo post: 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);
}

Secondo questo link, DialogFragment a schermo intero mostra un'imbottitura sui lati che funzionerà come un fascino.

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

Crea un dialogo a schermo intero usando solo lo stile

Prima soluzione

    <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. Aggiungi a DialogFragment:

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

Soluzione alternativa

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

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

Nel mio caso ho usato il seguente approccio:

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

Plus LinearLayout per riempire tutto lo spazio di contenuto.

Ma c'erano ancora piccoli vuoti tra i bordi sinistro e destro della finestra di dialogo e i bordi dello schermo su alcuni dispositivi Lollipop + (ad esempio Nexus 9).

Non era ovvio, ma alla fine ho capito che per renderlo a tutta larghezza su tutti i dispositivi e le piattaforme lo sfondo della finestra doveva essere specificato all'interno di styles.xml come il seguente:

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

E ovviamente questo stile deve essere usato quando creiamo la finestra di dialogo come la seguente:

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

Ho incontrato il problema prima quando utilizzavo una finestra di dialogo a schermo intero Frammento: c'è sempre un'imbottitura pur avendo impostato lo schermo intero. prova questo codice nel metodo onActivityCreated () di 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);
    }
}

Per quanto riguarda l'API di Android aggiornata, il metodo suggerito per mostrare una finestra di dialogo a schermo intero è il seguente:

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

in caso contrario, se non vuoi che venga mostrato a schermo intero, puoi farlo in questo modo:

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

Spero che sia d'aiuto.

MODIFICARE

Sii consapevole del fatto che la soluzione che ho dato funziona ma ha un punto debole che a volte potrebbe essere problematico. L'aggiunta di DialogFragment al android.R.id.contentcontenitore non consente di gestire il fileDialogFragment#setCancelable() correttamente funzionalità e può comportare comportamenti imprevisti quando si aggiunge DialogFragment stesso allo stack posteriore.

Quindi ti avevo suggerito di cambiare semplicemente lo stile del tuo DialogFragment nel metodo onCreate come segue:

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

Spero che sia d'aiuto.

Prova a usare setStyle () in onCreate e sovrascrivi onCreateDialog per creare una finestra di dialogo senza titolo

@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 semplicemente sovrascrivi onCreate () e setStyle collega il codice.

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

Può davvero dipendere da come viene definito il layout. Ma per garantire che la finestra di dialogo ottenga le dimensioni richieste, la soluzione migliore è fornire LayoutParams una volta visualizzata la finestra di dialogo (e non al momento della creazione). Su un DialogFragment la finestra di dialogo è mostrata sul metodo onStart , quindi un metodo valido per ottenere la larghezza completa è:

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

Per fornire anche un tema o uno stile, come uno stile NO_TITLE, la posizione migliore è sul metodo onCreate :

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

Nota: anche uno può trovare la risposta giusta qui. Ma voglio chiarire una confusione.

Usa sotto il codice per 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);
    }
}

Usa sotto il codice per 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);
}

E la versione di 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)
    }
}

Questa è la soluzione su come ho capito questo 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));
    }
}

Crea il tema seguente nel tuo 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>

quindi imposta lo stile in DialogFragment

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

Chirag Nagariya ha ragione tranne l'aggiunta di '_Fullscreen'. può essere risolto utilizzando qualsiasi stile di base non derivato dallo stile della finestra di dialogo. Anche 'android.R.style.Theme_Black_NoTitleBar' può essere utilizzato anche.

Nel caso in cui qualcuno dovesse imbattersi in questo, ho avuto un'esperienza simile a questa, ma si è scoperto che il problema era che avevo dimenticato di restituire la visualizzazione gonfiata da onCreateView (invece di restituire il super.onCreateView predefinito). Ho semplicemente restituito la corretta visualizzazione gonfiata e questo ha risolto il 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;
}

Questa soluzione applica un tema a schermo intero nella finestra di dialogo, che è simile al setStyle di Chirag in onCreate. Uno svantaggio è che saveInstanceState non viene utilizzato.

Prova questo per la finestra di dialogo dei frammenti comuni per molteplici usi. Spero che questo ti aiuti a scommettere

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

Questo è ciò che devi impostare per frammentare:

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

Nel tuo caso:

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

E perché? Perché DialogFragment (quando non detto esplicitamente), utilizzerà i suoi stili interni che avvolgeranno il layout personalizzato (senza schermo intero, ecc.).

E layout? Non c'è bisogno di fare confusione, questo funziona perfettamente:

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

Godere

Sono in ritardo per rispondere a questa domanda e voglio ancora condividere questa risposta in modo che in futuro chiunque possa utilizzarla.

Ho usato questo codice nel mio progetto, funziona sia nella versione precedente che in quella superiore.

Usa questo tema all'interno di onCreateDialog () in questo modo:

@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 - Ecco il codice sorgente di questo tema che puoi vedere solo questo tema è sufficiente per far apparire DialogFragment a schermo intero.

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

Per favore fatemi sapere se qualcuno deve affrontare qualche problema. Spero sia utile. Grazie :)

Il seguente modo funzionerà anche se stai lavorando su un layout relativo. Segui i seguenti passi:

1. Vai all'editor dei temi (disponibile in Strumenti-> Android -> Editor dei temi)
2. Seleziona mostra tutti i temi. Seleziona quello con AppCompat.Dialog
3. Scegli l'opzione sfondo della finestra Android se vuoi che abbia uno sfondo colorato specifico o trasparente.
4. Seleziona il colore e premi OK. Seleziona un nome per il nuovo tema.

5. Vai a styles.xml e quindi sotto il tema appena aggiunto, aggiungi questi due attributi:

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

La mia impostazione del tema per la finestra di dialogo è la seguente:

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

Assicurati che il tema abbia un genitore come Theme.AppCompat.Dialog Un altro modo sarebbe semplicemente creare un nuovo stile in styles.xml e cambiarlo secondo il codice sopra.

6. Vai alla tua classe Dialog Fragment e nel metodo onCreate () , imposta lo stile della tua finestra come:

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

Aggiungi questo sotto le righe nello stile della finestra di dialogo a schermo intero.

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

window.setLayout non è abbastanza per i dispositivi più vecchi.

Ecco cosa faccio:

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 soluzione utilizzando il nuovo ConstraintLayoutè il wrapping di ConstraintLayoutin a LinearLayoutcon minHeight e minWidth fissi. Senza il wrapping, ConstraintLayout non sta ottenendo la giusta dimensione per la finestra di dialogo.

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

Ha lavorato per me a Kotlin,

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

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

}

la seguente soluzione ha funzionato per me un'altra soluzione mi ha dato un po 'di spazio sui lati, cioè non a schermo intero

È necessario apportare modifiche al metodo onStart e 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));
 }