emergentes - tipos de dialogos en android studio

Pantalla completa DialogFragment en Android

Question

Intento mostrar un DialogFragment casi en pantalla completa. Pero de alguna manera no puedo hacerlo.

La forma en que estoy mostrando el Fragmento es directamente de la documentación del desarrollador de 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");

Sé ingenuamente intenté establecer el RelativeLayout en el fragmento para fill_parent y algunos minWidth y 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">

Me gustaría saber que DialogFragment ocupará la mayor parte de la pantalla. Pero solo parece cambiar el tamaño verticalmente, pero solo hasta cierto ancho fijo horizontalmente.

También traté de configurar los Atributos de ventana en el código, como se sugiere aquí: http://groups.google.com/group/android-developers/browse_thread/thread/f0bb813f643604ec . Pero esto tampoco ayudó.

Probablemente esté malinterpretando algo acerca de cómo maneja Android Dialogs, ya que soy nuevo en él. ¿Cómo puedo hacer algo como esto? ¿Hay alguna forma alternativa de alcanzar mi objetivo?

Dispositivo Android:
Transformador Asus EeePad
Android 3.0.1

Actualización: ahora logré ponerlo en pantalla completa, con el siguiente código en el fragmento

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

Lamentablemente, esto no es lo que quiero querer. Definitivamente necesito un pequeño "relleno" alrededor del diálogo para mostrar el fondo.

¿Alguna idea de cómo lograr eso?

Answer 1

Realice un DialogFragment de pantalla completa utilizando solo el estilo

Primera opción

1. Agregue a su 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. Agregue a su DialogFragment:

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

Segunda opción

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setStyle(DialogFragment.STYLE_NO_FRAME, R.style.AppTheme)
}

donde AppTheme es el tema que AppTheme en los estilos.

Answer 2

Chirag Nagariya tiene razón, excepto la adición de ''_Fullscreen''. se puede resolver utilizando cualquier estilo base que no se derive del estilo Dialog. ''android.R.style.Theme_Black_NoTitleBar'' se puede usar también.

Answer 3

Conocí el problema antes cuando uso un cuadro de diálogo de pantalla completaFragmento: siempre hay un relleno mientras se configura la pantalla completa. prueba este código en el método dialogFragment onActivityCreated ():

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

Answer 4

Cree el tema a continuación en su 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>

luego configura el estilo en DialogFragment

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

Answer 5

De hecho, puede depender de cómo se define el diseño. Pero para garantizar que el diálogo tenga el tamaño requerido, la mejor solución es proporcionar los LayoutParams una vez que se muestra el diálogo (y no en la creación). En un DialogFragment, el diálogo se muestra en el método onStart , por lo que un método válido para obtener el ancho completo es:

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

Para proporcionar también un tema o estilo, como un estilo NO_TITLE, la mejor ubicación es en el método onCreate :

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

Answer 6

En caso de que alguien más se encuentre con esto, tuve una experiencia similar a esta, pero resulta que el problema era que había olvidado devolver la vista inflada desde onCreateView (en lugar de devolver el super.onCreateView predeterminado). Simplemente devolví la vista inflada correcta y eso resolvió el problema.

Answer 7

En cuanto a la API de Android se actualizó, el método sugerido para mostrar un cuadro de diálogo de pantalla completa es el siguiente:

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

de lo contrario, si no desea que se muestre a pantalla completa, puede hacerlo de esta manera:

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

Espero eso ayude.

EDITAR

Tenga en cuenta que la solución que di funciona, pero tiene una debilidad que a veces puede ser problemática. Agregar el DialogFragment al contenedor android.R.id.content no le permitirá manejar la función DialogFragment#setCancelable() correctamente y podría generar comportamientos inesperados al agregar DialogFragment a la pila de respaldo también.

Así que le sugerí que simplemente cambie el estilo de su DialogFragment en el método onCreate de la siguiente manera:

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

Espero eso ayude.

Answer 8

En mi caso, utilicé el siguiente enfoque:

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

Además de LinearLayout para llenar todo el espacio con contenido.

Pero todavía había pequeños huecos entre los bordes izquierdo y derecho del diálogo y los bordes de la pantalla en algunos dispositivos Lollipop + (por ejemplo, Nexus 9).

No fue obvio, pero finalmente me di cuenta de que para hacerlo de ancho completo en todos los dispositivos y plataformas , el fondo de la ventana debe especificarse en styles.xml como el siguiente:

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

Y, por supuesto, este estilo debe usarse cuando creamos el diálogo de la siguiente manera:

 public static DialogFragment createNoTitleDlg() {
DialogFragment frag = new Some_Dialog_Frag();
frag.setStyle(DialogFragment.STYLE_NO_TITLE, R.style.Dialog_NoTitle);
return frag;
}

Answer 9

Esto es lo que necesita configurar para fragmentar:

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

En tu caso:

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

¿Y por qué? Debido a que DialogFragment (cuando no se lo dice explícitamente), usará sus estilos internos que envolverán su diseño personalizado (sin pantalla completa, etc.).

Y diseño? No se necesita una forma hacky, esto está funcionando bien:

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

Disfrutar

Answer 10

Intente cambiar a LinearLayout lugar de RelativeLayout . Estaba apuntando a la api 3.0 Honeycomb al probar.

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

y los diseños : 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>

Answer 11

Intente utilizar setStyle () en onCreate y anule onCreateDialog para crear un diálogo sin título

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

o simplemente anule en Crear () y establecer el código del tipo.

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

Answer 12

La siguiente forma funcionará incluso si está trabajando en un diseño relativo. Sigue los siguientes pasos:

1. Ir al editor de temas (disponible en Herramientas-> Android-> Editor de temas)
2. Seleccione mostrar todos los temas. Seleccione el que tiene AppCompat.Dialog
3. Elija la opción de fondo de la ventana de Android si desea que sea de un fondo de color específico o transparente.
4. Seleccione el color y presione OK. Seleccione un nombre del nuevo tema.

5. Vaya a styles.xml y luego debajo del tema que acaba de agregar, agregue estos dos atributos:

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

La configuración de mi tema para el diálogo es como debajo de:

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

Asegúrese de que el tema tenga un elemento principal como Theme.AppCompat.Dialog. Otra forma sería simplemente crear un nuevo estilo en styles.xml y modificarlo según el código anterior.

6. Vaya a su clase de Fragmento de Diálogo y en el método onCreate () , configure el estilo de su Diálogo como:

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

Answer 13

Llegué muy tarde para responder esta pregunta, pero quiero compartir esta respuesta para que en el futuro cualquiera pueda usar esto.

He usado este código en mi proyecto, funciona tanto en versiones más pequeñas como en versiones superiores.

Simplemente use este tema dentro de CreateDialog () de esta manera:

@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: aquí está el código fuente de este tema, puede ver que solo este tema es suficiente para hacer que DialogFragment aparezca en pantalla completa.

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

Por favor, avíseme si alguien tiene algún problema. Espero que esto sea útil. Gracias :)

Answer 14

Para obtener DialogFragment en pantalla completa

Anular el onStart de su onStart de la siguiente manera:

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

Y muchas gracias a esta publicación: techrepublic.com/article/…

Answer 15

Pruebe esto para el diálogo de fragmentos comunes para múltiples usos. Espero que esto te ayude 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();
}
}

Answer 16

Según este enlace, la pantalla completa de DialogFragment muestra relleno en los costados, esto funcionará como un amuleto.

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

Answer 17

esta es la solución de cómo resolví este 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));
}
}

Answer 18

window.setLayout no es suficiente para dispositivos más antiguos.

Esto es lo que hago:

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

Answer 19

@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 solución aplica un tema de pantalla completa en el diálogo, que es similar al setStyle de Chirag en onCreate. Una desventaja es que savedInstanceState no se usa.

Answer 20

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