Como fazer uma caixa de diálogo de alerta preencher 90% do tamanho da tela?

305

Posso criar e exibir uma caixa de diálogo de alerta personalizada muito bem, mas mesmo assim, android:layout_width/height="fill_parent"na caixa de diálogo xml, ela é apenas do tamanho do conteúdo.

O que eu quero é um diálogo que preencha a tela inteira, exceto talvez um preenchimento de 20 pixels. Em seguida, a imagem que faz parte da caixa de diálogo se estenderá automaticamente para o tamanho completo da caixa de diálogo com fill_parent.

Fabian
fonte

Respostas:

355

De acordo com a desenvolvedora da plataforma Android Dianne Hackborn, neste post do grupo de discussão, a Dialogs definiu a largura e a altura do layout de nível superior do Windows WRAP_CONTENT. Para aumentar o Diálogo, você pode definir esses parâmetros para MATCH_PARENT.

Código de demonstração:

    AlertDialog.Builder adb = new AlertDialog.Builder(this);
    Dialog d = adb.setView(new View(this)).create();
    // (That new View is just there to have something inside the dialog that can grow big enough to cover the whole screen.)

    WindowManager.LayoutParams lp = new WindowManager.LayoutParams();
    lp.copyFrom(d.getWindow().getAttributes());
    lp.width = WindowManager.LayoutParams.MATCH_PARENT;
    lp.height = WindowManager.LayoutParams.MATCH_PARENT;
    d.show();
    d.getWindow().setAttributes(lp);

Observe que os atributos são definidos após o diálogo ser mostrado. O sistema é meticuloso sobre quando eles são definidos. (Acho que o mecanismo de layout deve defini-los na primeira vez que a caixa de diálogo é exibida, ou algo assim.)

Seria melhor fazer isso estendendo Theme.Dialog, então você não precisaria jogar um jogo de adivinhação sobre quando chamar setAttributes. (Embora seja um pouco mais trabalhoso fazer com que a caixa de diálogo adote automaticamente um tema claro ou escuro apropriado, ou o tema Honeycomb Holo. Isso pode ser feito de acordo com http://developer.android.com/guide/topics/ui/themes. html # SelectATheme )

nmr
fonte
5
Se eu não entendo a resposta, ou não funciona para mim.
David Morales
4
Não parece ser verdade que as caixas de diálogo tenham todo o conteúdo do wrap_content. As coisas ficam mais estreitas e cortadas. A caixa de diálogo parece estar definida para uma largura predeterminada máxima.
precisa
21
Eu não entendo como isso responde à pergunta? O código sugerido por @nmr faz com que o Diálogo seja 90% da tela? Porque eu não vejo isso. A caixa de diálogo está definida como fill_width, então isso é 100%, não 90%, certo?
Ted
4
@Ted, o tema usado pelo AlertDialog tem uma margem. Portanto, o resultado não chega à borda da tela, ele preenche cerca de 90% dela. (É definitivamente não é exatamente 90%, apenas uma aproximação estética de 90%)
RMN
8
Apenas chamando d.getWindow (). GetAttributes (). Width = WindowManager.LayoutParams.FILL_PARENT; antes de chamar show () fará o truque. Além disso, tive alguns problemas com o método fornecido, pois o plano de fundo da caixa de diálogo estava ficando transparente. Assim que CopyFrom removido ((), o próprio problema fixo.
Alexey
183

Tente agrupar seu layout de caixa de diálogo personalizado em RelativeLayoutvez de LinearLayout. Isso funcionou para mim.

cvarsendan
fonte
2
tem para mim também. Alguém pode explicar o motivo !!
Rozina
É assim que o RelativeLayout deve funcionar ou um acidente feliz que pode desaparecer?
precisa saber é o seguinte
10
É 2019 e isso ainda funciona. Felicidades! De fato, deve ser a resposta aceita.
TaylanUB
@cvarsendan você poderia explicar a resposta? Isso funcionou para mim. Obrigado!
Jaco
OMG, My RecyclerView nunca exibe altura total ou altura 0 e, com isso, funciona perfeitamente depois de um dia tentando várias soluções. Por que RelativeLayout e outros?
Leegor #
85

A especificação de FILL_PARENT na janela da caixa de diálogo, como outros sugeriram, não funcionou para mim (no Android 4.0.4), porque apenas esticou o fundo preto da caixa de diálogo para preencher a tela inteira.

O que funciona bem é usar o valor mínimo de exibição, mas especificá-lo no código, para que a caixa de diálogo ocupe 90% da tela.

Assim:

Activity activity = ...;
AlertDialog dialog = ...;

// retrieve display dimensions
Rect displayRectangle = new Rect();
Window window = activity.getWindow();
window.getDecorView().getWindowVisibleDisplayFrame(displayRectangle);

// inflate and adjust layout
LayoutInflater inflater = (LayoutInflater)activity.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View layout = inflater.inflate(R.layout.your_dialog_layout, null);
layout.setMinimumWidth((int)(displayRectangle.width() * 0.9f));
layout.setMinimumHeight((int)(displayRectangle.height() * 0.9f));

dialog.setView(layout);

Em geral, apenas o ajuste da largura deve ser suficiente na maioria dos casos.

koma
fonte
Isso não parece funcionar completamente no 4.0 e acima. Não preenche 90% da tela. Alguma idéia do porquê? Estou fazendo isso em um Motorola Xoom com 4,0
Ryan Grey
@RyanGray Ele está funcionando para mim em um Samsung Nexus S com sistema operacional atualizado. Sem informações adicionais, infelizmente, não posso ajudá-lo.
Koma #
83

Defina android:minWidthe android:minHeightna sua visualização personalizada xml. Isso pode forçar o alerta a não apenas quebrar o tamanho do conteúdo. Usar uma exibição como esta deve fazer isso:

<LinearLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  android:minWidth="300dp" 
  android:minHeight="400dp">
  <ImageView
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"
   android:background="@drawable/icon"/>
</LinearLayout>
jqpubliq
fonte
3
Sim, com isso eu posso configurá-lo para um tamanho específico, mas quero que ele seja dimensionado para a tela menos um preenchimento de, por exemplo, 20 pixels. Ou largura = 90% da largura da tela.
Fabian
4
Os pixels independentes da densidade são sempre redimensionados para que qualquer tela tenha 320x480dp, portanto, uma visualização de 300x460dp seria um preenchimento de 20dp em todos os casos. Como alternativa, você pode encontrar o tamanho da tela assim: Display display = ((WindowManager) getSystemService (Context.WINDOW_SERVICE)). GetDefaultDisplay (); int largura = display.getWidth (); e defina maxWidth e maxHeight de acordo.
jqpubliq
5
Hmm da dissociação eu entendo o conceito de dp. Mas e se a proporção da tela for 16: 9 ou 4: 3? O dp será esticado de maneira desigual?
Fabian
2
Não, a resolução dp será apenas 320x480 se a proporção da tela for 2: 3; portanto, esse método não funcionará.
mhsmith
21
o que, por que essa resposta foi votada tantas vezes? essa é uma solução terrível, pois não tem absolutamente nenhuma consideração ao tamanho do dispositivo que o usuário está usando.
Jin
71

Ainda mais simples, faça o seguinte:

int width = (int)(getResources().getDisplayMetrics().widthPixels*0.90);
int height = (int)(getResources().getDisplayMetrics().heightPixels*0.90);

alertDialog.getWindow().setLayout(width, height);
FOMDeveloper
fonte
observação secundária: getResources () está disponível no contexto de Atividade.
Nat101 27/05
Esta resposta foi muito útil para o cenário de tentar recriar uma caixa de diálogo onCreateapós a rotação do dispositivo. Nesse caso, não podemos confiar na largura / altura de nada no layout, porque ele ainda não foi criado; mas a largura / altura física do dispositivo ainda estão disponíveis.
Tim Biegeleisen
5
Se você quer mudar apenas uma dimensão, passar ViewGroup.LayoutParams.WRAP_CONTENTcomo um dos parâmetros
Vadim Kotov
Esta é a melhor solução para mim.
Teekam Suthar
53
dialog.getWindow().setLayout(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
Elvis
fonte
1
Isso funcionou para mim e foi fácil de traduzir para o MonoDroid, que funcionou assim (onde d é um novo Diálogo): d.Window.SetLayout (WindowManagerLayoutParams.FillParent, WindowManagerLayoutParams.FillParent);
theJerm
10
Mas 90% não é o mesmo que 100%. FILL_PARENT indicaria preencher toda a largura, 100%, não 90%. Certo?
Ted
@ Ted Você está certo. Você pode substituir FILL_PARENTpela largura calculada como 90% da largura da exibição atual. Mas eu gosto da resposta porque é mais fácil do que os outros.
HRJ 19/12/13
27

Todas as outras respostas aqui fazem sentido, mas não atendem às necessidades de Fabian. Aqui está uma solução minha. Pode não ser a solução perfeita, mas funciona para mim. Ele mostra uma caixa de diálogo em tela cheia, mas você pode especificar um preenchimento na parte superior, inferior, esquerda ou direita.

Primeiro, coloque isso em res / values ​​/ styles.xml:

<style name="CustomDialog" parent="@android:style/Theme.Dialog">
    <item name="android:windowIsTranslucent">true</item>
    <item name="android:windowBackground">@color/Black0Percent</item>
    <item name="android:paddingTop">20dp</item>
    <item name="android:windowContentOverlay">@null</item>
    <item name="android:windowNoTitle">true</item>
    <item name="android:backgroundDimEnabled">false</item>
    <item name="android:windowIsFloating">false</item>
</style>

Como você pode ver, eu tenho o Android: paddingTop = 20dp é basicamente o que você precisa. O android: windowBackground = @ color / Black0Percent é apenas um código de cor declarado no meu color.xml

res / valores / color.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="Black0Percent">#00000000</color>
</resources>

Esse código de cores serve apenas como um modelo para substituir o plano de fundo da janela padrão da caixa de diálogo por uma cor de transparência de 0%.

Em seguida, crie o layout de diálogo personalizado res / layout / dialog.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/dialoglayout"
    android:layout_width="match_parent"
    android:background="@drawable/DesiredImageBackground"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <EditText
        android:id="@+id/edittext1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:singleLine="true"
        android:textSize="18dp" />

    <Button
        android:id="@+id/button1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Dummy Button"
        android:textSize="18dp" />

</LinearLayout>

Finalmente, aqui está nossa caixa de diálogo que define a exibição personalizada, que usa nosso dialog.xml:

Dialog customDialog;
LayoutInflater inflater = (LayoutInflater) getLayoutInflater();
View customView = inflater.inflate(R.layout.dialog, null);
// Build the dialog
customDialog = new Dialog(this, R.style.CustomDialog);
customDialog.setContentView(customView);
customDialog.show();

Conclusão: tentei substituir o tema da caixa de diálogo no styles.xml chamado CustomDialog. Ele substitui o layout da janela da caixa de diálogo e me dá a chance de definir um preenchimento e alterar a opacidade do plano de fundo. Pode não ser a solução perfeita, mas espero que ajude você .. :)

icaneatclouds
fonte
ele funciona para jellybean por agora eu tenho nt sido capaz de testá-lo outros bulids
Nasz Njoka Sr.
Parece a solução mais limpa e elegante. Trabalhos em Kitkat 4.4 e 4.3.
David
Eu tenho uma caixa de diálogo personalizada, e NADA estava funcionando até que eu veja isso, a mágica, TODA A MÁGICA em uma caixa de diálogo personalizada (que se estende DialogFragment) ocorre quando você faz: Dialog customDialog = new Dialog(context, STYLE);obrigado, REALMENTE, obrigado.
Sierisimo 5/05
É bom saber que ajuda :)
icaneatclouds
Isso funciona como um encanto para a janela de diálogo! (você também pode definir um Black60Percent ter a janela original acinzentado) O efeito colateral é que todos os meus pontos de vista no diálogo herdou os paddings I estabelecidos para o diálogo ....
runholen
25

Você pode usar a porcentagem para (APENAS) a largura da caixa de diálogo das janelas.

Veja este exemplo do Tema Holo:

<style name="Theme.Holo.Dialog.NoActionBar.MinWidth">
    <item name="android:windowMinWidthMajor">@android:dimen/dialog_min_width_major</item>
    <item name="android:windowMinWidthMinor">@android:dimen/dialog_min_width_minor</item>
</style>

 <!-- The platform's desired minimum size for a dialog's width when it
     is along the major axis (that is the screen is landscape).  This may
     be either a fraction or a dimension. -->
<item type="dimen" name="dialog_min_width_major">65%</item>

Tudo o que você precisa fazer é estender esse tema e alterar os valores de "Maior" e "Menor" para 90%, em vez de 65%.

Saudações.

Joao Gavazzi
fonte
1
Para utilizar com o diálogo apenas passar o seu estilo personalizado no construtor construtor de diálogo :)
sosite
23

O seguinte funcionou bem para mim:

    <style name="MyAlertDialogTheme" parent="Base.Theme.AppCompat.Light.Dialog.Alert">
        <item name="windowFixedWidthMajor">90%</item>
        <item name="windowFixedWidthMinor">90%</item>
    </style>

(observação: windowMinWidthMajor / Minor, conforme sugerido nas respostas anteriores, não funcionou. Minhas caixas de diálogo continuavam mudando de tamanho, dependendo do conteúdo)

e depois:

AlertDialog.Builder builder = new AlertDialog.Builder(getActivity(), R.style.MyAlertDialogTheme);
Deliriom
fonte
4
Melhor resposta até agora. Funcionou perfeitamente para mim!
Pawan 10/10
Eu me pergunto: como posso obter o valor dessas dimensões especiais, definidas em porcentagem, via código?
desenvolvedor android
19

Solução com cálculo real de 90%:

@Override public void onStart() {
   Dialog dialog = getDialog();
   if (dialog != null) {
     dialog.getWindow()
        .setLayout((int) (getScreenWidth(getActivity()) * .9), ViewGroup.LayoutParams.MATCH_PARENT);
   }
}

onde getScreenWidth(Activity activity)é definido o seguinte (melhor colocado em uma classe Utils):

public static int getScreenWidth(Activity activity) {
   Point size = new Point();
   activity.getWindowManager().getDefaultDisplay().getSize(size);
   return size.x;
}
Mehmet K
fonte
funciona como charme para um appcompatactivity que deve funcionar como diálogo
Estou obtendo índice de matriz fora do limite sobre isso :(
Dr. aNdRO 5/17/17
@ Dr.aNdRO como? Qual linha? Tem certeza de que é esse pedaço de código e não o smt mais?
Mehmet K
.setLayout () Estou chegando a esta linha. Quando eu mudo para WRAP CONTENT, isso funciona bem
Dr. Andro
10

Obtenha a largura do dispositivo:

public static int getWidth(Context context) {
    DisplayMetrics displayMetrics = new DisplayMetrics();
    WindowManager windowmanager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    windowmanager.getDefaultDisplay().getMetrics(displayMetrics);
    return displayMetrics.widthPixels;
}

use-o para criar diálogo 90% do dispositivo,

Dialog filterDialog = new Dialog(context, R.style.searchsdk_FilterDialog);

filterDialog.setContentView(R.layout.searchsdk_filter_popup);
initFilterDialog(filterDialog);
filterDialog.setCancelable(true);
filterDialog.getWindow().setLayout(((getWidth(context) / 100) * 90), LinearLayout.LayoutParams.MATCH_PARENT);
filterDialog.getWindow().setGravity(Gravity.END);
filterDialog.show();
Gopinath
fonte
8

Bem, você deve definir a altura e a largura da caixa de diálogo antes de mostrar isso (dialog.show ())

então, faça algo parecido com isto:

dialog.getWindow().setLayout(width, height);

//then

dialog.show()
shontauro
fonte
Não define dimensões para mim. API> = 21.
Odys 30/03
7

De longe, a maneira mais simples de pensar -

Se sua caixa de diálogo é feita de um LinearLayout vertical, basta adicionar uma exibição fictícia de "preenchimento de altura", que ocupará toda a altura da tela.

Por exemplo -

<?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:weightSum="1">

    <EditText
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:id="@+id/editSearch" />

    <ListView
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:id="@+id/listView"/>


   <!-- this is a dummy view that will make sure the dialog is highest -->
   <View
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:layout_weight="1"/>

</LinearLayout>

Observe android:weightSum="1"nos atributos do LinearLayout e android:layout_weight="1"nos atributos da visualização fictícia

Ron Tesler
fonte
Agradável! Isso impede que minha visualização na Web comece extremamente curta e se expanda até a altura máxima após onPageFinished. Parabéns!
Nancy
6

Bem, você deve definir a altura e a largura da caixa de diálogo antes de mostrar isso (dialog.show ())

então, faça algo parecido com isto:

dialog.getWindow().setLayout(width, height);

//then

dialog.show()

Obtendo este código, eu fiz algumas alterações:

dialog.getWindow().setLayout((int)(MapGeaGtaxiActivity.this.getWindow().peekDecorView().getWidth()*0.9),(int) (MapGeaGtaxiActivity.this.getWindow().peekDecorView().getHeight()*0.9));

no entanto, o tamanho da caixa de diálogo pode mudar quando o dispositivo muda de posição. Talvez você precise lidar sozinho quando as métricas mudarem. PD: peekDecorView, implica que o layout da atividade seja inicializado corretamente, caso contrário você poderá usar

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;

para obter o tamanho da tela

Juan Otero
fonte
6

Depois de inicializar seu objeto de diálogo e definir a exibição do conteúdo. Faça isso e aproveite.

(no caso, estou definindo 90% para a largura e 70% para a altura, porque a largura 90% estará sobre a barra de ferramentas)

DisplayMetrics displaymetrics = new DisplayMetrics();
getActivity().getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
int width = (int) ((int)displaymetrics.widthPixels * 0.9);
int height = (int) ((int)displaymetrics.heightPixels * 0.7);
d.getWindow().setLayout(width,height);
d.show();
Guilherme Pereira
fonte
4

Minha resposta é baseada no koma, mas não precisa substituir o onStart, mas apenas o onCreateView, que quase sempre é substituído por padrão quando você cria novos fragmentos.

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {
    View v = inflater.inflate(R.layout.your_fragment_layout, container);

    Rect displayRectangle = new Rect();
    Window window = getDialog().getWindow();
    window.getDecorView().getWindowVisibleDisplayFrame(displayRectangle);

    v.setMinimumWidth((int)(displayRectangle.width() * 0.9f));
    v.setMinimumHeight((int)(displayRectangle.height() * 0.9f));

    return v;
}

Eu testei no Android 5.0.1.

Kresimir Plese
fonte
3

Aqui está minha variante para a largura da caixa de diálogo personalizada:

DisplayMetrics displaymetrics = new DisplayMetrics();
mActivity.getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
int width = (int) (displaymetrics.widthPixels * (ThemeHelper.isPortrait(mContext) ? 0.95 : 0.65));

WindowManager.LayoutParams params = getWindow().getAttributes();
params.width = width;
getWindow().setAttributes(params);

Portanto, dependendo da orientação do dispositivo ( ThemeHelper.isPortrait(mContext)), a largura da caixa de diálogo será de 95% (no modo retrato) ou 65% (no modo paisagem). É um pouco mais do que o autor pediu, mas poderia ser útil para alguém.

Você precisa criar uma classe que se estenda do Dialog e coloque esse código no seu onCreate(Bundle savedInstanceState)método.

Para a altura da caixa de diálogo, o código deve ser semelhante a isso.

Clãs
fonte
O que é ThemeHelper? Eu não tenho essa classe disponível no meu projeto.
Nemi4 /
ThemeHelperé apenas uma aula auxiliar para minhas necessidades. Seu método isPortrait(Context)retorna se a orientação da tela do dispositivo é retrato ou paisagem.
Clans
isso terá problema se uma vez carregado o diálogo e depois mudarmos a orientação, ele manterá sua configuração inicial em onCreate
iBabur
3
public static WindowManager.LayoutParams setDialogLayoutParams(Activity activity, Dialog dialog)
    {
        try 
        {
            Display display = activity.getWindowManager().getDefaultDisplay();
            Point screenSize = new Point();
            display.getSize(screenSize);
            int width = screenSize.x;

            WindowManager.LayoutParams layoutParams = new WindowManager.LayoutParams();
            layoutParams.copyFrom(dialog.getWindow().getAttributes());
            layoutParams.width = (int) (width - (width * 0.07) ); 
            layoutParams.height = WindowManager.LayoutParams.WRAP_CONTENT;
            return layoutParams;
        } 
        catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
    }
Krunal Shah
fonte
3

Acima, muitas das respostas são boas, mas nenhuma delas funcionou totalmente para mim. Então eu combinei a resposta do @nmr e peguei essa.

final Dialog d = new Dialog(getActivity());
        //  d.getWindow().setBackgroundDrawable(R.color.action_bar_bg);
        d.requestWindowFeature(Window.FEATURE_NO_TITLE);
        d.setContentView(R.layout.dialog_box_shipment_detail);

        WindowManager wm = (WindowManager) getActivity().getSystemService(Context.WINDOW_SERVICE); // for activity use context instead of getActivity()
        Display display = wm.getDefaultDisplay(); // getting the screen size of device
        Point size = new Point();
        display.getSize(size);
        int width = size.x - 20;  // Set your heights
        int height = size.y - 80; // set your widths

        WindowManager.LayoutParams lp = new WindowManager.LayoutParams();
        lp.copyFrom(d.getWindow().getAttributes());

        lp.width = width;
        lp.height = height;

        d.getWindow().setAttributes(lp);
        d.show();
anand
fonte
3
    ...
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    Dialog d = builder.create(); //create Dialog
    d.show(); //first show

    DisplayMetrics metrics = new DisplayMetrics(); //get metrics of screen
    getActivity().getWindowManager().getDefaultDisplay().getMetrics(metrics);
    int height = (int) (metrics.heightPixels*0.9); //set height to 90% of total
    int width = (int) (metrics.widthPixels*0.9); //set width to 90% of total

    d.getWindow().setLayout(width, height); //set layout
Guihgo
fonte
3
mostrar a caixa de diálogo antes de definir o layout funciona para mim.
Anjo Koh
2

você precisa usar um estilo @ style.xml como CustomDialog para exibir a caixa de diálogo personalizável.

<style name="CustomDialog" parent="@android:style/Theme.DeviceDefault.Light.Dialog">
        <item name="android:windowIsTranslucent">true</item>
        <item name="android:windowBackground">@color/colorWhite</item>
        <item name="android:editTextColor">@color/colorBlack</item>
        <item name="android:windowContentOverlay">@null</item>
        <item name="android:windowNoTitle">true</item>
        <item name="android:backgroundDimEnabled">true</item>
        <item name="android:windowIsFloating">true</item>
        <item name="android:windowSoftInputMode">stateUnspecified|adjustPan</item>
    </style>

e use esse estilo em Activity.java como este

Dialog dialog= new Dialog(Activity.this, R.style.CustomDialog);
        dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
        dialog.setContentView(R.layout.custom_dialog);

e seu custom_dialog.xml deve estar dentro do diretório de layout

<?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:paddingLeft="10dp"
    android:paddingRight="10dp">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text=""
        android:textSize="20dp"
        android:id="@+id/tittle_text_view"
        android:textColor="@color/colorBlack"
        android:layout_marginTop="20dp"
        android:layout_marginLeft="10dp"/>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        android:layout_marginLeft="20dp"
        android:layout_marginBottom="10dp"
        android:layout_marginTop="20dp"
        android:layout_marginRight="20dp">

        <EditText
            android:id="@+id/edit_text_first"
            android:layout_width="50dp"
            android:layout_height="match_parent"
            android:hint="0"
            android:inputType="number" />

        <TextView
            android:id="@+id/text_view_first"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_marginLeft="5dp"
            android:gravity="center"/>

        <EditText
            android:id="@+id/edit_text_second"
            android:layout_width="50dp"
            android:layout_height="match_parent"
            android:hint="0"
            android:layout_marginLeft="5dp"
            android:inputType="number" />

        <TextView
            android:id="@+id/text_view_second"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_marginLeft="5dp"
            android:gravity="center"/>

    </LinearLayout>

</LinearLayout>
Nuwan Withanage
fonte
2

Se você estiver usando o Layout de restrição , poderá definir qualquer visualização dentro dele, para preencher uma porcentagem da tela com:

layout_constraintWidth_percent = "0.8"

Por exemplo, se você tem um ScrollView dentro da caixa de diálogo e deseja defini-lo como uma porcentagem da altura da tela. Seria assim:

<ScrollView
            android:id="@+id/scrollView"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            app:layout_constraintHeight_percent="0.8">

Espero que ajude alguém !!

Lucas
fonte
2

Basta dar ao AlertDialog esse tema

<style name="DialogTheme" parent="Theme.MaterialComponents.Light.Dialog.MinWidth">
    <item name="colorPrimary">@color/colorPrimary</item>
    <item name="android:windowMinWidthMajor">90%</item>
    <item name="android:windowMinWidthMinor">90%</item>
</style>
karimaounn
fonte
1

Aqui está uma resposta curta que funcionou para mim (Testado na API 8 e API 19).

Dialog mDialog;
View   mDialogView;
...
// Get height
int height = mDialog.getWindow()
.getWindowManager().getDefaultDisplay()
.getHeight();

// Set your desired padding (here 90%)
int padding = height - (int)(height*0.9f);

// Apply it to the Dialog
mDialogView.setPadding(
// padding left
0,
// padding top (90%)
padding, 
// padding right
0, 
// padding bottom (90%)
padding);
Tanasis
fonte
1
dialog.getWindow().setLayout(WindowManager.LayoutParams.MATCH_PARENT,WindowManager.LayoutParams.WRAP_CONTENT);
Sai Gopi N
fonte
0
    final AlertDialog alertDialog;

    LayoutInflater li = LayoutInflater.from(mActivity);
    final View promptsView = li.inflate(R.layout.layout_dialog_select_time, null);

    RecyclerView recyclerViewTime;
    RippleButton buttonDone;

    AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(mActivity);
    alertDialogBuilder.setView(promptsView);

    // create alert dialog
    alertDialog = alertDialogBuilder.create();

    /**
     * setting up window design
     */
    alertDialog.requestWindowFeature(Window.FEATURE_NO_TITLE);


    alertDialog.show();

    DisplayMetrics metrics = new DisplayMetrics(); //get metrics of screen
    mActivity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
    int height = (int) (metrics.heightPixels * 0.9); //set height to 90% of total
    int width = (int) (metrics.widthPixels * 0.9); //set width to 90% of total

    alertDialog.getWindow().setLayout(width, height); //set layout
    recyclerViewTime = promptsView.findViewById(R.id.recyclerViewTime);


    DialogSelectTimeAdapter dialogSelectTimeAdapter = new DialogSelectTimeAdapter(this);
    RecyclerView.LayoutManager linearLayoutManager = new LinearLayoutManager(this);
    recyclerViewTime.setLayoutManager(linearLayoutManager);
    recyclerViewTime.setAdapter(dialogSelectTimeAdapter);

    buttonDone = promptsView.findViewById(R.id.buttonDone);
    buttonDone.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {

            alertDialog.dismiss();

        }
    });
Neelu Agrawal
fonte
diálogo personalizada com a altura costume de diálogo
Neelu Agrawal