elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Los 10 CVE más críticos (peligrosos) de 2020


  Mostrar Mensajes
Páginas: 1 2 3 [4] 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ... 54
31  Programación / Java / Re: Andoid - Como evitar los Fragment superpuestos 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.
32  Programación / Bases de Datos / Re: Implementación de una base de datos en un programa local. en: 24 Abril 2019, 19:25 pm
Bueno, el caso es que puedes probar implementarlo mediante CSV si no es muy ambiciosa, y por otro lado si usas programación orientada a objetos crearte una clase, que si en un futuro se desea implementar otro tipo de base de datos pues simplemente te pones a ello.

Aplicación -> Clase DATOS -> Clase CSV, Clase MySQL, Clase Access

Yo lo haría así. Pero si hay algo escrito en el manual del buen programador no lo se.

Suerte.



33  Programación / Bases de Datos / Re: Implementación de una base de datos en un programa local. en: 24 Abril 2019, 13:09 pm
Depende, cual es la magnitud? Son millones de registros? Cada cuanto tiempo rondan las operaciones? Pues en base a un previo estudio de las necesidades del programa usarás esto o aquello, desde el sencillo CSV en texto plano, pasando por Access, DB2 basada en XML, motores SQL, etc..
34  Programación / Java / Re: Andoid - Como evitar los Fragment superpuestos 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.
35  Programación / Java / Re: Andoid - Como evitar los Fragment superpuestos 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
36  Programación / Java / Re: Andoid - Como evitar los Fragment superpuestos 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í.
37  Programación / Java / Re: Andoid - Como evitar los Fragment superpuestos 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
38  Programación / Java / Re: Andoid - Como evitar los Fragment superpuestos 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.
39  Programación / PHP / Re: Programacion PHP en: 22 Abril 2019, 18:04 pm
https://www.w3schools.com/php/
40  Programación / Programación General / Re: Programación para android en: 20 Abril 2019, 15:36 pm
Qués es una caché? Ficheros.

Por ejemplo te bajas una imagen llamada "perfil". Pues lo único que haces es volcar esa imagen a un fichero, "perfil.jpg". Luego en la siguiente inicialización antes de bajarte la imagen compruebas si existe "perfil.jpg", de ser así la cargas como un fichero normal y pasas esa imagen al componente drawable pertinente.

Aunque en apariencia puede parecer sencillo hay bastante complejidad. Yo para evitar que se detuviera la aplicación disponía de una clase que hacía ésto y que procesaba en un hilo, por lo que podían lanzarse muchísimos hilos a la vez, uno detrás de otro, con la suerte de que tenían un tiempo de vida de unos pocos segundos o menos dependiendo de la imagen. Se consumían recursos pero luego se liberaban.

Posiblemente existan librerías de terceros que hagan lo mismo pero muchas veces me gusta reinventar la rueda y hacerlo todo por mi cuenta, al fin y al cabo la clase sólo me supuso como 200 líneas de código.

Páginas: 1 2 3 [4] 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ... 54
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines