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

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.

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 )

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

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.

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>

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

dialog.getWindow().setLayout(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);

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

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.

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

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

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

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

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

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

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

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.

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.

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

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

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

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>

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

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>

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

dialog.getWindow().setLayout(WindowManager.LayoutParams.MATCH_PARENT,WindowManager.LayoutParams.WRAP_CONTENT);

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

        }
    });