Ich versuche, ein DialogFragment im Vollbildmodus anzuzeigen. Aber ich bin irgendwie nicht dazu in der Lage.

Die Art und Weise, wie ich das Fragment zeige, stammt direkt aus der Android-Entwicklerdokumentation

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

Ich weiß naiv versucht, das RelativeLayout im Fragment auf fill_parent und einige minWidth und minHeight zu setzen.

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

Ich würde wissen, dass das DialogFragment den größten Teil des Bildschirms ausfüllt. Aber ich scheine die Größe nur vertikal zu ändern, aber nur bis eine feste Breite horizontal.

Ich habe auch versucht, die Fensterattribute im Code festzulegen, wie hier vorgeschlagen: http://groups.google.com/group/android-developers/browse_thread/thread/f0bb813f643604ec . Aber das hat auch nicht geholfen.

Ich verstehe wahrscheinlich etwas falsch darüber, wie Android mit Dialogen umgeht, da ich brandneu darin bin. Wie kann ich so etwas machen? Gibt es alternative Wege, um mein Ziel zu erreichen?

Android-Gerät:
Asus EeePad Transformer
Android 3.0.1

Update: Ich habe es jetzt geschafft, es mit dem folgenden Code im Fragment in den Vollbildmodus zu bringen

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

Leider will ich das nicht ganz. Ich brauche definitiv ein kleines "Auffüllen" um den Dialog, um den Hintergrund anzuzeigen.

Irgendwelche Ideen, wie man das erreicht?

Versuchen Sie, zu a LinearLayoutstatt zu wechseln RelativeLayout. Ich habe beim Testen auf die 3.0 Honeycomb-API abgezielt.

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

}
}

und die Layouts : 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>

So rufen Sie DialogFragment im Vollbildmodus auf

Überschreiben onStartIhrer DialogFragment wie folgt aus :

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

Und vielen Dank an diesen Beitrag: Das Geheimnis der Androiden-Vollbild-Dialogfragmente

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

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

Laut diesem Link zeigt DialogFragment Vollbild Polsterung an den Seiten, dies wird wie ein Zauber funktionieren.

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

Erstellen Sie ein Vollbild-DialogFragment, indem Sie nur den Stil verwenden

Erste Lösung

1. Fügen Sie hinzu 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. Fügen Sie Ihrem DialogFragment Folgendes hinzu:

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

Alternative Lösung

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

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

Wo AppThemeist das Thema, das Sie in Stilen definiert haben?

In meinem Fall habe ich folgenden Ansatz verwendet:

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

Plus LinearLayout, um den gesamten Raum mit Inhalten zu füllen.

Aber es gab immer noch kleine Lücken einigen Lollipop + -Geräten (z. B. Nexus 9) zwischen dem linken und rechten Rand des Dialogfelds und den Bildschirmkanten.

Es war nicht offensichtlich, aber schließlich habe ich herausgefunden, dass der Fensterhintergrund in der Datei styles.xml wie folgt angegeben werden sollte , damit er über alle Geräte und Plattformen hinweg in voller Breite angezeigt wird :

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

Und natürlich muss dieser Stil verwendet werden, wenn wir den Dialog wie folgt erstellen:

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

Ich habe das Problem bereits bei der Verwendung eines Vollbild-Dialogfelds festgestellt. Fragment: Beim Festlegen des Vollbildmodus wird immer eine Auffüllung angezeigt. Versuchen Sie diesen Code in der onActivityCreated () -Methode von 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);
    }
}

Soweit die Android-API aktualisiert wurde, wird folgende Methode vorgeschlagen, um einen Vollbilddialog anzuzeigen:

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

Andernfalls können Sie Folgendes tun, wenn Sie nicht möchten, dass es im Vollbildmodus angezeigt wird:

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

Ich hoffe es hilft.

BEARBEITEN

Beachten Sie, dass die von mir angegebene Lösung funktioniert, aber eine Schwäche aufweist, die manchmal problematisch sein kann. Hinzufügen des DialogFragments zumandroid.R.id.content Container können Sie das nicht verarbeitenDialogFragment#setCancelable() Funktion korrekt , und kann zu unerwarteten Verhaltensweisen führen, wenn Sie das DialogFragment selbst ebenfalls zum Backstack hinzufügen.

Daher habe ich Ihnen vorgeschlagen, den Stil Ihres DialogFragments in der onCreate-Methode wie folgt zu ändern:

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

Ich hoffe es hilft.

Versuchen Sie, setStyle () in onCreate zu verwenden und überschreiben Sie den onCreateDialog make-Dialog ohne Titel

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

oder überschreiben Sie einfach onCreate () und setzen Sie den Code auf den Code.

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

Dies kann in der Tat davon abhängen, wie das Layout definiert ist. Um sicherzustellen, dass der Dialog die erforderliche Größe erhält, besteht die beste Lösung darin, die LayoutParams bereitzustellen, sobald der Dialog angezeigt wird (und nicht bei der Erstellung). In einem DialogFragment wird der Dialog in der onStart- Methode angezeigt. Eine gültige Methode zum Abrufen der vollen Breite lautet also:

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

Um auch ein Thema oder einen Stil wie einen NO_TITLE-Stil bereitzustellen, befindet sich die beste Position in der onCreate- Methode:

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

Hinweis: Auch hier findet man die richtige Antwort. Aber ich möchte eine Verwirrung klären.

Verwenden Sie den folgenden Code für 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);
    }
}

Verwenden Sie den folgenden Code für 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);
}

Und die Kotlin-Version!

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

Dies ist die Lösung, wie ich dieses Problem herausgefunden habe:

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

Erstellen Sie das folgende Thema in Ihrer 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>

Legen Sie dann den Stil in DialogFragment fest

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

Chirag Nagariya hat Recht, mit Ausnahme des Zusatzes '_Fullscreen'. Es kann mit jedem Basisstil gelöst werden, der nicht vom Dialogstil abgeleitet ist. 'android.R.style.Theme_Black_NoTitleBar' kann ebenfalls verwendet werden.

Falls jemand anderes darauf stößt, hatte ich eine ähnliche Erfahrung, aber es stellte sich heraus, dass das Problem darin bestand, dass ich vergessen hatte, die aufgeblasene Ansicht von onCreateView zurückzugeben (stattdessen die Standardeinstellung super.onCreateView zurückzugeben). Ich habe einfach die richtige aufgeblasene Ansicht zurückgegeben und das hat das Problem gelöst.

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

Diese Lösung wendet ein Vollbild-Thema auf den Dialog an, das Chirags setStyle in onCreate ähnelt. Ein Nachteil ist, dass savedInstanceState nicht verwendet wird.

Versuchen Sie dies für einen allgemeinen Fragmentdialog für mehrere Zwecke. Hoffe das hilft dir besser

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

Folgendes müssen Sie einstellen, um zu fragmentieren:

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

In deinem Fall:

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

Und warum? Da DialogFragment (wenn nicht explizit angegeben) seine inneren Stile verwendet, die Ihr benutzerdefiniertes Layout darin einschließen (kein Vollbild usw.).

Und Layout? Kein hackiger Weg nötig, das funktioniert einwandfrei:

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

Genießen

Ich bin sehr spät für die Beantwortung dieser Frage, dennoch möchte ich diese Antwort teilen, damit in Zukunft jeder diese verwenden kann.

Ich habe diesen Code in meinem Projekt verwendet. Er funktioniert sowohl in der niedrigeren als auch in der höheren Version.

Verwenden Sie dieses Thema einfach in onCreateDialog () wie folgt:

@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 - Hier ist der Quellcode für dieses Thema. Nur dieses Thema reicht aus, um DialogFragment im Vollbildmodus anzuzeigen.

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

Bitte lassen Sie mich wissen, wenn jemand auf ein Problem stößt. Hoffe das ist hilfreich. Vielen Dank :)

Die folgende Methode funktioniert auch, wenn Sie an einem relativen Layout arbeiten. Befolgen Sie die folgenden Schritte:

1. Gehen Sie zum Themeneditor Themeneditor (Verfügbar unter Extras-> Android -> Themeneditor)
2. Wählen Sie Alle Themen anzeigen. Wählen Sie die mit AppCompat.Dialog
3. Wählen Sie die Option Android-Fensterhintergrund, wenn Sie möchten, dass er einen bestimmten farbigen oder einen transparenten Hintergrund hat.
4. Wählen Sie die Farbe und klicken Sie auf OK. Wählen Sie einen Namen für das neue Thema.

5. Gehen Sie zu styles.xml und fügen Sie unter dem gerade hinzugefügten Thema die beiden folgenden Attribute hinzu:

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

Meine Themeneinstellung für den Dialog lautet wie folgt:

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

Stellen Sie sicher, dass das Thema ein übergeordnetes Thema als Theme.AppCompat.Dialog hat. Eine andere Möglichkeit besteht darin, einen neuen Stil in styles.xml zu erstellen und ihn gemäß dem obigen Code zu ändern.

6. Wechseln Sie zu Ihrer Dialogfragmentklasse und legen Sie in der onCreate () -Methode den Stil Ihres Dialogs wie folgt fest :

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

Fügen Sie diese folgenden Zeilen im Stil des Vollbilddialogs hinzu.

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

window.setLayout ist nicht genug für ältere Geräte.

Folgendes mache ich:

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

Eine Lösung unter Verwendung des neuen ConstraintLayoutist das Einwickeln des ConstraintLayoutin a LinearLayoutmit minHeight und minWidth behoben. Ohne die Umhüllung erhält ConstraintLayout nicht die richtige Größe für den 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>

Arbeitete für mich in Kotlin,

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

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

}

Die folgende Lösung funktionierte für mich. Andere Lösung gab mir etwas Platz in den Seiten, dh nicht im Vollbildmodus

Sie müssen Änderungen an der Methode onStart und onCreate vornehmen

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