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?

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>

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

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

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

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

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.

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

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

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.

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

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

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

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

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

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

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.

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.

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

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

É 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

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

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.

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

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>

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

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

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>

Trabalhou para mim em Kotlin,

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

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

}

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