android - studio - ¿Cómo hacer que un diálogo de alerta llene el 90% del tamaño de la pantalla?
input dialog android (24)
Puedo crear y mostrar un cuadro de diálogo de alerta personalizado muy bien, pero aun así tengo android:layout_width/height="fill_parent" en el cuadro de diálogo xml, solo es tan grande como el contenido.
Lo que quiero es un cuadro de diálogo que llene toda la pantalla, excepto quizás un relleno de 20 píxeles. Luego, la imagen que forma parte del diálogo se extendería automáticamente al tamaño del diálogo completo con fill_parent.
Aún más simple simplemente haz esto:
int width = (int)(getResources().getDisplayMetrics().widthPixels*0.90);
int height = (int)(getResources().getDisplayMetrics().heightPixels*0.90);
alertDialog.getWindow().setLayout(width, height);
Aquí está mi variante para el ancho del diálogo personalizado:
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);
Por lo tanto, en función de la orientación del dispositivo ( ThemeHelper.isPortrait(mContext) ), el ancho del diálogo será del 95% (para el modo vertical) o del 65% (para el horizontal). Es un poco más de lo que el autor preguntó, pero podría ser útil para alguien.
onCreate(Bundle savedInstanceState) crear una clase que se extienda desde Dialog y poner este código en su onCreate(Bundle savedInstanceState) .
Para la altura del diálogo, el código debe ser similar a este.
Aquí hay una breve respuesta que funcionó para mí (Probado en API 8 y 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);
Bueno, tienes que configurar la altura y el ancho de tu cuadro de diálogo antes de mostrar esto (dialog.show ())
Entonces, haz algo como esto:
dialog.getWindow().setLayout(width, height);
//then
dialog.show()
Bueno, tienes que configurar la altura y el ancho de tu cuadro de diálogo antes de mostrar esto (dialog.show ())
Entonces, haz algo como esto:
dialog.getWindow().setLayout(width, height);
//then
dialog.show()
Obteniendo este código, lo hice algunos cambios:
dialog.getWindow().setLayout((int)(MapGeaGtaxiActivity.this.getWindow().peekDecorView().getWidth()*0.9),(int) (MapGeaGtaxiActivity.this.getWindow().peekDecorView().getHeight()*0.9));
sin embargo, el tamaño del diálogo podría cambiar cuando el dispositivo cambie su posición. Tal vez necesite manejar por su cuenta cuando cambien las métricas. PD: peekDecorView, implica que el diseño en la actividad se inicializa correctamente, de lo contrario puede usar
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;
con el fin de obtener el tamaño de la pantalla
De acuerdo con la desarrolladora de la plataforma Android Dianne Hackborn en this publicación del grupo de discusión, los diálogos establecieron el ancho y la altura del diseño de nivel superior de su ventana en WRAP_CONTENT . Para hacer que el MATCH_PARENT diálogo sea más grande, puede establecer esos parámetros en MATCH_PARENT .
Código demo:
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);
Tenga en cuenta que los atributos se establecen después de que se muestra el diálogo. El sistema es delicado acerca de cuando se establecen. (Supongo que el motor de diseño debe establecerlos la primera vez que se muestra el cuadro de diálogo, o algo así).
Sería mejor hacer esto extendiendo Theme.Dialog, entonces no tendrías que jugar un juego de adivinanzas sobre cuándo llamar a setAttributes. (Aunque es un poco más de trabajo que el diálogo adopte automáticamente un tema claro u oscuro apropiado, o el tema Holo de panal. Esto se puede hacer de acuerdo con http://developer.android.com/guide/topics/ui/themes.html#SelectATheme )
De lejos, la forma más simple que se me ocurre -
Si su diálogo está hecho de un LinearLayout vertical, simplemente agregue una vista ficticia de "relleno de altura", que ocupará toda la altura de la pantalla.
Por ejemplo -
<?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 que android:weightSum="1" en los atributos de LinearLayout y android:layout_weight="1" en los atributos de la vista ficticia
Después de inicializar su objeto de diálogo y establecer la vista de contenido. Haz esto y disfruta.
(En el caso de que esté configurando el 90% para el ancho y el 70% para la altura porque el 90% del ancho estará sobre la barra de herramientas)
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();
Establezca android:minWidth and android:minHeight en su vista personalizada xml. Estos pueden forzar la alerta de no solo ajustar el tamaño del contenido. Usando una vista como esta debería hacerlo:
<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>
Intente envolver su diseño de diálogo personalizado en RelativeLayout en lugar de LinearLayout . Eso funcionó para mí.
La especificación de FILL_PARENT en la ventana de diálogo, como sugerían otros, no funcionó para mí (en Android 4.0.4), ya que solo estiró el fondo del diálogo negro para llenar toda la pantalla.
Lo que funciona bien es usar el valor de visualización mínimo, pero especificarlo dentro del código, de modo que el diálogo tome el 90% de la pantalla.
Asi que:
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);
En general, solo el ajuste del ancho debería ser suficiente en la mayoría de los casos.
Lo siguiente funcionó bien para mí:
<style name="MyAlertDialogTheme" parent="Base.Theme.AppCompat.Light.Dialog.Alert">
<item name="windowFixedWidthMajor">90%</item>
<item name="windowFixedWidthMinor">90%</item>
</style>
(nota: windowMinWidthMajor / Minor, como se sugirió en las respuestas anteriores, no funcionó. Mis cuadros de diálogo seguían cambiando de tamaño según el contenido)
y entonces:
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity(), R.style.MyAlertDialogTheme);
Mi respuesta se basa en los koma, pero no requiere anular onStart sino solo onCreateView, que casi siempre se anula de forma predeterminada al crear nuevos 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;
}
Lo he probado en Android 5.0.1.
Obtener el ancho del 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;
}
luego usar eso para hacer un diálogo del 90% del 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();
Por encima de muchas de las respuestas son buenas, pero ninguna de las que me funcionaron completamente. Así que combiné la respuesta de @nmr y obtuve esta.
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();
Puede utilizar el porcentaje para el ancho del diálogo de ventanas (JUST).
Mira en este ejemplo de Holo Theme:
<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>
Todo lo que necesita hacer es extender este tema y cambiar los valores de "Mayor" y "Menor" al 90% en lugar del 65%.
Saludos.
Solución con 90% real de cálculo:
@Override public void onStart() {
Dialog dialog = getDialog();
if (dialog != null) {
dialog.getWindow()
.setLayout((int) (getScreenWidth(getActivity()) * .9), ViewGroup.LayoutParams.MATCH_PARENT);
}
}
donde getScreenWidth(Activity activity) se define de la siguiente manera (la mejor getScreenWidth(Activity activity) es en una clase de Utils):
public static int getScreenWidth(Activity activity) {
Point size = new Point();
activity.getWindowManager().getDefaultDisplay().getSize(size);
return size.x;
}
Todas las otras respuestas aquí tienen sentido, pero no cumplieron con lo que Fabian necesita. Aquí hay una solución mía. Puede que no sea la solución perfecta pero funciona para mí. Muestra un cuadro de diálogo que está en pantalla completa, pero puede especificar un relleno en la parte superior, inferior, izquierda o derecha.
Primero ponga esto en su 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 puedes ver, tengo android: paddingTop = 20dp es básicamente lo que necesitas. El android: windowBackground = @ color / Black0Percent es solo un código de color declarado en mi color.xml
res / values / color.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="Black0Percent">#00000000</color>
</resources>
Ese código de color solo sirve como un dummy para reemplazar el fondo de ventana predeterminado del diálogo con un color de transparencia del 0%.
A continuación, cree el diseño 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, aquí está nuestro cuadro de diálogo que establece una vista personalizada que usa nuestro diálogo.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();
Conclusión: intenté anular el tema del diálogo en el styles.xml llamado CustomDialog. Anula el diseño de la ventana de diálogo y me da la oportunidad de configurar un relleno y cambiar la opacidad del fondo. Puede que no sea la solución perfecta, pero espero que te ayude ... :)
debe usar un style @ style.xml como CustomDialog para mostrar el cuadro de diálogo personalizable.
<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>
y usa este estilo en 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);
y su custom_dialog.xml debe estar dentro de su directorio de diseño
<?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>
...
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
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();
}
});
dialog.getWindow().setLayout(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
dialog.getWindow().setLayout(WindowManager.LayoutParams.MATCH_PARENT,WindowManager.LayoutParams.WRAP_CONTENT);
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;
}
}