Caixa de diálogo em tela cheia

164

Estou tentando mostrar um DialogFragment quase em tela cheia. Mas de alguma forma eu não sou capaz de fazê-lo.

A maneira como mostro o fragmento é diretamente da documentação do desenvolvedor do 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");

Eu sei que ingenuamente tentei definir o RelativeLayout no fragmento para fill_parent e alguns 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">

Eu esperaria que o DialogFragment ocupasse a maior parte da tela. Mas eu só parece redimensionar verticalmente, mas apenas até uma largura fixa horizontal.

Também tentei definir os atributos da janela no código, conforme sugerido aqui: http://groups.google.com/group/android-developers/browse_thread/thread/f0bb813f643604ec . Mas isso também não ajudou.

Provavelmente estou entendendo algo errado sobre como o Android lida com os Diálogos, pois sou novo nele. Como posso fazer algo assim? Existem maneiras alternativas de alcançar meu objetivo?


Dispositivo Android:
Asus EeePad Transformer
Android 3.0.1


Atualização: agora consegui colocá-lo em tela cheia, com o seguinte código no fragmento

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

Infelizmente, isso não é exatamente o que eu quero. Definitivamente, preciso de um pequeno "preenchimento" ao redor da caixa de diálogo para mostrar o plano de fundo.

Alguma idéia de como fazer isso?

Eric
fonte
2
boa leitura: techrepublic.com/article/…
kouretinho
Você economiza meu tempo, tysm
Arul Mani

Respostas:

73

Tente mudar para um em LinearLayoutvez de RelativeLayout. Eu estava alvejando a API 3.0 do Honeycomb ao testar.

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 os 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>
bradley4
fonte
E, para mim, eu precisava usar um RelativeLayout, mas a largura da caixa de diálogo não estava se ajustando adequadamente ao conteúdo, então aninhei o RelativeLayout em um LinearLayout cujo único filho era o RelativeLayout ... isso acionou os ajustes de largura adequados.
precisa
1
Testei tudo, mas posso confirmar que a única coisa que funcionou no meu DialogFragment foi agrupar todo o meu layout em um LinearLayout. Dessa forma, eu poderia definir a largura e altura das minhas (agora envolto) layout original da ... horas desperdiçadas neste
Até
6
Definir minWidth e minHeight como algo grande parece ser a parte crucial; mas isso é um truque em vez de uma solução limpa. A resposta dada por @ David abaixo - explicada mais adiante no link que ele fornece - também funciona e é limpa.
Garlef Wegart
@ tir38 Acho que não é verdade, porque onCreateDialog () já tem uma implementação na superclasse.
starkej2
Essa deve ser a resposta aceita. Elaborado e claro
mutiemule
179

Para obter o DialogFragment em tela cheia

Substitua onStartseu DialogFragment assim:

@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 muito obrigado a este post: O mistério dos andróides, fragmentos de diálogo em tela cheia

David
fonte
6
Exatamente isso funciona, mas eu tentei com o Videoview e não funciona para isso. A barra de status ainda é exibida. Portanto, isso me corrigiu abaixo do código: dialog.getWindow (). SetFlags (WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
WhiteHorse
1
finalmente resolva, obrigado por sugestão @ David
Ashu Kumar
1
Isso funcionou muito bem para mim. Eu usei ViewGroup.LayoutParams.WRAP_CONTENTpara a altura. Obrigado.
atordoado
1
este é limpo e não-hacky
rommex
7
isso não está funcionando para o meu caso .. mostrando algum preenchimento de todos os cantos. qualquer ajuda?
Abdul Waheed 23/11
144
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    setStyle(DialogFragment.STYLE_NORMAL,
             android.R.style.Theme_Black_NoTitleBar_Fullscreen);
}
Chirag Nagariya
fonte
7
A única solução que parecia funcionar para mim. Outros estavam trabalhando às vezes, às vezes não. Vamos esperar que eu não encontrar uma exceção a esta um também :)
azertiti
12
Se você quiser que o plano de fundo seja transparente, use '' 'android.R.style.Theme_Translucent_NoTitleBar' ''
acntwww
2
A chave está passando STYLE_NORMAL. Isso faz com que a caixa de diálogo preencha a tela como qualquer outra atividade. Nós podemos usar qualquer tema. Para o design do material, você pode derivar um tema do material (por exemplo, Theme.AppCompat.NoActionBar que mantém a decoração do sistema, mas remove a barra de ação).
Rpattabi
2
Ha-ha, quando lancei, uma tela preta apareceu e pensei que estivesse congelada. Então mudei um tema para Theme_Light_NoTitleBar_Fullscreen. Obrigado, uma caixa de diálogo ocupa uma tela inteira (incluindo uma barra de status).
precisa saber é o seguinte
1
Theme_DeviceDefault_Light_NoActionBar_Fullscreen envia uma caixa de diálogo com fundo branco.
Hitesh Sahu
45

De acordo com este link, o DialogFragment em tela cheia mostra estofamento nos lados. Isso funcionará como um encanto.

@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;
}
Ayman Mahgoub
fonte
4
Funciona muito bem, mesmo em 2018! (nada mais fez) Obrigado.
AutonomousApps
2
Esta é a resposta perfeita, mesmo no Android Studio 3.1+ em 2018, melhor do que outras respostas aqui. A outra resposta vontade quebrou o UI android como cardview, girador, etc.
Taufik Nur Rahmanda
1
Funciona encantadoramente em 2020!
Yue Yin
Funciona, mas se você deseja definir margens no seu layout XML, terá que agrupar suas visualizações com outro layout, caso contrário, as margens serão ignoradas.
Felipe Ribeiro R. Magalhães
29

Crie um DialogFragment em tela cheia usando apenas o estilo

Primeira solução

1. Adicione ao seu 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. Adicione ao seu DialogFragment:

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

Solução alternativa

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

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

onde AppThemeé o tema que você definiu em estilos.

vovahost
fonte
Esta é a maneira mais elegante do que a resposta de Bradley4.
MeLine 26/01
solução de uma linha perfeita
me_
Ambas as soluções funcionaram, mas a primeira causou um erro no pop-up da área de transferência. Alternativa funciona bem
Janusz Hain
18

No meu caso, usei a seguinte abordagem:

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

Além disso, LinearLayout para preencher todo o espaço com conteúdo.

Mas ainda havia pequenas lacunas entre as bordas esquerda e direita da caixa de diálogo e as bordas da tela em alguns dispositivos Lollipop + (por exemplo, Nexus 9).

Não era óbvio, mas finalmente descobri que, para torná-lo em largura total em todos os dispositivos e plataformas , o plano de fundo da janela deve ser especificado dentro de styles.xml, como o seguinte:

<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 é claro que esse estilo precisa ser usado quando criamos a caixa de diálogo da seguinte maneira:

    public static DialogFragment createNoTitleDlg() {
        DialogFragment frag = new Some_Dialog_Frag();
        frag.setStyle(DialogFragment.STYLE_NO_TITLE, R.style.Dialog_NoTitle);
        return frag;
}
goRGon
fonte
Essa é a resposta. Funciona bem.
VonSchnauzer 28/11
2
Tentei a maioria das respostas neste tópico, algumas funcionaram, mas perdi todos os meus estilos de temas compatíveis com aplicativos. Eu esperava que este funcionasse como tema principal era AppCompat. É quase funcionou. Para mim, eu tive que adicionar 2 estilos adicionais: <item name="android:windowFullscreen">true</item> <item name="android:windowIsFloating">false</item> Fonte: TechRepublic
Breeno 11/17/17
15

Eu já conheci o problema antes ao usar um dialogFragment em tela cheia: sempre há um preenchimento ao definir a tela inteira. tente este código no método onActivityCreated () do 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);
    }
}
Ruidge
fonte
Funciona, outras soluções mudam o tema dos botões e outros elementos do fragmento.
Yhondri 12/08/19
11

Na atualização da API do Android, o método sugerido para mostrar uma caixa de diálogo em tela cheia é o seguinte:

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

caso contrário, se você não quiser que ele seja exibido em tela cheia, faça o seguinte:

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

Espero que ajude.

EDITAR

Esteja ciente de que a solução que eu dei funciona, mas tem uma fraqueza que às vezes pode ser problemática. Adicionar o DialogFragment ao android.R.id.contentcontêiner não permitirá que você lide com o DialogFragment#setCancelable()recurso corretamente e pode levar a comportamentos inesperados ao adicionar o próprio DialogFragment à pilha traseira.

Então, eu sugeri que você alterasse o estilo do seu DialogFragment no método onCreate da seguinte maneira:

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

Espero que ajude.

andrea.rinaldi
fonte
1
Concordo. Aqui está uma explicação completa do guia do desenvolvedor do Android: link
user2274431
10

Tente usar setStyle () em onCreate e substitua onCreateDialog make dialog without title

@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 simplesmente substitua onCreate () e setStyle pelo código.

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

De fato, isso depende de como o layout é definido. Mas, para garantir que a caixa de diálogo obtenha o tamanho necessário, a melhor solução é fornecer os LayoutParams assim que a caixa de diálogo for exibida (e não na criação). Em um DialogFragment, a caixa de diálogo é mostrada no método onStart , portanto, um método válido para obter largura total é:

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

Para também fornecer um tema ou estilo, como um estilo NO_TITLE, a melhor localização é no método onCreate :

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

Nota: Mesmo um pode encontrar a resposta correta aqui. Mas quero esclarecer uma confusão.

Use o código abaixo 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 o código abaixo 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);
}
Khemraj
fonte
6

E a versão 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)
    }
}
Boldijar Paul
fonte
1
Realmente funciona! Também quero adicionar, o desenvolvedor deve agrupar o conteúdo da caixa de diálogo por FrameLayout transparente, para evitar a deformação do conteúdo.
Georgiy Chebotarev
4

Esta é a solução que eu descobri esse 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));
    }
}
savepopulation
fonte
3

Crie o tema abaixo em seu 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>

depois defina o estilo em DialogFragment

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

Chirag Nagariya está certo, exceto a adição '_Fullscreen'. pode ser resolvido usando qualquer estilo de base que não seja derivado do estilo de Diálogo. O 'android.R.style.Theme_Black_NoTitleBar' também pode ser usado.

Shoham Ben-Har
fonte
1

Caso alguém se depare com isso, tive uma experiência semelhante a essa, mas o problema é que esqueci de retornar a exibição inflada do onCreateView (retornando o super.onCreateView padrão). Eu simplesmente retornei a visão inflada correta e isso resolveu o problema.

user1205577
fonte
1
@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 solução aplica um tema de tela cheia na caixa de diálogo, semelhante ao setStyle de Chirag no onCreate. Uma desvantagem é que SavedInstanceState não é usado.

Xingang Huang
fonte
1

Tente isso para o diálogo de fragmento comum para vários usos. Espero que isso ajude você 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();
    }
}
Dashrath Rathod
fonte
consulte esta pergunta - stackoverflow.com/questions/45494644/…
Aman Verma
1

É isso que você precisa definir para fragmentar:

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

No seu caso:

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

E porque? Como o DialogFragment (quando não informado explicitamente), usará seus estilos internos que envolverão seu layout personalizado (sem tela cheia etc.).

E layout? Nenhuma maneira hacky necessária, isso está funcionando muito bem:

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

Aproveitar

arenaq
fonte
1

Estou muito atrasado para responder a essa pergunta e ainda quero compartilhar essa resposta para que no futuro alguém possa usá-la.

Eu usei esse código no meu projeto, ele funciona na versão inferior e na versão superior.

Basta usar este tema dentro de onCreateDialog () assim:

@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 - Aqui está o código-fonte para este tema, você pode ver apenas esse tema é suficiente para fazer o DialogFragment aparecer em tela cheia.

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

Entre em contato se alguém enfrentar algum problema. Espero que isso seja útil. Obrigado :)

Biswajit
fonte
a caixa de diálogo é exibida em tela cheia, mas tudo ficou preto, exceto um botão. qualquer ideia ??
Sagar Nayak
1

A maneira a seguir funcionará mesmo se você estiver trabalhando em um layout relativo. Siga os seguintes passos:

  1. Vá para o editor de temas (disponível em Ferramentas-> Android -> Editor de temas )
  2. Selecione mostrar todos os temas. Selecione aquele com AppCompat.Dialog
  3. Escolha a opção android window background se quiser que seja de um fundo colorido específico ou transparente.
  4. Selecione a cor e pressione OK. Selecione um nome para o novo tema.
  5. Vá para styles.xml e, abaixo do tema adicionado, adicione estes dois atributos:

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

Minha configuração de tema para a caixa de diálogo é a seguinte:

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

Certifique-se de que o tema tenha um pai como Theme.AppCompat.Dialog. Outra maneira seria criar um novo estilo em styles.xml e alterá-lo conforme o código acima.

  1. Vá para a classe Fragmento de Diálogo e no onCreate () método , defina o estilo do Dialog como:

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

Saumya Mehta
fonte
1

Adicione isso abaixo das linhas no estilo da caixa de diálogo de tela cheia.

<item name="android:windowNoTitle">true</item>
    <item name="android:windowFullscreen">true</item>
    <item name="android:windowIsFloating">false</item>
MEGHA DOBARIYA
fonte
ou: substitua diversão onCreate (savedInstanceState: Bundle?) {super.onCreate (savedInstanceState) setStyle (DialogFragment.STYLE_NORMAL, R.style.BottomSheetDialogThemeNoFloating) <nome do estilo = "BottomSheetDialogThemeNoFloating" parent ". nome do item = "android: windowIsFloating"> false </item> </style>
Filipkowicz 6/04
0

window.setLayout não é suficiente para dispositivos mais antigos.

Aqui está o que eu faço:

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){}
palindrom
fonte
0
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);
        }
MEGHA DOBARIYA
fonte
0

Uma solução usando o novo ConstraintLayouté agrupar o ConstraintLayoutem um LinearLayoutcom minHeight e minWidth corrigidos. Sem o agrupamento, o ConstraintLayout não está obtendo o tamanho certo para o 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>
Nicola Gallazzi
fonte
0

Trabalhou para mim em Kotlin,

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

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

}
Aziz
fonte
0

a seguinte solução funcionou para mim outra solução me deu algum espaço nas laterais ou seja, não em tela cheia

Você precisa fazer alterações nos métodos 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));
 }


   
nikhil123
fonte