Próbuję pokazać prawie pełny ekran DialogFragment. Ale jakoś nie jestem w stanie tego zrobić.

Sposób, w jaki pokazuję fragment, pochodzi bezpośrednio z dokumentacji programisty Androida

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

Wiem, że naiwnie próbowałem ustawić RelativeLayout we fragmencie na fill_parent i trochę minWidth i 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">

Wiedziałbym, że spodziewam się, że DialogFragment wypełni większość ekranu. Ale wydaje mi się, że zmieniam rozmiar tylko w pionie, ale tylko do pewnej stałej szerokości w poziomie.

Próbowałem też ustawić atrybuty okna w kodzie, jak zasugerowałem tutaj: http://groups.google.com/group/android-developers/browse_thread/thread/f0bb813f643604ec . Ale to też nie pomogło.

Prawdopodobnie nie rozumiem czegoś o tym, jak Android obsługuje dialogi, ponieważ jestem w tym zupełnie nowy. Jak mogę zrobić coś takiego? Czy są jakieś alternatywne sposoby osiągnięcia celu?

Urządzenie z systemem Android:
Asus EeePad Transformer
Android 3.0.1

Aktualizacja: udało mi się teraz wyświetlić go na pełnym ekranie, z następującym kodem we fragmencie

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

Niestety, nie bardzo chcę tego. Zdecydowanie potrzebuję małego „wypełnienia” wokół okna dialogowego, aby wyświetlić tło.

Jakieś pomysły, jak to osiągnąć?

Spróbuj przełączyć się na LinearLayoutzamiast RelativeLayout. Podczas testowania celowałem w interfejs API 3.0 Honeycomb.

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

}
}

i układy : 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>

Aby uzyskać DialogFragment na pełnym ekranie

Zastąp onStartswój DialogFragment w następujący sposób:

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

I bardzo dziękuję za ten 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);
}

Zgodnie z tym linkiem na pełnym ekranie DialogFragment pokazuje wypełnienie po bokach, co będzie działać jak urok.

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

Utwórz DialogFragment na pełnym ekranie, używając tylko stylu

Pierwsze rozwiązanie

1. Dodaj do 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. Dodaj do swojego DialogFragment:

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

Alternatywne rozwiązanie

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

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

gdzie AppThemejest temat zdefiniowany w stylach.

W moim przypadku zastosowałem następujące podejście:

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

Plus LinearLayout, aby wypełnić całą przestrzeń treścią.

Jednak na niektórych urządzeniach Lollipop + (np. Nexus 9) między lewą i prawą krawędzią okna dialogowego a krawędziami ekranu nadal były niewielkie przerwy .

Nie było to oczywiste, ale w końcu doszedłem do wniosku, że aby uzyskać pełną szerokość na wszystkich urządzeniach i platformach, tło okna powinno być określone w pliku styles.xml, jak poniżej:

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

I oczywiście ten styl musi być używany podczas tworzenia okna dialogowego, takiego jak poniżej:

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

Wcześniej napotkałem ten problem podczas korzystania z pełnoekranowego okna dialogowegoFragment: zawsze występuje wypełnienie podczas ustawiania pełnego ekranu. wypróbuj ten kod w metodzie onActivityCreated () programu 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);
    }
}

Jeśli chodzi o zaktualizowanie interfejsu API systemu Android, sugerowana metoda wyświetlania okna dialogowego na pełnym ekranie jest następująca:

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

w przeciwnym razie, jeśli nie chcesz, aby był wyświetlany na pełnym ekranie, możesz to zrobić w ten sposób:

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

Mam nadzieję, że to pomoże.

EDYTOWAĆ

Miej świadomość, że rozwiązanie, które podałem, działa, ale ma słabość, która czasami może być kłopotliwa. Dodanie DialogFragment do android.R.id.contentkontenera nie pozwoli na obsługęDialogFragment#setCancelable() poprawną funkcji i może prowadzić do nieoczekiwanych zachowań podczas dodawania samego DialogFragment do tylnego stosu.

Dlatego zasugerowałem ci prostą zmianę stylu twojego DialogFragment w metodzie onCreate w następujący sposób:

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

Mam nadzieję, że to pomoże.

Spróbuj użyć setStyle () w onCreate i przesłonić onCreateDialog zrobić okno dialogowe bez tytułu

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

lub po prostu nadpisuj onCreate () i setStyle obok kodu.

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

Rzeczywiście może to zależeć od tego, jak zdefiniowano układ. Aby jednak upewnić się, że okno dialogowe uzyska wymagany rozmiar, najlepszym rozwiązaniem jest dostarczenie LayoutParams po wyświetleniu okna (a nie podczas tworzenia). W DialogFragment okno dialogowe jest wyświetlane w metodzie onStart , więc prawidłową metodą uzyskania pełnej szerokości jest:

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

Aby zapewnić również motyw lub styl, na przykład styl NO_TITLE, najlepszą lokalizacją jest metoda onCreate :

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

Uwaga: tutaj nawet można znaleźć właściwą odpowiedź. Ale chcę wyjaśnić zamieszanie.

Użyj poniższego kodu dla 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);
    }
}

Użyj poniższego kodu dla 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);
}

I wersja 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)
    }
}

Oto rozwiązanie, w jaki sposób rozwiązałem ten problem:

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

Utwórz poniższy motyw w swoim 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>

następnie ustaw styl w DialogFragment

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

Chirag Nagariya ma rację, z wyjątkiem dodatku „_Fullscreen”. można go rozwiązać przy użyciu dowolnego stylu podstawowego, który nie pochodzi ze stylu okna dialogowego. Można również użyć „android.R.style.Theme_Black_NoTitleBar”.

Na wypadek, gdyby ktoś inny się z tym spotkał, miałem podobne doświadczenie, ale okazuje się, że problem polegał na tym, że zapomniałem zwrócić zawyżonego widoku z onCreateView (zamiast tego zwracałem domyślny super.onCreateView). Po prostu zwróciłem poprawny zawyżony widok i to rozwiązało problem.

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

To rozwiązanie stosuje motyw pełnoekranowy w oknie dialogowym, który jest podobny do setStyle Chiraga w onCreate. Wadą jest to, że nie jest używany parametr saveInstanceState.

Spróbuj tego dla wspólnego okna dialogowego fragmentów do wielu zastosowań. Mam nadzieję, że to pomoże ci obstawiającym

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

Oto, co musisz ustawić na fragmentację:

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

W Twoim przypadku:

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

I dlaczego? Ponieważ DialogFragment (jeśli nie zostanie to wyraźnie powiedziane), użyje swoich wewnętrznych stylów, które zawiną w nim Twój niestandardowy układ (bez pełnego ekranu itp.).

A układ? Nie jest potrzebny żaden hackerski sposób, to działa dobrze:

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

Cieszyć się

Jestem bardzo spóźniony na odpowiedź na to pytanie, ale nadal chcę udostępnić tę odpowiedź, aby w przyszłości każdy mógł z niej skorzystać.

Użyłem tego kodu w moim projekcie, działa on zarówno w wersji niższej, jak i wyższej.

Po prostu użyj tego motywu wewnątrz onCreateDialog () w następujący sposób:

@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 - Oto kod źródłowy tego motywu, możesz zobaczyć, że tylko ten motyw wystarczy, aby DialogFragment pojawił się na pełnym ekranie.

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

Daj mi znać, jeśli ktoś napotka jakiś problem. Mam nadzieję, że to jest pomocne. Dzięki :)

Poniższy sposób zadziała, nawet jeśli pracujesz nad względnym układem. Wykonaj następujące kroki:

1. Przejdź do edytora motywów (dostępne w menu Narzędzia-> Android -> Edytor motywów)
2. Wybierz pokaż wszystkie motywy. Wybierz ten z AppCompat.Dialog
3. Wybierz opcję Tło okna Androida, jeśli chcesz, aby miało ono określone kolorowe tło lub przezroczyste.
4. Wybierz kolor i wciśnij OK Wybierz nazwę nowego motywu.

5. Przejdź do styles.xml, a następnie pod właśnie dodanym motywem dodaj te dwa atrybuty:

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

Moje ustawienie motywu dla okna dialogowego jest następujące:

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

Upewnij się, że motyw ma element nadrzędny jako Theme.AppCompat.Dialog Innym sposobem byłoby po prostu utworzenie nowego stylu w styles.xml i zmiana go zgodnie z powyższym kodem.

6. Idź do swojej klasy Dialog Fragment i do onCreate () ustaw styl swojego okna dialogowego na:

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

Dodaj poniższe linie w stylu pełnego okna dialogowego.

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

window.setLayout za mało dla starszych urządzeń.

Oto co robię:

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

Rozwiązaniem wykorzystującym nowe ConstraintLayoutjest zawijanie ConstraintLayouta LinearLayoutze stałą wartością minHeight i minWidth. Bez zawijania ConstraintLayout nie uzyskuje odpowiedniego rozmiaru dla okna dialogowego.

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

Pracował dla mnie w Kotlinie,

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

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

}

poniższe rozwiązanie działało u mnie inne rozwiązanie dało mi trochę miejsca po bokach, tj. nie na pełnym ekranie

Musisz wprowadzić zmiany w metodzie onStart i 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));
 }