Foro de elhacker.net

Programación => Java => Mensaje iniciado por: MaX2 en 22 Abril 2019, 20:00 pm



Título: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 22 Abril 2019, 20:00 pm
Hola, tengo creado un menú horizontal con pestañas desde las que llamo a la clase que extienden de Fragment, donde tengo puesto unos botones para abrir una segunda clase Fragment.
 
El problema es que cunado llamo a esta segundo Fragment el primer Fragment se siguen mostrando debajo.
 
Lo de poner un fondo no es efectivo, porque si pulsamos sobre una parte de la pantalla que contiene debajo un botón, éste sigue activo y mostraría su contenido.
 
Alguien me puede decir como evitar que se superpongan los Fragment ?
 
Este es el codigo que tengo puesto en el Fragment y su xml

Menu1.java extends Fragment

Código:
 public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {

        View rootView = inflater.inflate( R.layout.menu1, container, false );

        bt_apuntes = rootView.findViewById(R.id.btn_Apuntes);
        bt_apuntes.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Apuntes_2 fl=new Apuntes_2();
                FragmentTransaction transaction=manager.beginTransaction();
                transaction.replace(R.id.fragmen_menu1,fl);
                transaction.addToBackStack(null);
                transaction.commit();
            }
        });

  return rootView;

}

Menu1.xml  (he quitado mas código que tengo puesto para otros botones para dejar de ejemplo solo uno)


Código:
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    ....
    ....
    android:clickable="true"
    android:focusable="true"
    tools:context=".Menu1">

    <FrameLayout
        ....
        ....
        android:id="@+id/fragmen_menu1">

            <androidx.constraintlayout.widget.ConstraintLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

                <Button
                    android:id="@+id/btn_Apuntes"
                    android:text="Apuntes"
                    ....
                    ....
                    ....
                    ..../>
            </androidx.constraintlayout.widget.ConstraintLayout>

    </FrameLayout>

</androidx.constraintlayout.widget.ConstraintLayout>


P.D. lo de poner el android:clickable="true" y android:focusable="true" es porque he leido que para que no se superpongan los fragment hay que ponelo, pero a mi no me funciona.


Un saludo.


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: srWhiteSkull en 22 Abril 2019, 20:13 pm
Tienes que hacerle un pop al contenedor o gestor de Fragments. Hace tiempo qeu no trabajo con Android pero creo que era con ésto :

https://developer.android.com/reference/android/app/FragmentManager.html

Investiga

PD O guarda la referncia del anterior y hazle un onDestroy(), porque por lo que veo lo que te puse está deprecated.


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 22 Abril 2019, 20:25 pm
Hola srWhiteSkull, gracias por responder tan pronto, la verdad es que no estoy muy puesto y ando un poco perdido, y no se muy bien lo que quiere decir de hacer un pop al contenedor, y la pagina oficial con la traducción que hace google hay veces que....

Creo que se lo que me quieres decir, sustituir el layaut de ese fragment por el segundo, de todas formas en un rato pongo el código en el primer post por si se puede ver mejor lo que estoy haciendo mal.

La verdad es que llevo viendo muchos vídeos, para ver si que codigo utilizandan en los ejemplos y los que he visto siempre llaman a un solo Fragment desde una clase que extiende de AppCompatActivity, lo de llamar a un fragmen desde otro fragmen no lo he visto


Editado
No me interesa destruir los fragment anteriores, porque necesito volver atrás.

Un saludo.


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: srWhiteSkull en 22 Abril 2019, 20:51 pm
No, me refiero hacer un pop, un pop es sacar el Fragment. Supuestamente los Fragment o las vistas se van apilando y existe un gestor que te indiqué en el enlace y que en la documentación recomiendan no usarlo por obsolescencia. Este gestor de fragmentos tiene funciones para sacar el último Fragment, y combinándolo con otro objeto que ya ni me acuerdo, recuerdo que podías hacer transiciones entre Fragments. La verdad es que no estoy muy puesto al día pero si recuerdo el problema que comentas.

En teoría según la doc debes evitar usar el sistema comentado y atenerte al ciclo de vida del Fragment por lo que sugiero que pruebes usar el método onDestroy() con el Fragment que se queda atrás, y para ello debes conservar de alguna manera su "referencia".

Quizás si no entiendes los términos descritos aquí lo que necesitas es más práctica y experiencia con la programación del Api de Android. Si no quieres destrozar el proyecto que tienes con experimentos te aconsejo que crees nuevos proyectos de prueba y cuando entiendas todo eso lo apliques al proyecto que tienes entre mano.

Suerte


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: srWhiteSkull en 22 Abril 2019, 20:58 pm
Siento el doble post, pero viendo el código que has puesto creo que vas encaminado, prueba usar el método remove(FragmentoAnterior) y luego aplicar el reaplce(nuevoFragmento) o el add(NuevoFragmento).

PD Voy a echar un vistazo a algo que tenga por ahí.


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: srWhiteSkull en 22 Abril 2019, 21:04 pm
En el activity :
Código
  1.    public void cambiaFrame(String nombre, Fragment fragmento){
  2.        esPrincipal=false;
  3.        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
  4.        if (getSupportFragmentManager().getBackStackEntryCount()>=1){ // Comprobamos la pila, y si existen más Fragments dentro entonces...
  5.            if (getSupportFragmentManager().getFragments().get(1).getClass()!=fragmento.getClass()) {
  6.                getSupportFragmentManager().popBackStack(); // Sacamos el de atrás de la pila (creo que era para evitar que cuando pulsaras el botón BACK volvieras a la vista anterior)
  7.                ft.replace(R.id.fragment, fragmento); // y reeplazamos
  8.                ft.addToBackStack(nombre); // Le ponemos un nombre a ese Fragment
  9.            }
  10.        } else {
  11.            ft.add(R.id.fragment, fragmento); // En caso de no existir ninguno simplemente añadimos
  12.            ft.addToBackStack(nombre);
  13.        }
  14.        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
  15.        getSupportActionBar().setDisplayShowHomeEnabled(true);
  16.        findViewById(R.id.boton_sms).setVisibility(View.INVISIBLE);
  17.        ft.commit();
  18.    }
  19.  

PD También podrías hacerlo invisible o destruirlo, al de atrás, prueba eso también si este código no te sirve.

Resto del código :
https://github.com/RufusWein/proyecto-fin-curso/blob/master/Cliente%20Android%20con%20Pasarela%20SMS/StudentManager/app/src/main/java/tk/srwhiteskull/studentmanager/ActividadPrincipal.java


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 22 Abril 2019, 21:25 pm
He cambiado la imagen, porque he corregido los fallos que puse antes, pero todavía me siguen dando errores

(http://i63.tinypic.com/jinqrl.png)






Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 23 Abril 2019, 19:37 pm
He cambiado la imagen porque parece que en el servidor donde estaba no se podia ver, a no ser que se entre con un proxy, asi que la he cambiado de sitio.

Como ves en esa imagen hay algunos errores que no se como corregirlos, otros como el "boton_sms" yo utilizo botones independientes.






Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: srWhiteSkull en 23 Abril 2019, 22:43 pm
Los elementos que comienzan por R indican que son recursos estáticos. Eso significa que ya están creados y definidos en el proyecto. En el caso que te puse de ejemplo, no era para que hicieras un copy/paste, algo que deberías entender si vas a dedicarte a la programación.

Lo siguiente que te voy a mostrar, es un ejemplo más sencillo, pero no es para que hagas copy/paste, es para que asimiles el funcionamiento del proceso de transacción o reemplazo de fragmentos evitando el solapamiento de éstos al retroceder por medio del botón BACK del sistema.

Para que asimiles esto estudia el código y prueba comentar la línea de la función cambiaFrame() del Activity, getSupportFragmentManager().popBackStack(), que es la encargada de sacar el fragmento que se encuentra apilado y que aunque la transacción lo reemplaza en verdad permanece vivo en la aplicación. Verás también, en la consola de depuración, como el resultado de Fragmentos Apilados se incrementa según invoques los fragmentos al pulsar los botones Fragmento A y Fragmento B cuando dicha línea esté comentada pero cuando la línea no está comentada el apilamiento será siempre 1.

Normalmente cuando pulsas la tecla BACK del sistema en la actividad tenderá a volver hacia atrás, si no hay nada en la pila volverá al escritorio pero si existen fragmentos vivos en la pila irá haciendo pop liberando en cada pulsación cada fragmento. Esto lo verás al comentar la susodicha línea. Fíjate en la consola de depuración.

Recursos

Código
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.    xmlns:app="http://schemas.android.com/apk/res-auto"
  4.    xmlns:tools="http://schemas.android.com/tools"
  5.    android:layout_width="match_parent"
  6.    android:layout_height="match_parent"
  7.    android:background="#F44336"
  8.    android:orientation="vertical"
  9.    tools:context=".MainActivity">
  10.  
  11.    <LinearLayout
  12.        android:layout_width="match_parent"
  13.        android:layout_weight=".15"
  14.        android:background="#00BCD4"
  15.        android:orientation="horizontal"
  16.        android:layout_height="0dp">
  17.  
  18.        <Button
  19.            android:id="@+id/llamaFragmentoA"
  20.            android:layout_width="wrap_content"
  21.            android:layout_height="match_parent"
  22.            android:layout_weight="1"
  23.            android:text="Fragmento A" />
  24.  
  25.        <Button
  26.            android:id="@+id/llamaFragmentoB"
  27.            android:layout_width="wrap_content"
  28.            android:layout_height="match_parent"
  29.            android:layout_weight="1"
  30.            android:text="Fragmento B" />
  31.    </LinearLayout>
  32.  
  33.    <FrameLayout
  34.        android:id="@+id/contenedor"
  35.        android:layout_width="match_parent"
  36.        android:layout_weight=".85"
  37.        android:layout_height="0dp">
  38.  
  39.    </FrameLayout>
  40. </LinearLayout>

Código
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.    android:layout_width="match_parent"
  4.    android:layout_height="match_parent">
  5.  
  6.  
  7.    <LinearLayout
  8.        android:layout_width="match_parent"
  9.        android:layout_height="match_parent"
  10.        android:orientation="vertical">
  11.  
  12.        <TextView
  13.            android:id="@+id/textView"
  14.            android:layout_width="match_parent"
  15.            android:layout_weight=".50"
  16.            android:gravity="center"
  17.            android:text="Fragmento A"
  18.            android:layout_height="0dp" />
  19.  
  20.        <FrameLayout
  21.            android:layout_width="match_parent"
  22.            android:layout_height="0dp"
  23.            android:layout_weight=".50"
  24.            android:background="#4CAF50">
  25.  
  26.            <EditText
  27.                android:id="@+id/editText"
  28.                android:layout_width="match_parent"
  29.                android:layout_height="match_parent"
  30.                android:ems="10"
  31.                android:gravity="center"
  32.                android:inputType="textPersonName"
  33.                android:text="A"
  34.                android:textSize="200dp" />
  35.        </FrameLayout>
  36.  
  37.    </LinearLayout>
  38. </FrameLayout>

Código
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.    android:layout_width="match_parent"
  4.    android:layout_height="match_parent">
  5.  
  6.  
  7.    <LinearLayout
  8.        android:layout_width="match_parent"
  9.        android:layout_height="match_parent"
  10.        android:orientation="vertical">
  11.  
  12.        <FrameLayout
  13.            android:layout_width="match_parent"
  14.            android:layout_height="0dp"
  15.            android:layout_weight=".50"
  16.            android:background="#FF9800">
  17.  
  18.            <EditText
  19.                android:id="@+id/editText"
  20.                android:layout_width="match_parent"
  21.                android:layout_height="match_parent"
  22.                android:ems="10"
  23.                android:gravity="center"
  24.                android:inputType="textPersonName"
  25.                android:text="B"
  26.                android:textSize="200dp" />
  27.        </FrameLayout>
  28.  
  29.        <TextView
  30.            android:id="@+id/textView"
  31.            android:layout_width="match_parent"
  32.            android:layout_weight=".50"
  33.            android:gravity="center"
  34.            android:text="Fragmento B"
  35.            android:layout_height="0dp" />
  36.  
  37.    </LinearLayout>
  38. </FrameLayout>

Codigo

Hay que añadir a cada clase el package con el nombre correspondiente que le hayas dado al proyecto.

Código
  1. import android.content.Context;
  2. import android.support.v4.app.Fragment;
  3. import android.support.v4.app.FragmentTransaction;
  4. import android.support.v7.app.AppCompatActivity;
  5. import android.os.Bundle;
  6. import android.util.AttributeSet;
  7. import android.util.Log;
  8. import android.view.View;
  9. import android.widget.Button;
  10.  
  11. public class MainActivity extends AppCompatActivity {
  12.  
  13.    @Override
  14.    protected void onCreate(Bundle savedInstanceState) {
  15.        super.onCreate(savedInstanceState);
  16.        setContentView(R.layout.activity_main);
  17.  
  18.        findViewById(R.id.llamaFragmentoA).setOnClickListener(new View.OnClickListener() {
  19.            @Override
  20.            public void onClick(View v) {
  21.                Log.d("Evento","Frgamento A");
  22.                cambiaFrame("A",new FragmentoA());
  23.            }
  24.        });
  25.  
  26.        findViewById(R.id.llamaFragmentoB).setOnClickListener(new View.OnClickListener() {
  27.            @Override
  28.            public void onClick(View v) {
  29.                Log.d("Evento","Frgamento B");
  30.                cambiaFrame("B",new FragmentoB());
  31.            }
  32.        });
  33.    }
  34.  
  35.    public void cambiaFrame(String nombre, Fragment fragmento){
  36.        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
  37.        int numFragmentos = getSupportFragmentManager().getBackStackEntryCount();
  38.        Log.d("Frame","Fragmentos Apilados = "+numFragmentos);
  39.        if (numFragmentos>=1){ // Comprobamos la pila, y si existen más Fragments dentro entonces...
  40.            // Comenta esta linea y compara el resultado sin comentar esta linea, cual es la conclusión?
  41.            getSupportFragmentManager().popBackStack(); // Sacamos el de atrás de la pila (creo que era para evitar que cuando pulsaras el botón BACK volvieras a la vista anterior)
  42.  
  43.            ft.replace(R.id.contenedor, fragmento); // y reeplazamos
  44.            ft.addToBackStack(nombre); // Le ponemos un nombre a ese Fragment
  45.  
  46.        } else {
  47.            ft.add(R.id.contenedor, fragmento); // En caso de no existir ninguno simplemente añadimos
  48.            ft.addToBackStack(nombre);
  49.        }
  50.        ft.commit();
  51.    }
  52.  
  53.    @Override
  54.    public void onBackPressed() {
  55.        super.onBackPressed();
  56.        int numFragmentos = getSupportFragmentManager().getBackStackEntryCount();
  57.        Log.d("Frame","Haciendo Pop, fragmentos apilados = "+numFragmentos);
  58.  
  59.    }
  60. }

Código
  1. import android.os.Bundle;
  2. import android.support.v4.app.Fragment;
  3. import android.view.LayoutInflater;
  4. import android.view.View;
  5. import android.view.ViewGroup;
  6. import android.widget.TextView;
  7.  
  8. /**
  9.  * A simple {@link Fragment} subclass.
  10.  */
  11. public class FragmentoA extends Fragment {
  12.  
  13.  
  14.    public FragmentoA() {
  15.        // Required empty public constructor
  16.    }
  17.  
  18.  
  19.    @Override
  20.    public View onCreateView(LayoutInflater inflater, ViewGroup container,
  21.                             Bundle savedInstanceState) {
  22.        return inflater.inflate(R.layout.fragmento_a, container, false);
  23.    }
  24.  
  25. }

Código
  1. import android.os.Bundle;
  2. import android.support.v4.app.Fragment;
  3. import android.view.LayoutInflater;
  4. import android.view.View;
  5. import android.view.ViewGroup;
  6. import android.widget.TextView;
  7.  
  8. /**
  9.  * A simple {@link Fragment} subclass.
  10.  */
  11. public class FragmentoB extends Fragment {
  12.  
  13.  
  14.    public FragmentoB() {
  15.        // Required empty public constructor
  16.    }
  17.  
  18.  
  19.    @Override
  20.    public View onCreateView(LayoutInflater inflater, ViewGroup container,
  21.                             Bundle savedInstanceState) {
  22.        return inflater.inflate(R.layout.fragmento_b, container, false);
  23.    }
  24.  
  25. }

Este sistema permite solucionar el problema que tienes pero como indica la doc en Apis iguales o superiores a la 28 se debe prescindir del FragmentManager, aconsejando tener en cuenta el ciclo de vida (https://developer.android.com/topic/libraries/architecture/lifecycle.html).


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 24 Abril 2019, 06:19 am
Esta tarde me llevare el portátil al curro y lo probare, pero por lo que veo es más o menos lo que yo tengo con un código parecido, y eso si me está funcionando, puedo mostrar desde los botones del AppCompatActivity los Fragment.

(http://i64.tinypic.com/xpoges.png)

El problema viene en el siguiente paso, que en el código que pones no está, que sería poner unos botones en uno de los Fragment y abrir otro Fragment

(http://i66.tinypic.com/2qs5isx.png)

Ahí es donde tengo el problema para mostrar ese segundo Fragment

(http://i66.tinypic.com/2mcsmra.png)


Mira a ver si con el video se muestra algo más claro,

tdGuSrzwNBQ


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: srWhiteSkull en 24 Abril 2019, 19:34 pm
Todo eso es lo mismo que le expliqué en la publicación. Como puedes apreciar el fragmento B sigue vivo y posiblemente el resto de fragmentos. De esa forma cuando usted haga BACK volverá al fragmento que hay debajo.


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 24 Abril 2019, 19:55 pm
Te respondo con dificultad porque escribo desde el móvil, y no tengo muy buena cobertura.
He probado el código que has puesto y funciona bien, igual como el que tengo yo y puedes ver en el video, pero cuando se colocan unos botones en un Fragment para mostrar otro Fragment, es cuando aparece ese problema de Fragment superpuestos.

Interesa tener los fragment anteriores vivo para poder volver atrás y poder mostrarlo.

Se puede solucionar de alguna forma, he puesto un fondo, pero no es efectivo porque, aunque no se ven los botones, siguen activos, y si se pulsa encima de uno de los botones, aunque no se vea, se abre su fragment.


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: srWhiteSkull en 24 Abril 2019, 20:01 pm
Entonces si te interesa que estén vivos lo único que debes hacer es que el layout que lo solapa le tengas puesto la propiedad clickable false.

https://developer.android.com/reference/android/view/View#attr_android:clickable

De esa forma al hacer click sobre el fondo no traspasará o no debería traspasarlo y hacer click a lo que haya detrás.

PD Puedes implementarlo también en la vista de diseño (en el XML), así :

Código:
android:clickable="false"


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 24 Abril 2019, 20:36 pm
No se si me dará tiempo a probarlo ahora, pero lo que comentas de poner android:clickable="false", no tengo claro en el xml donde colocarlo, porque en el momento que lo ponga, no se van a anular los botones ?

Quiero decir que la primera vez que entre al fragmen y me muestre los botones si ya los he anulado no podre abrir el otro fragmen, y si lo pongo en el segundo fragment anulara los botones  que hay en este segundo fragment.


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: srWhiteSkull en 24 Abril 2019, 20:40 pm
Eso va en el XML del fragmento, en sus propiedades, como cuando especificas el ancho, alto o color de fondo (que es lo que habrás hecho para tapar lo que hay detrás). Ese atributo le indica a la aplicación que esa vista no puede ser clickable pero los componentes que existan dentro de esa vista no se verán afectados como botones etc. Creo haber usado eso hace tiempo, pero si lo pruebas ya nos cuentas por aquí y de paso acuérdate de mostrar el XML donde lo incluiste a ver si lo pusiste correctamente.

PD Quizás si tengo tiempo te muestro un ejemplo.


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 24 Abril 2019, 20:59 pm
Espera srWhiteSkull no te molestes en poner codigo, voy a ver si puedo hacerlo, y si no doy con la solucion te lo digo, pero como te comenta no se si voy a poder hacerlo ahora.

Estaba viendo con el movil, que odio tener que leer desde él, jeje, que tambien hay que poner en el xml esto:

Código:
android:focusable="true"
android:focusableInTouchMode="true"

no entiendo porque.

y tambien despues de llamar al FragmenD poner este codigo para ignorará todos botones

Código:
FragmenA.setOnTouchListener(new OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        return true;
    }
});



Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 24 Abril 2019, 22:48 pm
Estaba deseando probarlo para ver si puedo seguir con la aplicación, pero no he tenido suerte con android:clickable="false", incluso he llegado a ponerlo en los dos a la vez, en el ConstraintLayout y en FrameLayout, y cuando los botones se siguen quedando activos.



Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 25 Abril 2019, 20:08 pm
Mira srWhiteSkull incluso colocandolo en los dos, en LinearLayout y androidx.constraintlayout.widget.ConstraintLayout los link siguen activos, si que pone un color de fondo para que no se van, pero como digo siguen activos los link que hay debajo.

Tambien lo he puesto en el XML del que se queda debajo, pero nada.

(http://i68.tinypic.com/33wpqw1.png)


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: srWhiteSkull en 25 Abril 2019, 22:03 pm
Al final me hicistes probarlo, con lo liado que andaba, y funciona, solo que es con clickable=true, ya que de esa forma la vista que solapa el botón que hay detrás, absorbe el evento y no llega a lo que tenga detrás!!

Una demo (API >=28):
https://drive.google.com/file/d/1sKJjZl-mjxuSbYPlxcmqukYH8JCqPmbS/view?usp=sharing

API min 22 y max 26:
https://drive.google.com/file/d/1JLnSJJRlYHiGMRB8GTzHAZndDZc1G0YF/view?usp=sharing

PD Quita el atributo focusable


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 25 Abril 2019, 23:22 pm
Gracias de verdad srWhiteSkull, si estabas liado, había preferido que comentases que luego mañana o pasado lo probarías, o cuando estés menos liado, yo he ido respondiendo por si alguien de las mas de 400 visitas que tiene el post podía comentar algo, bueno igual están en la misma situación que yo, aunque creo que sea difícil, jeje.

He  probado el de la API 22 y max 26, porque tengo Android 7.1, y veo que funciona, pero si en un futuro tengo un móvil nuevo, que ya tendrá una API superior, que diferencia hay en el código entre uno y otro ? porque pensaba que si se crea una app para utilizarla en un movil con API 25, esta app tambien funcionaria sin problemas en otros con API 29

Por otro lado, seria posible ver el codigo nuevo que has creado para esta apk, porque estoy colocando el android:clickable="true" y los botones me siguen funcionando.

Por cierto, al pone clickable="true" me dice que tengo que poner también android:focusable="true"

Editado
Espera espera, que con las prisas lo estaba colocando en otro xml, Voy a probarlo en otro proyecto que tengo a ver que tal funciona.





Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: srWhiteSkull en 25 Abril 2019, 23:33 pm
No entiendo por qué necesitarías el código, es así tal como te dije:

Si este fuera el fragmento que superpones:
Código
  1. <FrameLayout
  2. ...
  3. ...
  4.  
  5.    <!-- Aqui una vista qeu abarca todo el frgamento -->
  6.    <LinearLayout
  7.        android:clickable="true"
  8. ...
  9.  

En el contenedor no tienes que poner nada y el focusable ese sobra, y quizás el problema vas a tenerlo en el diseño de la aplicación. De todas formas hasta aquí puedo echarte una mano, no puedo dar soporte a un usuario con un problema tan complejo solo orientarte. Ya si requieres soporte deberías ponerte en contacto con alguna empresa o desarrollador, lo siento MaX2.

PD Ensambla pequeños proyectos de prueba como el que hice para que estudies el efecto del clickable y el focusable, pero ya te digo el focusable sobra.


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 25 Abril 2019, 23:46 pm
Sí señor, está funcionando, ya no están activos los botones, te decía lo del código por si cambia algo dependiendo de la API, de verdad que muy agradecido, aunque para ti solo sea echar una mano, para mí me has ayudado mucho, llevo mucho tiempo, con este problema y no encontraba solución.

Editado, se me olvido para srWhiteSkull.....

(http://i64.tinypic.com/2j64h7r.png)

Solo por curiosidad, porque he visto que tu apk no pesa mucho, en cambio cuando creo la mía pesa mucho, pero mucho, he visto que al crear el apk le pone la carpeta "lib" con todas las librerías, armeabi-v7a, x86, x86_64, armeabi, mips, mips64, arm64-v8a, y el caso es que si las quito la armeabi-v7a, que parece que es el que lleva mi móvil, no funciona la aplicación, porque son necesarias, en cambio tu apk no las lleva.



Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: srWhiteSkull en 26 Abril 2019, 00:06 am
Por eso mismo que citas, yo hace mcho tiempo que no desarrollo en Android y cuadno lo toco para prbar algo como el porblema que traías, simplemente me limito a probarlo en mi móvil, que trabaja con la API 26 (Oreo) y ya está. Pero si tú caso es para publicarlo en el store pues es de agradecer que abarques bastantes APIS pues interesa tener basatnte público. Es necesario que comprendas eso y tengas una idea de como configurar eso con la herramienta denominada Gradle, que es como se configura el tema de las APis.

https://developer.android.com/studio/build?hl=ES

Bueno suerte con tú trabajo MAx2 y espero que no me des más la brasa :xD (es broma)
Fue un placer, hasta otra.


Título: Re: Andoid - Como evitar los Fragment superpuestos
Publicado por: MaX2 en 26 Abril 2019, 00:13 am
Gracias nuevamente, pero no, es sólo una aplicación para mí, para ordenar un poco la documentacion que utilizó en el curro, y poderla tener a mano de forma rápida.

Lo dicho... Muchas gracias por tu tiempo y por tu gran ayuda.