<< Galeria imagenes dinamicas con Viewpager , Fragmentos y subfragmentos (siempre OUT OF MEMORY) >>

1,454 views
Skip to first unread message

Pedro_gomez

unread,
Sep 21, 2013, 7:18:03 AM9/21/13
to desarrollad...@googlegroups.com
Hola Compañeros,

a ver si podeis darme algo de luz porque llevo luchando contra los elementos desde hace semanas entre documentación, foros y opiniones. Resulta que he hecho una galeria de imagenes que se cargan de manera dinámica desde la sdcard donde se puede cambiar la distribucion de imagenes por página. La estructura que diseñé es esta:


Básicamente lo que hago es añadir un viewpager con su adapter. Al adaptador solo le paso una lista de string con los nombres de las imagenges que hay y el "GetItem" crea el fragmento. Dependiendo de la distribución que tenga por página, se crean de manera dinámica subfragmentos dentro de este fragmento. Cada subfragmento en el momento de ser creado llama a BitmapWorkedTask para cargar la imagen en un hilo secundario. Os dejo código de las clases principales para que veais como creo todo.

Class ViewPager

Lo que se hace es inicializar el viewpager con la lista de articulos / imagenes a mostrar (list<string>).

class FragmentViewPager : Activity
{
 
private ViewPager pViewPager;

 public ViewPager ViewPager
{
 get { return pViewPager; }
}

public override View OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle bundle)
{
 View v = inflater.Inflate(Resource.Layout.FragmentViewPager, container, false);

 pViewPager = v.FindViewById<ViewPager>(Resource.FragmentViewPager.pager);

 return v;
}

//Inicializa el viewpager
public void Init(List<MGeneral.GrupoArticulo> lista)
{
      this.lista = lista;
      Adaptador ad = new Adaptador(FragmentManager, lista);
      pViewPager.Adapter = ad;
      pViewPager.Adapter.NotifyDataSetChanged();
      pViewPager.OffscreenPageLimit = 1;
}


    public class GrupoArticulo
    {
      private int pCodigo;
      private List<string> pArticulos;
      public int Filas, Columnas;
      public int IdVenta;

      public int Codigo
      {
        get { return this.pCodigo; }
        set { this.pCodigo = value; }
      }

      public List<string> Articulos
      {
        get { return this.pArticulos; }
        set { this.pArticulos = value; }
      }
    }

Class Adaptador viewpager

En el adaptador se guardar todas los codigos de las imagenes en un list<string> y solo se crea el fragmento cuando se llama al GetItem() donde se llama a un metodo de la clase Fragmento para crearlo.


 class Adaptador : FragmentStatePagerAdapter
 {
 private List<MGeneral.GrupoArticulo> pListaGrupoArticulos;

 public Adaptador(Android.Support.V4.App.FragmentManager fm, List<MGeneral.GrupoArticulo> list)
 : base(fm)
 {
 this.pListaGrupoArticulos = list;

 }

 public override int GetItemPosition(Java.Lang.Object @object)
 {
   return PositionNone;
 }

 public override void DestroyItem(ViewGroup container, int position, Java.Lang.Object @object)
 {
 FragmentManager manager = ((Fragment)@object).FragmentManager;
 FragmentTransaction trans = manager.BeginTransaction();
 trans.Remove((Fragment)@object);
 trans.Commit();

 ((Fragmento)@object).OnDestroyView();

 base.DestroyItem(container, position, @object);
 }


 public override Fragment GetItem(int position)
 {
    MGeneral.GrupoArticulo gf;

    gf = this.pListaGrupoArticulos[position-1];

    return Fragmento.Nuevo(gf);
 }

 public override int Count
 {
   get { return this.pListaGrupoArticulos.Count; }
 }
}


class Fragmento

En el onCreateView se crea dinamicamente todos los subfragmentos necesarios de forma dinamica añadiendo al linearlayout base.

 class Fragmento : Fragment
 {
 public const string cParametroFilas = "filas";
 public const string cParametroColumnas = "columnas";
 public const string cParametroArticulos = "articulos";

 private bool pCargado;
 private int pFilas;
 private int pColumnas;
 private List<string> pArticulos;
 private List<SubFragmento> pSubfragmentos;

 private LinearLayout vwPrincipal;
 private View vwCargando;
 private LinearLayout.LayoutParams parametros;

 private SubFragmento pSelected;

 public int Filas
 {
 get { return this.pFilas; }
 set { pFilas = value; }
 }

 public int Columnas
 {
 get { return this.pColumnas; }
 set { pColumnas = value; }
 }

 public SubFragmento Selected
 {
 get { return pSelected; }
 }

 public static Fragmento Nuevo(MGeneral.GrupoArticulo gf)
 {
 Fragmento fragment;
 Bundle bundle;

 fragment = new Fragmento();
 bundle = new Bundle();

 bundle.PutInt(Fragmento.cParametroFilas, gf.Filas);
 bundle.PutInt(Fragmento.cParametroColumnas, gf.Columnas);
 bundle.PutStringArrayList(Fragmento.cParametroArticulos, gf.Articulos.ToArray());

 fragment.Arguments = bundle;

 return fragment;
 }

 public override Android.Views.View OnCreateView(Android.Views.LayoutInflater inflater, Android.Views.ViewGroup viewGroup, Android.OS.Bundle bundle)
 {
 this.pSubfragmentos = new List<SubFragmento>();

 this.pFilas = this.Arguments.GetInt(cParametroFilas);
 this.pColumnas = this.Arguments.GetInt(cParametroColumnas);
 this.pArticulos = new List<string>(this.Arguments.GetStringArrayList(cParametroArticulos));

 CreaLayoutInicial();

 //Cargar el primer fragmento del viewpager.
 if (this.pCargado)
 CreaLayoutConSubfragmentos();

 return this.vwPrincipal;
 }

 public void CreaLayoutInicial()
 {
 vwPrincipal = new LinearLayout(this.Activity);
 vwPrincipal.Orientation = Orientation.Vertical;
 vwPrincipal.SetBackgroundColor(Color.Green);
 parametros = new LinearLayout.LayoutParams(TableRow.LayoutParams.FillParent, TableRow.LayoutParams.FillParent, 1.0f);
 vwPrincipal.LayoutParameters = parametros;

 vwCargando = MGeneral.AddWaitToLayout(this.Activity, vwPrincipal);
 }

 //Crea la estructura de subfragmentos según las filas / columnas
 public void CreaLayoutConSubfragmentos()
 {
 int posicion = 0;

 LinearLayout LayoutRow;
 SubFragmento Farticulo;

 for (int row = 0; row < this.pFilas; row++)
 {
 LayoutRow = new LinearLayout(this.Activity);
 LayoutRow.Orientation = Orientation.Horizontal;
 LayoutRow.SetBackgroundColor(Color.White);
 parametros = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.FillParent, LinearLayout.LayoutParams.FillParent, 1.0f);
 LayoutRow.LayoutParameters = parametros;

 for (int column = 0; column < this.pColumnas; column++)
 {
 Farticulo = new SubFragmento(this.Activity, 1, this.pArticulos[posicion]);
 Farticulo.OnClick += new EventHandler(Farticulo_OnClick);
 Farticulo.SetFragmentManager(FragmentManager);
 Farticulo.SetActivity(this.Activity);
 this.pSubfragmentos.Add(Farticulo);
 
 LayoutRow.AddView(Farticulo.Vista);
 posicion++;
 }

 vwPrincipal.AddView(LayoutRow);
 }

 if (vwCargando != null)
 vwCargando.Visibility = ViewStates.Gone;

 this.pCargado = true;

 }

    //Realizar dispose de los bitmaps que contienen los subfragmentos. Clave para ahorrar memoria.
    public override void OnDestroyView()
    {

      for (int i = 0; i < this.pSubfragmentos.Count; i++)
      {
        this.pSubfragmentos[i].OnDestroyView();
      }

      base.OnDestroyView();
    }

class Subfragmento

Se crea dinamicamente una serie de layouts para pintar la imagen, labels o botones. Como se ve se utiliza el BitmapWrokedTask para cargar la imagen en un hilo secundario.


 public SubFragmento(Context context, int unidadesMedida, string IdArticulo)
 {
 this.pUnidadesMedida = unidadesMedida;
 this.pEnabled = true;
 this.IdArticulo = IdArticulo;
 this.pPathImagen = System.IO.Path.Combine(this.pPathImagen, "Datadec Online/emali/catalogo/3/" + IdArticulo); //load image from sdcard

 CreaTimer();
 CrearLayoutInicial(context);
 CrearLayoutPrincipal(context);

 ThreadPool.QueueUserWorkItem((object sender) =>
 {
 //Cargar informacion actualizada desde base de datos.
 System.Threading.Thread.Sleep(300);
 //((Activity1)this.pActivity).IdVenta;
 //IdArticulo;

 this.pActivity.RunOnUiThread(() =>
 {
 lbDescripcion.Text = lbDescripcion.Text + " ----> Cargado";
 });
 });
 }

 private void CrearLayoutInicial(Context context)
 {
 vwPrincipal = new LinearLayout(context);
 vwPrincipal.LayoutParameters = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.FillParent, LinearLayout.LayoutParams.FillParent, 1.0f);

 this.pView = vwPrincipal;
 }

 public void CrearLayoutPrincipal(Context context)
 {
 fade_in = AnimationUtils.LoadAnimation(context, Resource.Animation.fade_in);
 fade_out = AnimationUtils.LoadAnimation(context, Resource.Animation.fade_out);


 LinearLayout layout1 = new LinearLayout(context);
 layout1.SetBackgroundColor(Color.White);
 layout1.Orientation = Orientation.Horizontal;
 layout1.SetPadding(10, 10, 10, 10);
 layout1.LayoutParameters = param_fill_fill;

 LinearLayout layout2 = new LinearLayout(context);
 layout2.SetBackgroundColor(Color.White);
 layout2.Orientation = Orientation.Vertical;
 layout2.LayoutParameters = param_fill_wrap_20;

 RelativeLayout relative1 = new RelativeLayout(context);
 relative1.SetBackgroundColor(Color.White);
 relative1.LayoutParameters = param_fill_wrap_1;

 LinearLayout layout3 = new LinearLayout(context);
 layout3.SetBackgroundColor(Color.White);
 layout3.Orientation = Orientation.Horizontal;
 layout3.LayoutParameters = param_fill_wrap_50;

 lbDescripcion = new TextView(context);
 lbDescripcion.SetMaxLines(2);
 lbDescripcion.LayoutParameters = param_fill_wrap_10;
 lbDescripcion.SetTextColor(Color.Black);
 lbDescripcion.Text = this.IdArticulo + " Fragance 100ml.";

 lbCantidad = new TextView(context);
 lbCantidad.SetTextColor(Color.Black);
 lbCantidad.Gravity = GravityFlags.Right;
 lbCantidad.SetPadding(0, 0, 10, 0);
 lbCantidad.LayoutParameters = param_fill_wrap_90;
 lbCantidad.Typeface = Typeface.Create("arial", TypefaceStyle.Bold);
 lbCantidad.SetTextSize(Android.Util.ComplexUnitType.Dip, 25);

 layout3.AddView(lbDescripcion);
 layout3.AddView(lbCantidad);

 imArticulo = new ImageButton(context);
 imArticulo.LayoutParameters = param_fill_fill;
 imArticulo.SetBackgroundColor(Color.Transparent);
 imArticulo.SetAdjustViewBounds(true); //Redimensionar la imagen sin perder aspect ratio.
 imArticulo.Click += new EventHandler(imArticulo_Click);

 LinearLayout layout4 = new LinearLayout(context);
 layout4.SetBackgroundColor(Color.Transparent);
 layout4.Orientation = Orientation.Horizontal;
 layout4.LayoutParameters = param_fill_fill;
 layout4.SetGravity(GravityFlags.Bottom);

 btUnidadMedida = new Button(context);
 btUnidadMedida.LayoutParameters = param_fill_wrap_80;
 btUnidadMedida.Text = "Unds";
 btUnidadMedida.Click += new EventHandler(btUnidadMedida_Click);

 lbPrecio = new TextView(context);
 lbPrecio.LayoutParameters = param_fill_wrap_20;
 lbPrecio.SetTextColor(Color.Black);

 layout4.AddView(btUnidadMedida);
 layout4.AddView(lbPrecio);

 relative1.AddView(imArticulo);
 relative1.AddView(layout3);
 relative1.AddView(layout4);


 layout2.AddView(relative1);

 llCantidad = new LinearLayout(context);
 llCantidad.SetBackgroundColor(Color.White);
 llCantidad.Orientation = Orientation.Vertical;
 llCantidad.LayoutParameters = param_wrap_wrap;
 llCantidad.Visibility = ViewStates.Gone;

 btUp = new Button(context);
 btUp.LayoutParameters = param_fill_wrap;
 btUp.Text = "+";
 btUp.SetTextColor(Color.White);
 btUp.SetTextSize(Android.Util.ComplexUnitType.Dip, 40);
 btUp.SetBackgroundColor(Color.Green);
 btUp.Gravity = GravityFlags.Center;
 btUp.Click += new EventHandler(btUp_Click);

 txCantidad = new EditText(context);
 txCantidad.LayoutParameters = param_fill_wrap;
 txCantidad.SetTextColor(Color.Black);
 txCantidad.InputType = Android.Text.InputTypes.NumberFlagDecimal;
 txCantidad.Typeface = Typeface.Create("Arial", TypefaceStyle.Bold);
 txCantidad.SetTextSize(Android.Util.ComplexUnitType.Dip, 40);
 txCantidad.Focusable = false;
 txCantidad.Gravity = GravityFlags.Center;
 txCantidad.Click += new EventHandler(txCantidad_Click);
 txCantidad.Text = "0";

 btDown = new Button(context);
 btDown.LayoutParameters = param_fill_wrap;
 btDown.Text = "-";
 btDown.SetTextColor(Color.White);
 btDown.SetTextSize(Android.Util.ComplexUnitType.Dip, 40);
 btDown.SetBackgroundColor(Color.Red);
 btDown.Gravity = GravityFlags.Center;
 btDown.Click += new EventHandler(btDown_Click);

 llCantidad.AddView(btUp);
 llCantidad.AddView(txCantidad);
 llCantidad.AddView(btDown);

 layout1.AddView(layout2);
 layout1.AddView(llCantidad);

 vwPrincipal.AddView(layout1);

 this.pView = vwPrincipal;

 //Actualiza el width / height dinamicamente al cambiar el tamaño del imagebutton
 ViewTreeObserver vto = imArticulo.ViewTreeObserver;
 vto.GlobalLayout += (sender, args) =>
 {
 if (imArticulo.Width != FinalWidth || imArticulo.Height != FinalHeight)
 {
 FinalWidth = imArticulo.Width;
 FinalHeight = imArticulo.Height;

 int BotonHeight = FinalHeight / 3;

 btUp.SetHeight(BotonHeight);
 btUp.SetWidth(BotonHeight);
 btDown.SetHeight(BotonHeight);
 btDown.SetWidth(BotonHeight);
 txCantidad.SetHeight(BotonHeight);
 txCantidad.SetWidth(BotonHeight);

 //Asigna la imagen cada vez que cambia el grid de articulos.
 LoadImage();
 }
 };
 }

 #region Asignacion de imagenes

 private void LoadImage()
 {
   MGeneral.BitmapWorkerTask task = new MGeneral.BitmapWorkerTask(imArticulo, 1, FinalWidth, FinalHeight);
   task.Execute(this.pPathImagen);
 }

    public override void OnDestroyView()
    {
      if (imArticulo != null && imArticulo.Drawable != null && ((BitmapDrawable)imArticulo.Drawable).Bitmap != null)
        ((BitmapDrawable)imArticulo.Drawable).Bitmap.Recycle();
      base.OnDestroyView();
    }





Como vereis estoy cargando las imagenes desde un hilo secundario con la clase bitmapworkedtask , destruyo los fragmentos que dejan de ser operativos por viewpager con el Destroyview() y a su vez , cada uno de los susbfragmentos que contienen este fragmento. He probado varias posibles soluciones pero siempre que tengo distribuciones como 2x2 o 3x3 me encuentro con que estoy aumentando la memoria de DALVIKCache hasta que me falla por "OUT OF MEMORY".  Consigo liberar algo de memoeria pero siempre que cambio de fragmento termino aumentando la memoria pero no lo entiendo porque deberia borrarse por completo al destroir el fragmento.


Aqui teneis parte del log final:

08-22 17:09:40.540 D/dalvikvm(14562): GC_FOR_ALLOC freed 65K, 1% free 64758K/65095K, paused 41ms 
08-22 17:09:40.540 I/dalvikvm-heap(14562): Forcing collection of SoftReferences for 675016-byte allocation 
08-22 17:09:40.600 I/dalvikvm-heap(14562): Clamp target GC heap from 65.300MB to 64.000MB 
08-22 17:09:40.600 D/dalvikvm(14562): GC_BEFORE_OOM freed 0K, 1% free 64758K/65095K, paused 45ms 
08-22 17:09:40.600 E/dalvikvm-heap(14562): Out of memory on a 675016-byte allocation.

Cualquier tipo de ayuda será bienvenida!


gracias


pd: Comentar que el codigo está en C# pero es muy parecido a java (incluyendo funciones o clases).









Gabriel Pozo

unread,
Sep 21, 2013, 9:37:21 AM9/21/13
to desarrollad...@googlegroups.com
Yo estuve renegando bastante con las imágenes y los problemas de memoria en Android, trata de leer los correos de este hilo, quizás algunas de las cosas que ahí escribimos te sirvan ;)


--
Para participar es necesario que leas detenidamente las normas del grupo: http://goo.gl/20KhL
---
Has recibido este mensaje porque estás suscrito al grupo "desarrolladores-android" de Grupos de Google.
Para anular la suscripción a este grupo y dejar de recibir sus correos electrónicos, envía un correo electrónico a desarrolladores-a...@googlegroups.com.
Para publicar una entrada en este grupo, envía un correo electrónico a desarrollad...@googlegroups.com.
Visita este grupo en http://groups.google.com/group/desarrolladores-android.
Para ver este debate en la Web, visita https://groups.google.com/d/msgid/desarrolladores-android/f89ea9ac-f00d-4db4-ad25-b6cdf68f4ad9%40googlegroups.com.
Para obtener más opciones, visita https://groups.google.com/groups/opt_out.



--
Saludos, Gabriel

http://aprendiendodeandroidymas.com/

Pedro Gomez

unread,
Sep 21, 2013, 6:12:29 PM9/21/13
to

Gracias Gabriel,

he visto tu hilo y es interesante , de hecho me fijo en cómo lo solucionastes tu pero no me queda claro la limpieza de los asyntask.

Como en tu caso, mi proyecto ha pensado en:

- Hacer destroyview de los fragmentos cuando no sean visibles, la variable uservisiblehint del viewpager.

- Cada vez que hago un destroyview de cada subfragmento , hago un recycle de la imagen que he cargado sobre el imagebutton.

- Utilizo AyncTask para cargar mis imagenes con la optimización como dice android utilizando el "inJustDecodeBounds " y "inSampleSize " .

Los caminos para optimizar y no consumir memoria creo conocerlos pero no debo de estar aplicandolos correctamente...  entiendo que debe ser un poco engorroso leer código que he puesto pero creo es fácil de entender la idea de galeria que persigo para que hagais una idea de lo que intento construir.


Tu pones esto (en tu post final):

Utilizar WeakRefences
Usar recycling
Pedir las imágenes al servidor por medio de AyncTask  
Verificar el tamaño de las imágenes, y de ser necesario re-dimensionar. (En la mayoría de los casos esto no es necesario en mi caso, porque las imágenes son nuestra)
Disminuir el tamaño de la cache que uso para guardar las imágenes.

Ademas de eso fue, detener todas las asynctask que peticionan las imágenes cuando se sale de la vista (también en el ejemplo esta, pero no lo usa) ya que no me había dado cuenta de que si el usuario entraba y salia repetidas veces y movía el mapa, se me iban sumando hilos y hasta que estos no terminan seguían corriendo todos a las vez y cada vez era más :P , naturalmente comenzaba a subir el consumo de memoria :P
Al salir de esa vista, cerrar correctamente la cache, des-referenciar de forma explicita todos los elementos de la UI, por ejemplo en un layout utilizar métodos como removeAllView() y luego dejarlo en null. Después de eso llamar de manera explicita al GC, para que limpie la memoria lo más pronto que pueda. En algunos sectores desde donde llamaba a esa Activity utilizar los flags: (Intent.FLAG_ACTIVITY_CLEAR_TOP|Intent.FLAG_ACTIVITY_NEW_TASK)  

P.D: Aunque extrañamente no me había dado cuenta lo de las asynctask :P :D me termino ayudando la herramienta Memory Analyzer, esta buena, aunque al no tener mucha experiencia con la misma, seguramente no le pude sacar todo el jugo :P


Como liberas los asyntask que dices que se quedan colgados? En mi proyecto , lo que ocurre es que si tengo una distribucion de 3x3 , cada vez que mueve una página (fragmento) se le lanzan 9 asyntask para mostrar la imagen de la forma optima y en un thead secundario. Estos hilos mueren cuando se ejecuta la acción en el hilo principal de actualizar la imagen. Y deberia morir el bitmap en memoria cuando hace el "destroyview" de cada subfragmento porque hago a la imagen un recycle.

((BitmapDrawable)imArticulo.Drawable).Bitmap.Recycle();

Yo lo que entiendo es que si tienes 3 fragmentos activos siempre sobre un viewpager, en el momento que te mueves a izq. o der. hay un fragmento que termina destruyendose , de ahí que todo lo que tiene dentro se destruye (destroyview de los subfragmentos que tiene este fragmento) pero la memoria sigue aumentandose.

saludos y gracias


Gabriel Pozo

unread,
Sep 21, 2013, 6:27:40 PM9/21/13
to desarrollad...@googlegroups.com
Hoy no tengo tiempo de ver el código, pero si puedo el lunes lo hago, en cuanto a cancelar las asynctask no debería ser complicado, en el ejemplo que ellos ofrecen tienen una función que realiza esta acción, te recomiendo mucho ver el código fuente este:

En StackOverFlow, hablan sobre el tema, estos son algunos ejemplo ;)



((BitmapDrawable)imArticulo.Drawable).Bitmap.Recycle();

Yo lo que entiendo es que si tienes 3 fragmentos activos siempre sobre un viewpager, en el momento que te mueves a izq. o der. hay un fragmento que termina destroyendo , de ahí que todo lo que tiene dentro se destruye (destroyview de los subfragmentos que tiene este fragmento) pero la memoria sigue aumentandose.

saludos y gracias


--
Para participar es necesario que leas detenidamente las normas del grupo: http://goo.gl/20KhL
---
Has recibido este mensaje porque estás suscrito al grupo "desarrolladores-android" de Grupos de Google.
Para anular la suscripción a este grupo y dejar de recibir sus correos electrónicos, envía un correo electrónico a desarrolladores-a...@googlegroups.com.
Para publicar una entrada en este grupo, envía un correo electrónico a desarrollad...@googlegroups.com.
Visita este grupo en http://groups.google.com/group/desarrolladores-android.
Para ver este debate en la Web, visita https://groups.google.com/d/msgid/desarrolladores-android/9f224990-09af-4393-97a4-d4d2e77eed42%40googlegroups.com.

Para obtener más opciones, visita https://groups.google.com/groups/opt_out.

Pedro Gomez

unread,
Sep 22, 2013, 4:28:38 AM9/22/13
to desarrollad...@googlegroups.com
Buenos dias,

efectivamente hago lo que aparece en la url  http://developer.android.com/training/displaying-bitmaps/index.html  , he probado a utilizar el asyntask.Cancel() cuando hago el destroyview del subfragmento a la vez que hago el recycle del bitmap cargado en el imagebutton pero sigo incrementando la memoria, nunca baja.

    public override void OnDestroyView()
    {
      if (imArticulo != null && imArticulo.Drawable != null && ((BitmapDrawable)imArticulo.Drawable).Bitmap != null)
      {
        ((BitmapDrawable)imArticulo.Drawable).Bitmap.Recycle();

        task.Cancel(true);
      }

      base.OnDestroyView();
    }

Mi problema es cuando paso de fragmento en fragmento por el viewpager. Cada vez que paso a un fragmento nuevo, creo los subfragmentos montandolos dinamicamente con layouts cargando la imagen con asyntas, y se ejecuta el DestroyView del fragmento que ha desaparecido de la cache del viewpager pero para la DALVIKCache no le afecta. (sigue aumentando).

saludos

jumartinx

unread,
Sep 22, 2013, 10:42:46 AM9/22/13
to desarrollad...@googlegroups.com
Yo utilice este ejemplo para cachear las imágenes, de esta forma las imágenes mas referenciadas permanecen al inicio de la Lruchce y las menos al final. Cuando necesitas añadir nuevas imágenes las menos referenciadas se eliminan y se incluyen las otras.

http://android-er.blogspot.com.es/2012/07/apply-lrucache-on-gridview.html?m=1

Pedro Gomez

unread,
Sep 22, 2013, 1:29:03 PM9/22/13
to
Este ejemplo lo tengo también medio implementado pero la LRUCache solo te sirve si te mueves sobre un fragmento que ya has cargado, si siempre te mueves a la derecha en tu viewpager nunca la utilizarias. Y mi caso , lo que no consigo entender, es por qué la DALVIKCache pasa olimpicamente de mi cuando hago el recycle del bitmap / destroy del fragmento.

saludos y muchas gracias por responder.

Gabriel Pozo

unread,
Sep 23, 2013, 9:13:38 AM9/23/13
to desarrollad...@googlegroups.com
Recién veo el código un poco :D interesante como queda con C# y cargando todo el layout por código :D
A lo mejor algo así te ayuda, ahora que vi el error del logcat:

Estás trabajando con Xamarin? 
Ah otro cosa, podrías poner un log un poco más grande, para ver lo que pasa antes de ese error?
Los problemas de memoria son medio molestos :P  No tenes alguna herramienta similar a esta? http://www.eclipse.org/mat/




El 22 de septiembre de 2013 14:28, Pedro Gomez <pocke...@gmail.com> escribió:
Este ejemplo lo tengo también medio implementado pero la LRUCache solo te sirve si te mueves sobre un fragmento que ya has cargado, si siempre te mueves a la izq. en tu viewpager nunca la utilizarias. Y mi caso , lo que no consigo entender, es por qué la DALVIKCache pasa olimpicamente de mi cuando hago el recycle del bitmap / destroy del fragmento.


saludos y muchas gracias por responder.

El domingo, 22 de septiembre de 2013 16:42:46 UTC+2, jumartinx escribió:
Yo utilice este ejemplo para cachear las imágenes, de esta forma las imágenes mas referenciadas permanecen al inicio de la Lruchce y las menos al final. Cuando necesitas añadir nuevas imágenes las menos referenciadas se eliminan y se incluyen las otras.

http://android-er.blogspot.com.es/2012/07/apply-lrucache-on-gridview.html?m=1

--
Para participar es necesario que leas detenidamente las normas del grupo: http://goo.gl/20KhL
---
Has recibido este mensaje porque estás suscrito al grupo "desarrolladores-android" de Grupos de Google.
Para anular la suscripción a este grupo y dejar de recibir sus correos electrónicos, envía un correo electrónico a desarrolladores-a...@googlegroups.com.
Para publicar una entrada en este grupo, envía un correo electrónico a desarrollad...@googlegroups.com.
Visita este grupo en http://groups.google.com/group/desarrolladores-android.
Para ver este debate en la Web, visita https://groups.google.com/d/msgid/desarrolladores-android/680b9cd1-87e7-4935-ba08-ddad41d1bea6%40googlegroups.com.

Para obtener más opciones, visita https://groups.google.com/groups/opt_out.

Pedro Gomez

unread,
Sep 23, 2013, 10:16:45 AM9/23/13
to
Efectivamente, estoy trabajando con xamarin. Adjunto un logcat con un test (bastante cañero) que acabo de hacer. En él lo que hago es pasar los fragmentos muy rápidamente en una distribucion (3x3 , la más costosa). Como pone en el logcat, se queja de que hago demasiadas cosas en el hilo principal , entiendo que esto lo dice porque al crear un fragmento debo crear 9 subfragmentos dinámicamente (esto tiene que costar), este código no puedo meterlo en un thead secundario.

En el logcat también podemos fijarnos que cada ciertas lineas el GC se ejecuta de forma automática y libera algo de memoria, aún así no es suficiente porque sigue subiendo. Las vistas dinamicas no puede ser que gasten tanta memoria y más sabiendo que se hace un OnDestroy de cada fragmento que no está en la cache del viewpager.

Loaded assembly: MonoDroidConstructors [External]
09-23 15:43:27.562 D/dalvikvm(16847): GC_CONCURRENT freed 106K, 3% free 7940K/8112K, paused 3ms+1ms, total 22ms
09-23 15:43:27.562 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 6ms
Thread started: <Thread Pool> #2
Thread started: <Thread Pool> #3
Loaded assembly: System.Data.dll [External]
09-23 15:43:27.702 D/libEGL  (16847): loaded /system/lib/egl/libEGL_tegra.so
09-23 15:43:27.722 D/libEGL  (16847): loaded /system/lib/egl/libGLESv1_CM_tegra.so
09-23 15:43:27.732 D/libEGL  (16847): loaded /system/lib/egl/libGLESv2_tegra.so
09-23 15:43:27.752 D/OpenGLRenderer(16847): Enabling debug mode 0
Loaded assembly: System.dll [External]
Loaded assembly: System.ComponentModel.DataAnnotations.dll [External]
Loaded assembly: System.Xml.dll [External]
Loaded assembly: Mono.Data.Sqlite.dll [External]
Loaded assembly: System.Transactions.dll [External]
09-23 15:43:29.732 D/dalvikvm(16847): GC_CONCURRENT freed 339K, 5% free 8030K/8436K, paused 3ms+2ms, total 18ms
09-23 15:45:44.522 D/dalvikvm(16847): GC_CONCURRENT freed 236K, 4% free 8266K/8564K, paused 2ms+6ms, total 31ms
09-23 15:45:44.662 D/dalvikvm(16847): GC_CONCURRENT freed 200K, 3% free 8511K/8772K, paused 2ms+8ms, total 30ms
09-23 15:45:45.312 D/dalvikvm(16847): GC_CONCURRENT freed 205K, 3% free 8722K/8988K, paused 3ms+8ms, total 36ms
09-23 15:45:53.702 D/dalvikvm(16847): GC_CONCURRENT freed 120K, 2% free 9079K/9260K, paused 4ms+4ms, total 41ms
09-23 15:45:55.312 D/dalvikvm(16847): GC_CONCURRENT freed 134K, 3% free 9338K/9532K, paused 4ms+4ms, total 49ms
09-23 15:45:55.632 D/dalvikvm(16847): GC_EXPLICIT freed 448K, 6% free 9026K/9560K, paused 2ms+3ms, total 39ms
Thread started:  #4
09-23 15:45:56.392 D/dalvikvm(16847): GC_FOR_ALLOC freed 168K, 5% free 9131K/9560K, paused 20ms, total 20ms
09-23 15:45:56.392 I/dalvikvm-heap(16847): Grow heap (frag case) to 9.230MB for 267216-byte allocation
09-23 15:45:56.412 D/dalvikvm(16847): GC_FOR_ALLOC freed 2K, 5% free 9390K/9824K, paused 19ms, total 19ms
Thread started:  #5
09-23 15:45:56.552 D/dalvikvm(16847): GC_FOR_ALLOC freed 77K, 5% free 9428K/9824K, paused 24ms, total 24ms
09-23 15:45:58.692 D/dalvikvm(16847): GC_CONCURRENT freed 107K, 3% free 9844K/10088K, paused 2ms+2ms, total 34ms
Thread started:  #6
Thread started:  #7
Thread started:  #8
09-23 15:45:59.372 D/dalvikvm(16847): GC_CONCURRENT freed 338K, 4% free 10276K/10676K, paused 2ms+3ms, total 31ms
09-23 15:45:59.372 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 17ms
09-23 15:45:59.372 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 18ms
09-23 15:45:59.372 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 15ms
09-23 15:45:59.602 D/dalvikvm(16847): GC_CONCURRENT freed 363K, 4% free 10809K/11232K, paused 3ms+4ms, total 37ms
09-23 15:45:59.602 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 30ms
09-23 15:45:59.702 D/dalvikvm(16847): GC_CONCURRENT freed 463K, 5% free 11433K/11956K, paused 3ms+4ms, total 36ms
09-23 15:45:59.702 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 24ms
Thread started: <Thread Pool> #9
09-23 15:46:05.492 D/dalvikvm(16847): GC_CONCURRENT freed 560K, 5% free 12047K/12672K, paused 4ms+6ms, total 42ms
Thread started: <Thread Pool> #10
09-23 15:46:06.492 D/dalvikvm(16847): GC_CONCURRENT freed 593K, 5% free 12955K/13612K, paused 3ms+4ms, total 39ms
09-23 15:46:06.492 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 19ms
09-23 15:46:06.892 D/dalvikvm(16847): GC_CONCURRENT freed 743K, 6% free 13909K/14732K, paused 2ms+3ms, total 35ms
09-23 15:46:06.982 D/dalvikvm(16847): GC_EXPLICIT freed 1944K, 19% free 11991K/14732K, paused 2ms+5ms, total 39ms
09-23 15:46:07.292 D/dalvikvm(16847): GC_CONCURRENT freed 731K, 14% free 12771K/14732K, paused 3ms+4ms, total 54ms
09-23 15:46:07.292 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 34ms
09-23 15:46:07.412 D/dalvikvm(16847): GC_FOR_ALLOC freed 361K, 10% free 13404K/14732K, paused 29ms, total 30ms
09-23 15:46:08.412 D/dalvikvm(16847): GC_CONCURRENT freed 827K, 6% free 14538K/15424K, paused 2ms+5ms, total 46ms
09-23 15:46:08.412 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 23ms
09-23 15:46:08.412 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 16ms
09-23 15:46:08.412 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 17ms
09-23 15:46:08.622 I/dalvikvm(16847): Jit: resizing JitTable from 4096 to 8192
09-23 15:46:09.112 D/dalvikvm(16847): GC_CONCURRENT freed 1066K, 7% free 15808K/16936K, paused 4ms+5ms, total 50ms
09-23 15:46:09.112 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 38ms
09-23 15:46:09.112 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 18ms
09-23 15:46:09.112 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 15ms
09-23 15:46:10.052 D/dalvikvm(16847): GC_CONCURRENT freed 1152K, 7% free 17413K/18628K, paused 2ms+5ms, total 45ms
09-23 15:46:10.052 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 35ms
09-23 15:46:10.062 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 29ms
09-23 15:46:12.082 D/dalvikvm(16847): GC_CONCURRENT freed 1443K, 8% free 19256K/20756K, paused 3ms+6ms, total 65ms
09-23 15:46:12.082 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 45ms
09-23 15:46:13.672 D/dalvikvm(16847): GC_CONCURRENT freed 1650K, 8% free 21512K/23224K, paused 4ms+6ms, total 60ms
09-23 15:46:13.672 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 30ms
09-23 15:46:13.672 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 26ms
09-23 15:46:13.682 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 34ms
09-23 15:46:15.202 D/dalvikvm(16847): GC_EXPLICIT freed 6689K, 31% free 16629K/23896K, paused 2ms+9ms, total 60ms
09-23 15:46:15.372 I/Choreographer(16847): Skipped 30 frames!  The application may be doing too much work on its main thread.
09-23 15:46:16.322 D/dalvikvm(16847): GC_CONCURRENT freed 1790K, 26% free 17802K/23896K, paused 2ms+6ms, total 69ms
09-23 15:46:17.262 D/dalvikvm(16847): null clazz in OP_INSTANCE_OF, single-stepping
09-23 15:46:18.152 D/dalvikvm(16847): GC_CONCURRENT freed 1423K, 18% free 19801K/23896K, paused 2ms+6ms, total 60ms
09-23 15:46:18.152 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 14ms
09-23 15:46:18.152 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 11ms
09-23 15:46:18.152 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 14ms
09-23 15:46:20.262 D/dalvikvm(16847): GC_FOR_ALLOC freed 1358K, 10% free 21669K/23896K, paused 51ms, total 52ms
09-23 15:46:22.142 D/dalvikvm(16847): GC_CONCURRENT freed 1862K, 8% free 24522K/26444K, paused 4ms+8ms, total 83ms
09-23 15:46:22.142 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 22ms
09-23 15:46:22.142 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 13ms
09-23 15:46:24.152 D/dalvikvm(16847): GC_EXPLICIT freed 8905K, 31% free 20714K/29684K, paused 2ms+13ms, total 75ms
09-23 15:46:25.732 D/dalvikvm(16847): GC_CONCURRENT freed 2403K, 24% free 22703K/29684K, paused 5ms+6ms, total 71ms
09-23 15:46:25.732 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 43ms
09-23 15:46:25.732 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 48ms
09-23 15:46:25.732 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 49ms
09-23 15:46:27.332 D/dalvikvm(16847): GC_CONCURRENT freed 2126K, 14% free 25570K/29684K, paused 3ms+8ms, total 78ms
09-23 15:46:29.912 D/dalvikvm(16847): GC_CONCURRENT freed 2577K, 9% free 28898K/31540K, paused 4ms+10ms, total 97ms
09-23 15:46:32.122 D/dalvikvm(16847): GC_EXPLICIT freed 8174K, 26% free 24718K/33052K, paused 3ms+13ms, total 86ms
09-23 15:46:34.082 D/dalvikvm(16847): GC_CONCURRENT freed 2942K, 18% free 27422K/33052K, paused 4ms+9ms, total 89ms
09-23 15:46:37.292 D/dalvikvm(16847): GC_CONCURRENT freed 2812K, 9% free 31245K/34108K, paused 4ms+11ms, total 110ms
Thread started: <Thread Pool> #11
09-23 15:46:40.022 D/dalvikvm(16847): GC_EXPLICIT freed 9145K, 25% free 28878K/38088K, paused 3ms+16ms, total 105ms
09-23 15:46:40.052 I/Choreographer(16847): Skipped 31 frames!  The application may be doing too much work on its main thread.
09-23 15:46:45.202 D/dalvikvm(16847): GC_CONCURRENT freed 3508K, 15% free 32524K/38056K, paused 11ms+11ms, total 141ms
09-23 15:46:45.202 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 61ms
09-23 15:46:49.752 D/dalvikvm(16847): GC_EXPLICIT freed 7381K, 20% free 31101K/38548K, paused 4ms+17ms, total 111ms
09-23 15:46:49.992 I/Choreographer(16847): Skipped 32 frames!  The application may be doing too much work on its main thread.
09-23 15:46:56.232 D/dalvikvm(16847): GC_CONCURRENT freed 3841K, 10% free 35173K/38992K, paused 7ms+14ms, total 156ms
09-23 15:46:56.232 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 20ms
09-23 15:47:01.132 D/dalvikvm(16847): GC_CONCURRENT freed 3596K, 9% free 39723K/43380K, paused 4ms+17ms, total 137ms
09-23 15:47:03.112 D/dalvikvm(16847): GC_EXPLICIT freed 5540K, 21% free 34597K/43464K, paused 3ms+13ms, total 112ms
09-23 15:47:11.702 D/dalvikvm(16847): GC_CONCURRENT freed 3809K, 11% free 38980K/43460K, paused 4ms+12ms, total 141ms
09-23 15:47:11.702 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 114ms
09-23 15:47:11.702 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 45ms
09-23 15:47:11.702 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 49ms
09-23 15:47:11.702 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 49ms
09-23 15:47:18.682 D/dalvikvm(16847): GC_CONCURRENT freed 3629K, 8% free 43545K/47236K, paused 5ms+18ms, total 150ms
09-23 15:47:18.682 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 128ms
09-23 15:47:18.682 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 106ms
09-23 15:47:18.682 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 103ms
09-23 15:47:19.832 D/dalvikvm(16847): GC_EXPLICIT freed 6127K, 20% free 38331K/47572K, paused 4ms+14ms, total 125ms
09-23 15:47:25.292 D/dalvikvm(16847): GC_CONCURRENT freed 3915K, 11% free 42607K/47568K, paused 5ms+14ms, total 143ms
09-23 15:47:25.292 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 86ms
09-23 15:47:25.292 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 85ms
09-23 15:47:25.292 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 87ms
09-23 15:47:28.452 D/dalvikvm(16847): GC_CONCURRENT freed 3317K, 7% free 47485K/50864K, paused 4ms+16ms, total 147ms
09-23 15:47:28.452 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 93ms
09-23 15:47:28.462 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 99ms
09-23 15:47:28.462 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 89ms
09-23 15:47:28.462 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 89ms
09-23 15:47:29.612 D/dalvikvm(16847): GC_EXPLICIT freed 7327K, 19% free 41683K/51264K, paused 4ms+19ms, total 136ms
09-23 15:47:30.202 I/Choreographer(16847): Skipped 56 frames!  The application may be doing too much work on its main thread.
09-23 15:47:32.642 D/dalvikvm(16847): GC_CONCURRENT freed 3809K, 11% free 46065K/51264K, paused 4ms+13ms, total 134ms
09-23 15:47:32.642 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 77ms
09-23 15:47:32.642 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 105ms
09-23 15:47:32.642 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 79ms
09-23 15:47:49.392 D/dalvikvm(16847): GC_EXPLICIT freed 9185K, 18% free 43602K/52852K, paused 4ms+21ms, total 160ms
09-23 15:47:56.042 D/dalvikvm(16847): GC_CONCURRENT freed 4121K, 10% free 47672K/52852K, paused 5ms+17ms, total 152ms
09-23 15:47:56.052 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 123ms
09-23 15:47:56.052 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 63ms
09-23 15:48:01.962 D/dalvikvm(16847): GC_CONCURRENT freed 3523K, 7% free 52342K/55928K, paused 6ms+18ms, total 155ms
09-23 15:48:01.962 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 138ms
09-23 15:48:01.972 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 144ms
09-23 15:48:02.542 D/dalvikvm(16847): GC_EXPLICIT freed 7058K, 18% free 46985K/56616K, paused 5ms+15ms, total 151ms
09-23 15:48:02.582 I/Choreographer(16847): Skipped 34 frames!  The application may be doing too much work on its main thread.
09-23 15:48:10.192 D/dalvikvm(16847): GC_CONCURRENT freed 3953K, 10% free 51223K/56604K, paused 5ms+19ms, total 202ms
09-23 15:48:10.192 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 54ms
09-23 15:48:10.192 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 55ms
09-23 15:48:15.222 D/dalvikvm(16847): GC_CONCURRENT freed 3443K, 6% free 55975K/59480K, paused 5ms+19ms, total 168ms
09-23 15:48:15.222 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 150ms
09-23 15:48:15.232 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 126ms
09-23 15:48:15.232 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 126ms
09-23 15:48:15.742 D/dalvikvm(16847): GC_EXPLICIT freed 7458K, 17% free 50382K/60380K, paused 5ms+21ms, total 164ms
09-23 15:48:15.792 I/Choreographer(16847): Skipped 32 frames!  The application may be doing too much work on its main thread.
Thread started: <Thread Pool> #12
Thread finished: <Thread Pool> #10
The thread 0xa has exited with code 0 (0x0).
Thread finished: <Thread Pool> #10
09-23 15:48:24.802 D/dalvikvm(16847): GC_CONCURRENT freed 3796K, 10% free 54778K/60348K, paused 7ms+18ms, total 168ms
09-23 15:48:24.802 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 145ms
09-23 15:48:24.802 D/dalvikvm(16847): WAIT_FOR_CONCURRENT_GC blocked 145ms
09-23 15:48:24.872 I/Choreographer(16847): Skipped 37 frames!  The application may be doing too much work on its main thread.
09-23 15:48:28.352 D/dalvikvm(16847): GC_EXPLICIT freed 7440K, 13% free 53716K/61248K, paused 5ms+25ms, total 181ms
09-23 15:48:32.662 I/dalvikvm-heap(16847): Clamp target GC heap from 64.290MB to 64.000MB
09-23 15:48:32.662 D/dalvikvm(16847): GC_CONCURRENT freed 4274K, 8% free 57580K/61916K, paused 6ms+23ms, total 215ms
09-23 15:48:36.442 D/dalvikvm(16847): GC_EXPLICIT freed 8005K, 13% free 56955K/65024K, paused 5ms+27ms, total 195ms
09-23 15:48:36.552 I/Choreographer(16847): Skipped 40 frames!  The application may be doing too much work on its main thread.
09-23 15:48:44.872 I/dalvikvm-heap(16847): Clamp target GC heap from 67.194MB to 64.000MB
09-23 15:48:44.872 D/dalvikvm(16847): GC_FOR_ALLOC freed 3983K, 8% free 60554K/65168K, paused 163ms, total 163ms
09-23 15:48:45.172 I/dalvikvm-heap(16847): Clamp target GC heap from 67.529MB to 64.000MB
09-23 15:48:45.172 D/dalvikvm(16847): GC_FOR_ALLOC freed 460K, 8% free 60897K/65508K, paused 153ms, total 153ms
09-23 15:48:45.172 I/dalvikvm-heap(16847): Forcing collection of SoftReferences for 66816-byte allocation
09-23 15:48:45.332 I/dalvikvm-heap(16847): Clamp target GC heap from 67.529MB to 64.000MB
09-23 15:48:45.332 D/dalvikvm(16847): GC_BEFORE_OOM freed 0K, 8% free 60897K/65508K, paused 165ms, total 165ms
09-23 15:48:45.332 E/dalvikvm-heap(16847): Out of memory on a 66816-byte allocation.
09-23 15:48:45.332 I/dalvikvm(16847): "AsyncTask #5" prio=5 tid=21 RUNNABLE
09-23 15:48:45.332 I/dalvikvm(16847):   | group="main" sCount=0 dsCount=0 obj=0x42273868 self=0x6e753200
09-23 15:48:45.332 I/dalvikvm(16847):   | sysTid=16933 nice=10 sched=0/0 cgrp=apps/bg_non_interactive handle=1849144928
09-23 15:48:45.332 I/dalvikvm(16847):   | state=R schedstat=( 2135540000 3022069000 5011 ) utm=189 stm=24 core=2
09-23 15:48:45.332 I/dalvikvm(16847):   at android.graphics.BitmapFactory.nativeDecodeStream(Native Method)
09-23 15:48:45.332 I/dalvikvm(16847):   at android.graphics.BitmapFactory.decodeStream(BitmapFactory.java:530)
09-23 15:48:45.332 I/dalvikvm(16847):   at android.graphics.BitmapFactory.decodeFile(BitmapFactory.java:303)
09-23 15:48:45.332 I/dalvikvm(16847):   at emali.monodroid.MGeneral_BitmapWorkerTask.n_doInBackground(Native Method)
09-23 15:48:45.332 I/dalvikvm(16847):   at emali.monodroid.MGeneral_BitmapWorkerTask.doInBackground(MGeneral_BitmapWorkerTask.java:36)
09-23 15:48:45.342 I/dalvikvm(16847):   at android.os.AsyncTask$2.call(AsyncTask.java:287)
09-23 15:48:45.342 I/dalvikvm(16847):   at java.util.concurrent.FutureTask.run(FutureTask.java:234)
09-23 15:48:45.342 I/dalvikvm(16847):   at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:230)
09-23 15:48:45.342 I/dalvikvm(16847):   at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1080)
09-23 15:48:45.342 I/dalvikvm(16847):   at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:573)
09-23 15:48:45.342 I/dalvikvm(16847):   at java.lang.Thread.run(Thread.java:841)
09-23 15:48:45.342 I/dalvikvm(16847):
09-23 15:48:45.342 D/skia    (16847): --- decoder->decode returned false
09-23 15:48:45.352 D/DecodeBitmapFromFile: (16847): Exception of type 'Java.Lang.OutOfMemoryError' was thrown.
09-23 15:48:45.572 I/dalvikvm-heap(16847): Clamp target GC heap from 67.584MB to 64.000MB
09-23 15:48:45.572 D/dalvikvm(16847): GC_FOR_ALLOC freed 96K, 7% free 60955K/65508K, paused 151ms, total 151ms
09-23 15:48:45.572 I/dalvikvm-heap(16847): Forcing collection of SoftReferences for 66816-byte allocation
09-23 15:48:45.742 I/dalvikvm-heap(16847): Clamp target GC heap from 67.584MB to 64.000MB
09-23 15:48:45.742 D/dalvikvm(16847): GC_BEFORE_OOM freed <1K, 7% free 60954K/65508K, paused 166ms, total 166ms
09-23 15:48:45.742 E/dalvikvm-heap(16847): Out of memory on a 66816-byte allocation.
09-23 15:48:45.742 I/dalvikvm(16847): "AsyncTask #4" prio=5 tid=20 RUNNABLE
09-23 15:48:45.742 I/dalvikvm(16847):   | group="main" sCount=0 dsCount=0 obj=0x4204f9d0 self=0x6e747518
09-23 15:48:45.742 I/dalvikvm(16847):   | sysTid=16930 nice=10 sched=0/0 cgrp=apps/bg_non_interactive handle=1853127016
09-23 15:48:45.742 I/dalvikvm(16847):   | state=R schedstat=( 2276366000 2909516000 4847 ) utm=208 stm=19 core=2
09-23 15:48:45.742 I/dalvikvm(16847):   at android.graphics.BitmapFactory.nativeDecodeStream(Native Method)
09-23 15:48:45.742 I/dalvikvm(16847):   at android.graphics.BitmapFactory.decodeStream(BitmapFactory.java:530)
09-23 15:48:45.742 I/dalvikvm(16847):   at android.graphics.BitmapFactory.decodeFile(BitmapFactory.java:303)
09-23 15:48:45.742 I/dalvikvm(16847):   at emali.monodroid.MGeneral_BitmapWorkerTask.n_doInBackground(Native Method)
09-23 15:48:45.742 I/dalvikvm(16847):   at emali.monodroid.MGeneral_BitmapWorkerTask.doInBackground(MGeneral_BitmapWorkerTask.java:36)
09-23 15:48:45.742 I/dalvikvm(16847):   at android.os.AsyncTask$2.call(AsyncTask.java:287)
09-23 15:48:45.742 I/dalvikvm(16847):   at java.util.concurrent.FutureTask.run(FutureTask.java:234)
09-23 15:48:45.742 I/dalvikvm(16847):   at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:230)
09-23 15:48:45.742 I/dalvikvm(16847):   at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1080)
09-23 15:48:45.742 I/dalvikvm(16847):   at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:573)
09-23 15:48:45.742 I/dalvikvm(16847):   at java.lang.Thread.run(Thread.java:841)
09-23 15:48:45.742 I/dalvikvm(16847):
09-23 15:48:45.742 D/skia    (16847): --- decoder->decode returned false
09-23 15:48:45.752 D/DecodeBitmapFromFile: (16847): Exception of type 'Java.Lang.OutOfMemoryError' was thrown.
09-23 15:48:45.852 I/Choreographer(16847): Skipped 70 frames!  The application may be doing too much work on its main thread.
09-23 15:48:49.152 I/dalvikvm-heap(16847): Clamp target GC heap from 67.708MB to 64.000MB
09-23 15:48:49.152 D/dalvikvm(16847): GC_FOR_ALLOC freed 142K, 7% free 61080K/65508K, paused 150ms, total 150ms
09-23 15:48:49.152 I/dalvikvm-heap(16847): Forcing collection of SoftReferences for 66816-byte allocation
09-23 15:48:49.322 I/dalvikvm-heap(16847): Clamp target GC heap from 67.708MB to 64.000MB
09-23 15:48:49.322 D/dalvikvm(16847): GC_BEFORE_OOM freed <1K, 7% free 61080K/65508K, paused 164ms, total 164ms
09-23 15:48:49.322 E/dalvikvm-heap(16847): Out of memory on a 66816-byte allocation.
09-23 15:48:49.322 I/dalvikvm(16847): "AsyncTask #2" prio=5 tid=17 RUNNABLE
09-23 15:48:49.322 I/dalvikvm(16847):   | group="main" sCount=0 dsCount=0 obj=0x42121dd0 self=0x6e0471f8
09-23 15:48:49.322 I/dalvikvm(16847):   | sysTid=16921 nice=10 sched=0/0 cgrp=apps/bg_non_interactive handle=1845786184
09-23 15:48:49.322 I/dalvikvm(16847):   | state=R schedstat=( 2174290000 3316622000 4915 ) utm=190 stm=27 core=3
09-23 15:48:49.322 I/dalvikvm(16847):   at android.graphics.BitmapFactory.nativeDecodeStream(Native Method)
09-23 15:48:49.322 I/dalvikvm(16847):   at android.graphics.BitmapFactory.decodeStream(BitmapFactory.java:530)
09-23 15:48:49.322 I/dalvikvm(16847):   at android.graphics.BitmapFactory.decodeFile(BitmapFactory.java:303)
09-23 15:48:49.322 I/dalvikvm(16847):   at emali.monodroid.MGeneral_BitmapWorkerTask.n_doInBackground(Native Method)
09-23 15:48:49.322 I/dalvikvm(16847):   at emali.monodroid.MGeneral_BitmapWorkerTask.doInBackground(MGeneral_BitmapWorkerTask.java:36)
09-23 15:48:49.322 I/dalvikvm(16847):   at android.os.AsyncTask$2.call(AsyncTask.java:287)
09-23 15:48:49.322 I/dalvikvm(16847):   at java.util.concurrent.FutureTask.run(FutureTask.java:234)
09-23 15:48:49.322 I/dalvikvm(16847):   at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:230)
09-23 15:48:49.322 I/dalvikvm(16847):   at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1080)
09-23 15:48:49.322 I/dalvikvm(16847):   at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:573)
09-23 15:48:49.322 I/dalvikvm(16847):   at java.lang.Thread.run(Thread.java:841)
09-23 15:48:49.322 I/dalvikvm(16847):
09-23 15:48:49.322 D/skia    (16847): --- decoder->decode returned false
09-23 15:48:49.322 D/DecodeBitmapFromFile: (16847): Exception of type 'Java.Lang.OutOfMemoryError' was thrown.
09-23 15:48:49.512 I/dalvikvm-heap(16847): Clamp target GC heap from 67.717MB to 64.000MB
09-23 15:48:49.512 D/dalvikvm(16847): GC_FOR_ALLOC freed 93K, 7% free 61090K/65508K, paused 151ms, total 151ms
09-23 15:48:49.512 I/dalvikvm-heap(16847): Forcing collection of SoftReferences for 66816-byte allocation
09-23 15:48:49.672 I/dalvikvm-heap(16847): Clamp target GC heap from 67.717MB to 64.000MB
09-23 15:48:49.672 D/dalvikvm(16847): GC_BEFORE_OOM freed <1K, 7% free 61090K/65508K, paused 164ms, total 164ms
09-23 15:48:49.682 E/dalvikvm-heap(16847): Out of memory on a 66816-byte allocation.
09-23 15:48:49.682 I/dalvikvm(16847): "AsyncTask #1" prio=5 tid=16 RUNNABLE
09-23 15:48:49.682 I/dalvikvm(16847):   | group="main" sCount=0 dsCount=0 obj=0x42120c60 self=0x662bc4a0
09-23 15:48:49.682 I/dalvikvm(16847):   | sysTid=16920 nice=10 sched=0/0 cgrp=apps/bg_non_interactive handle=1702543488
09-23 15:48:49.682 I/dalvikvm(16847):   | state=R schedstat=( 2784819000 5285456000 6186 ) utm=249 stm=29 core=3
09-23 15:48:49.682 I/dalvikvm(16847):   at android.graphics.BitmapFactory.nativeDecodeStream(Native Method)
09-23 15:48:49.682 I/dalvikvm(16847):   at android.graphics.BitmapFactory.decodeStream(BitmapFactory.java:530)
09-23 15:48:49.682 I/dalvikvm(16847):   at android.graphics.BitmapFactory.decodeFile(BitmapFactory.java:303)
09-23 15:48:49.682 I/dalvikvm(16847):   at emali.monodroid.MGeneral_BitmapWorkerTask.n_doInBackground(Native Method)
09-23 15:48:49.682 I/dalvikvm(16847):   at emali.monodroid.MGeneral_BitmapWorkerTask.doInBackground(MGeneral_BitmapWorkerTask.java:36)
09-23 15:48:49.682 I/dalvikvm(16847):   at android.os.AsyncTask$2.call(AsyncTask.java:287)
09-23 15:48:49.682 I/dalvikvm(16847):   at java.util.concurrent.FutureTask.run(FutureTask.java:234)
09-23 15:48:49.682 I/dalvikvm(16847):   at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:230)
09-23 15:48:49.682 I/dalvikvm(16847):   at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1080)
09-23 15:48:49.682 I/dalvikvm(16847):   at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:573)
09-23 15:48:49.682 I/dalvikvm(16847):   at java.lang.Thread.run(Thread.java:841)
09-23 15:48:49.682 I/dalvikvm(16847):
09-23 15:48:49.682 D/skia    (16847): --- decoder->decode returned false
09-23 15:48:49.682 D/DecodeBitmapFromFile: (16847): Exception of type 'Java.Lang.OutOfMemoryError' was thrown.
09-23 15:48:49.872 I/dalvikvm-heap(16847): Clamp target GC heap from 67.746MB to 64.000MB
09-23 15:48:49.872 D/dalvikvm(16847): GC_FOR_ALLOC freed 83K, 7% free 61119K/65508K, paused 152ms, total 152ms
09-23 15:48:49.872 I/dalvikvm-heap(16847): Forcing collection of SoftReferences for 66816-byte allocation
09-23 15:48:50.032 I/dalvikvm-heap(16847): Clamp target GC heap from 67.746MB to 64.000MB
09-23 15:48:50.032 D/dalvikvm(16847): GC_BEFORE_OOM freed 0K, 7% free 61119K/65508K, paused 164ms, total 164ms
09-23 15:48:50.032 E/dalvikvm-heap(16847): Out of memory on a 66816-byte allocation.
09-23 15:48:50.032 I/dalvikvm(16847): "AsyncTask #3" prio=5 tid=19 RUNNABLE
09-23 15:48:50.032 I/dalvikvm(16847):   | group="main" sCount=0 dsCount=0 obj=0x4202f6a8 self=0x6e58a5c0
09-23 15:48:50.032 I/dalvikvm(16847):   | sysTid=16929 nice=10 sched=0/0 cgrp=apps/bg_non_interactive handle=1851282104
09-23 15:48:50.032 I/dalvikvm(16847):   | state=R schedstat=( 2765990000 5415255000 6740 ) utm=251 stm=25 core=3
09-23 15:48:50.032 I/dalvikvm(16847):   at android.graphics.BitmapFactory.nativeDecodeStream(Native Method)
09-23 15:48:50.032 I/dalvikvm(16847):   at android.graphics.BitmapFactory.decodeStream(BitmapFactory.java:530)
09-23 15:48:50.032 I/dalvikvm(16847):   at android.graphics.BitmapFactory.decodeFile(BitmapFactory.java:303)
09-23 15:48:50.032 I/dalvikvm(16847):   at emali.monodroid.MGeneral_BitmapWorkerTask.n_doInBackground(Native Method)
09-23 15:48:50.032 I/dalvikvm(16847):   at emali.monodroid.MGeneral_BitmapWorkerTask.doInBackground(MGeneral_BitmapWorkerTask.java:36)
09-23 15:48:50.032 I/dalvikvm(16847):   at android.os.AsyncTask$2.call(AsyncTask.java:287)
09-23 15:48:50.032 I/dalvikvm(16847):   at java.util.concurrent.FutureTask.run(FutureTask.java:234)
09-23 15:48:50.032 I/dalvikvm(16847):   at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:230)
09-23 15:48:50.032 I/dalvikvm(16847):   at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1080)
09-23 15:48:50.032 I/dalvikvm(16847):   at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:573)
09-23 15:48:50.032 I/dalvikvm(16847):   at java.lang.Thread.run(Thread.java:841)
09-23 15:48:50.032 I/dalvikvm(16847):
09-23 15:48:50.042 D/skia    (16847): --- decoder->decode returned false
09-23 15:48:50.052 D/DecodeBitmapFromFile: (16847): Exception of type 'Java.Lang.OutOfMemoryError' was thrown.
09-23 15:48:50.252 I/dalvikvm-heap(16847): Clamp target GC heap from 67.786MB to 64.000MB
09-23 15:48:50.252 D/dalvikvm(16847): GC_FOR_ALLOC freed 82K, 7% free 61160K/65508K, paused 154ms, total 154ms
09-23 15:48:50.252 I/dalvikvm-heap(16847): Forcing collection of SoftReferences for 66816-byte allocation
09-23 15:48:50.422 I/dalvikvm-heap(16847): Clamp target GC heap from 67.786MB to 64.000MB
09-23 15:48:50.422 D/dalvikvm(16847): GC_BEFORE_OOM freed <1K, 7% free 61160K/65508K, paused 167ms, total 167ms
09-23 15:48:50.422 E/dalvikvm-heap(16847): Out of memory on a 66816-byte allocation.
09-23 15:48:50.422 I/dalvikvm(16847): "AsyncTask #5" prio=5 tid=21 RUNNABLE
09-23 15:48:50.422 I/dalvikvm(16847):   | group="main" sCount=0 dsCount=0 obj=0x42273868 self=0x6e753200
09-23 15:48:50.422 I/dalvikvm(16847):   | sysTid=16933 nice=10 sched=0/0 cgrp=apps/bg_non_interactive handle=1849144928
09-23 15:48:50.422 I/dalvikvm(16847):   | state=R schedstat=( 2462827000 3074007000 5101 ) utm=222 stm=24 core=0
09-23 15:48:50.422 I/dalvikvm(16847):   at android.graphics.BitmapFactory.nativeDecodeStream(Native Method)
09-23 15:48:50.422 I/dalvikvm(16847):   at android.graphics.BitmapFactory.decodeStream(BitmapFactory.java:530)
09-23 15:48:50.422 I/dalvikvm(16847):   at android.graphics.BitmapFactory.decodeFile(BitmapFactory.java:303)
09-23 15:48:50.422 I/dalvikvm(16847):   at emali.monodroid.MGeneral_BitmapWorkerTask.n_doInBackground(Native Method)
09-23 15:48:50.422 I/dalvikvm(16847):   at emali.monodroid.MGeneral_BitmapWorkerTask.doInBackground(MGeneral_BitmapWorkerTask.java:36)
09-23 15:48:50.422 I/dalvikvm(16847):   at android.os.AsyncTask$2.call(AsyncTask.java:287)
09-23 15:48:50.422 I/dalvikvm(16847):   at java.util.concurrent.FutureTask.run(FutureTask.java:234)
09-23 15:48:50.422 I/dalvikvm(16847):   at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:230)
09-23 15:48:50.422 I/dalvikvm(16847):   at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1080)
09-23 15:48:50.422 I/dalvikvm(16847):   at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:573)
09-23 15:48:50.422 I/dalvikvm(16847):   at java.lang.Thread.run(Thread.java:841)
09-23 15:48:50.422 I/dalvikvm(16847):
09-23 15:48:50.422 D/skia    (16847): --- decoder->decode returned false
09-23 15:48:50.432 D/DecodeBitmapFromFile: (16847): Exception of type 'Java.Lang.OutOfMemoryError' was thrown.

La última linea hacer referencia a un try/catch que tengo al hacer el decode en el bitmapworkertask.


Pedro Gomez

unread,
Sep 24, 2013, 3:44:58 PM9/24/13
to desarrollad...@googlegroups.com

Sigo dandole vueltas a como optimizar mi código. He visto la herramienta DDMS, a ver si puedo acoplarla. Creo que así se pueden saber hasta los objetos creados en java.

http://developer.android.com/tools/debugging/ddms.html


Pedro Gomez

unread,
Sep 25, 2013, 7:03:23 AM9/25/13
to





Tras utilizar la galeria durante varios minutos he visto en mi dominator tree del DDMS que "1-byte array (byte[], boolean[])" se incrementa de manera salvaje. ¿Que es exactamente?


EDITO:

He sacado un archivo HPROF del DDMS y convirtiendolo a través de HPROF-CONV.Exe (android/tool) he podido abrirlo en el Eclipse Memory Analyzer, y me he encontrado con esta sorpresa!!!!!!!!
























¿¿¿¿Como es posible que se queden los bitmapworkertask si terminan ejecutandose????

Gabriel Pozo

unread,
Sep 25, 2013, 8:51:05 AM9/25/13
to desarrollad...@googlegroups.com
Podrías ver esto, con este tipo de problemas de memoria, la solución creo que solo podrá salir de tu análisis sobre que sucede con la misma :P (Si es muy molesto)

http://stackoverflow.com/a/13583808/1748764

Ahora lo que ya no recuerdo, era porque tantos fragments necesitas?




El 25 de septiembre de 2013 04:14, Pedro Gomez <pocke...@gmail.com> escribió:

Tras utilizar la galeria durante varios minutos he visto en mi dominator tree del DDMS que "1-byte array (byte[], boolean[])" se incrementa de manera salvaje. ¿Que es exactamente?



El martes, 24 de septiembre de 2013 21:44:58 UTC+2, Pedro Gomez escribió:

Sigo dandole vueltas a como optimizar mi código. He visto la herramienta DDMS, a ver si puedo acoplarla. Creo que así se pueden saber hasta los objetos creados en java.

http://developer.android.com/tools/debugging/ddms.html


--
Para participar es necesario que leas detenidamente las normas del grupo: http://goo.gl/20KhL
---
Has recibido este mensaje porque estás suscrito al grupo "desarrolladores-android" de Grupos de Google.
Para anular la suscripción a este grupo y dejar de recibir sus correos electrónicos, envía un correo electrónico a desarrolladores-a...@googlegroups.com.
Para publicar una entrada en este grupo, envía un correo electrónico a desarrollad...@googlegroups.com.
Visita este grupo en http://groups.google.com/group/desarrolladores-android.
Para ver este debate en la Web, visita https://groups.google.com/d/msgid/desarrolladores-android/4c623a79-49ce-46fb-80a9-09565bd6b543%40googlegroups.com.

Para obtener más opciones, visita https://groups.google.com/groups/opt_out.

Pedro Gomez

unread,
Sep 25, 2013, 9:35:20 AM9/25/13
to
Gracias Gabriel, habia entrado en esos enlaces haciendo una busqueda ràpida pero he revisado los arrays que tengo (string[] = null). No se por qué pero los bitmapworkedtask se quedan en memoria y mira que de cada fragmento hago un bitmapworkedtask = null para que pierda el puntero.

Lo que necesito tanto fragmentos es porque la distribución es dinámica, es decir, puedes tener en un fragmento 1, 2, 4 o 9 imagenes (cada imagen es un subfragmento para que tenga entiendad propia y pueda manejarlo como un activity).




El miércoles, 25 de septiembre de 2013 14:51:05 UTC+2, Gabriel Pozo escribió:
Podrías ver esto, con este tipo de problemas de memoria, la solución creo que solo podrá salir de tu análisis sobre que sucede con la misma :P (Si es muy molesto)

http://stackoverflow.com/a/13583808/1748764

Ahora lo que ya no recuerdo, era porque tantos fragments necesitas?


El 25 de septiembre de 2013 04:14, Pedro Gomez <pocke...@gmail.com> escribió:

Tras utilizar la galeria durante varios minutos he visto en mi dominator tree del DDMS que "1-byte array (byte[], boolean[])" se incrementa de manera salvaje. ¿Que es exactamente?



El martes, 24 de septiembre de 2013 21:44:58 UTC+2, Pedro Gomez escribió:

Sigo dandole vueltas a como optimizar mi código. He visto la herramienta DDMS, a ver si puedo acoplarla. Creo que así se pueden saber hasta los objetos creados en java.

http://developer.android.com/tools/debugging/ddms.html


--
Para participar es necesario que leas detenidamente las normas del grupo: http://goo.gl/20KhL
---
Has recibido este mensaje porque estás suscrito al grupo "desarrolladores-android" de Grupos de Google.
Para anular la suscripción a este grupo y dejar de recibir sus correos electrónicos, envía un correo electrónico a desarrolladores-android+unsub...@googlegroups.com.

Para publicar una entrada en este grupo, envía un correo electrónico a desarrollad...@googlegroups.com.
Visita este grupo en http://groups.google.com/group/desarrolladores-android.

Gabriel Pozo

unread,
Sep 25, 2013, 9:41:49 AM9/25/13
to desarrollad...@googlegroups.com
Si usas el ejemplo de Google (http://developer.android.com/training/displaying-bitmaps/index.html) deberías usar el método de la clase ImageWorker: 

public static void cancelWork(ImageView imageView) {
        final BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);
        if (bitmapWorkerTask != null) {
            bitmapWorkerTask.cancel(true);
            if (BuildConfig.DEBUG) {
                final Object bitmapData = bitmapWorkerTask.data;
                Log.d(TAG, "CancelarTrabajo - cancelar el trabajo para " + bitmapData);
            }
        }
 }

O por supuesto modificar eso para tu proyecto ;) con algo como esto por ejemplo (no necesariamente digo que uses esta función, ni que sea lo optimo, es solo una opción):

public void cancelarCargaImagenes(){
        ImageView imageView;

        for(int i = 0; i < layout.getChildCount(); i++){

            if(layout.getChildAt(i) != null){
                    if(mapa.getChildAt(i).getClass().equals(ImageView.class)){
                        imageView = (ImageView)mapa.getChildAt(i);

                        if(imageView != null){
                            ImageWorker.cancelWork(imageView);
                        }
                    }
             }
         }
  }


Si es como decís tu problema puede estar en que las AsyncTask siguen trabajando a pesar de que lo que hacen ya no sirva porque las imágenes a cargar ya no están a la vista :P, pero el problema es que se le van sumando las nuevas, y eso termina sobrecargando la memoria. Aclaro, solo imagino :D 
En resumen, una posibilidad sobre tu problema, creo que puede ser, que cargas un fragment, llamas a las tareas que cargan las imágenes, ahora si cambias el fragment, las tareas que no terminaron siguen corriendo y le agregas las del nuevo fragment y así seguimos comiendo memoria hasta que desbordas el heap de tu app y vuela todo por los aires ;)




El 25 de septiembre de 2013 10:17, Pedro Gomez <pocke...@gmail.com> escribió:
Gracias Gabriel, habia entrado en esos enlaces haciendo una busqueda ràpida pero es algo obvio (string[] = null). No se por qué pero los bitmapworkedtask se quedan en memoria y mira que de cada fragmento hago un bitmapworkedtask = null para que pierda el puntero.

Lo que necesito tanto fragmentos es porque la distribución es dinámica, es decir, puedes tener en un fragmento 1, 2, 4 o 9 imagenes (cada imagen es un subfragmento para que tenga entiendad propia y pueda manejarlo como un activity).



El miércoles, 25 de septiembre de 2013 14:51:05 UTC+2, Gabriel Pozo escribió:
Podrías ver esto, con este tipo de problemas de memoria, la solución creo que solo podrá salir de tu análisis sobre que sucede con la misma :P (Si es muy molesto)

http://stackoverflow.com/a/13583808/1748764

Ahora lo que ya no recuerdo, era porque tantos fragments necesitas?


El 25 de septiembre de 2013 04:14, Pedro Gomez <pocke...@gmail.com> escribió:

Tras utilizar la galeria durante varios minutos he visto en mi dominator tree del DDMS que "1-byte array (byte[], boolean[])" se incrementa de manera salvaje. ¿Que es exactamente?



El martes, 24 de septiembre de 2013 21:44:58 UTC+2, Pedro Gomez escribió:

Sigo dandole vueltas a como optimizar mi código. He visto la herramienta DDMS, a ver si puedo acoplarla. Creo que así se pueden saber hasta los objetos creados en java.

http://developer.android.com/tools/debugging/ddms.html


--
Para participar es necesario que leas detenidamente las normas del grupo: http://goo.gl/20KhL
---
Has recibido este mensaje porque estás suscrito al grupo "desarrolladores-android" de Grupos de Google.
Para anular la suscripción a este grupo y dejar de recibir sus correos electrónicos, envía un correo electrónico a desarrolladores-android+unsub...@googlegroups.com.
Para publicar una entrada en este grupo, envía un correo electrónico a desarrollad...@googlegroups.com.

--
Para participar es necesario que leas detenidamente las normas del grupo: http://goo.gl/20KhL
---
Has recibido este mensaje porque estás suscrito al grupo "desarrolladores-android" de Grupos de Google.
Para anular la suscripción a este grupo y dejar de recibir sus correos electrónicos, envía un correo electrónico a desarrolladores-a...@googlegroups.com.
Para publicar una entrada en este grupo, envía un correo electrónico a desarrollad...@googlegroups.com.
Visita este grupo en http://groups.google.com/group/desarrolladores-android.
Para ver este debate en la Web, visita https://groups.google.com/d/msgid/desarrolladores-android/194d94a7-f477-406a-aef1-1fe8f89ebb63%40googlegroups.com.

Para obtener más opciones, visita https://groups.google.com/groups/opt_out.

Pedro Gomez

unread,
Sep 25, 2013, 10:47:15 AM9/25/13
to

Gracias Gabriel, efectivamente hago un bitmapworkedtask.Cancel(true). En concreto, lo hago desde el OnDestroyView de cada subfragmento, adjunto clase bitmapworkedtaskCustom y subfragmento:



class Subfragmento : Fragmento
{
private BitmapWorkedTaskCustom mTask;

public oncreateview(....)
{
....
LoadImage();
}

private void LoadImage()
{
mTask = new BitmapWorkedTaskCustom(imagebutton, width, height);
mTask.OnExecute(pathimagen);
}

public override OnDestroyView()
{
  mTask.Cancel(true);
  mTask = null;
}




public class BitmapWorkerTaskCustom : AsyncTask
    {
      private WeakReference imageViewReference;
      private int reqHeight = 0;
      private int reqWidht = 0;
      private string path;

      public BitmapWorkerTask(ImageButton imageView, int pReqWidth, int pReqHeight)
      {
        //_____________________________________________________________________
        // Use a WeakReference to ensure the ImageView can be garbage collected
        imageViewReference = new WeakReference(imageView);

        reqHeight = pReqHeight;
        reqWidht = pReqWidth;
      }

      protected override Java.Lang.Object DoInBackground(params Java.Lang.Object[] @params)
      {
        path = @params[0].ToString();

        try
        {
          return DecodeSampleBitmapFromFile(path, reqWidht, reqHeight);
        }
        catch (System.Exception ex)
        {
          Log.Debug("TT", "Exception : " + ex.Message);
          return null;
        }
      }

      protected override void OnPostExecute(Java.Lang.Object result)
      {
        base.OnPostExecute(result);

        if (IsCancelled)
        {
          result = null;
          Log.Debug("TT", "OnPostExecute - Task Cancelled");
        }
        else
        {
          using (Bitmap bmpResult = result as Bitmap)
          {
            if (imageViewReference != null && bmpResult != null)
            {
              ImageButton view = imageViewReference.Target as ImageButton;

              if (view != null)
              {
                view.SetImageBitmap(bmpResult); //Actualizo el imagebutton con el bitmap resultante.
               
                bmpResult.Dispose();

              }
            }
          }

        }
      }

      public static int CalculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight)
      {
        //_____________________________
        // Raw height and width of image
        int height = options.OutHeight;
        int width = options.OutWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth)
        {
          if (width > height)
          {
            inSampleSize = (int)System.Math.Round((float)height / (float)reqHeight);
          }
          else
          {
            inSampleSize = (int)System.Math.Round((float)width / (float)reqWidth);
          }
        }

        return inSampleSize;

      }

      public static Bitmap DecodeSampleBitmapFromFile(string path, int reqWidth, int reqHeight)
      {
        Bitmap b = null;

        try
        {
          //______________________________________________________________
          // First decode with inJustDecodeBounds=true to check dimensions
          BitmapFactory.Options options = new BitmapFactory.Options();
          options.InJustDecodeBounds = true;
          options.InPurgeable = true;
          options.InPreferredConfig = Bitmap.Config.Rgb565; //Bajar calidad del bitmap para utilizar menos memoria.
          BitmapFactory.DecodeFile(path, options);

          //______________________
          // Calculate inSampleSize
          options.InSampleSize = CalculateInSampleSize(options, reqWidth, reqHeight);

          //____________________________________
          // Decode bitmap with inSampleSize set
          options.InJustDecodeBounds = false;

          b = BitmapFactory.DecodeFile(path, options);
          return b;
        }
        catch (System.Exception ex)
        {
          Log.Debug("DecodeBitmapFromFile: ", ex.Message);
          return null;
        }
        finally
        {
          b.Dispose();
        }
      }

    }

Estas son mis llamadas , practicamente siguiendo al detalle la documentación oficial pero sigo teniendo fugas de memoria.

saludos




Reply all
Reply to author
Forward
0 new messages