Provoquant OutOfMemoryError en en Animation image par Image dans Android

Je suppose que votre image d'animation les images sont compressées (format PNG ou JPG). La taille compressée n'est pas utile pour le calcul de la quantité de mémoire nécessaire pour les afficher. Pour cela, vous devez penser à la taille non compressée. Ce sera le nombre de pixels (320 x 480), multiplié par le nombre d'octets par pixel, ce qui est généralement 4 (32 bits). Pour vos images, puis, chacun sera 614,400 octets. Pour le 26-animation d'images exemple fourni par vous, qui nécessitera un total de 15,974,400 octets pour tenir les premières données de l'image pour toutes les images, sans compter l'objet de frais généraux.

Regardant le code source pour AnimationDrawable, il apparaît pour charger toutes les images dans la mémoire à la fois, qu'il aurait fait de faire de bonnes performances.

Si vous pouvez allouer plus de mémoire ou pas est très dépendante du système. Je voudrais au moins vous recommandons d'essayer cela sur un périphérique réel au lieu de l'émulateur. Vous pouvez également essayer de peaufiner l'émulateur disponible de la taille de la RAM, mais c'est juste deviner.

Il y a des façons d'utiliser BitmapFactory.inPreferredConfig pour charger des images dans un plus efficace de la mémoire format RVB 565 (plutôt que ARGB 8888). Cela permettrait d'économiser de l'espace, mais encore, elle pourrait ne pas être suffisante.

Si vous ne pouvez pas allouer beaucoup de mémoire à la fois, vous devez considérer d'autres options. La plupart des cartes graphiques hautes performances des applications (ex: jeux) tirer leurs graphiques à partir des combinaisons de petits graphiques (sprites) ou 2D ou 3D primitives (rectangles, triangles). Dessin plein écran bitmap pour chaque trame est effectivement la même que le rendu de la vidéo, pas nécessairement la plus efficace.

L'ensemble du contenu de votre changement de l'animation avec chaque image? Une autre optimisation peut être pour animer la partie qui change réellement, et découpez vos bitmaps de tenir compte de cela.

Pour résumer, vous avez besoin de trouver un moyen d'attirer votre animation en utilisant moins de mémoire. Il y a beaucoup d'options, mais cela dépend beaucoup de la façon dont votre animation doit regarder.

J'ai passé beaucoup de temps sur ce sujet et ont deux solutions différentes, à la fois bon..

Tout d'abord, le problème:
1) Android charge toutes les images dans la mémoire vive, en non compressé en format Bitmap.
2) Android utilise les ressources de mise à l'échelle, de sorte que sur un téléphone avec un xxxhdpi d'affichage (comme le LG G3), chaque image prend une TONNE d'espace, de sorte que vous rapidement à court de RAM.

Solution #1

1) court-circuite Android ressource mise à l'échelle. 2) les Magasins de la bytearrays de tous les fichiers dans la mémoire (ce sont de petites, surtout pour les Jpeg). 3) Génère des images bitmap, image par image, de sorte qu'il est presque impossible de faire fonctionner de la mémoire vive.

Inconvénients: Elle spams vos journaux qu'Android est l'allocation de mémoire pour de nouvelles images Bitmaps et de recyclage des anciens. Il effectue aussi moche sur des appareils plus anciens (Galaxy S1), mais qui joue bien sur le budget actuel des téléphones (lire: $10 Alcatel C1, j'ai ramassé au BestBuy). Deuxième solution ci-dessous fonctionne mieux sur les appareils plus anciens, mais pourraient encore à court de RAM dans certaines circonstances.

public class MyAnimationDrawable {
public static class MyFrame {
byte[] bytes;
int duration;
Drawable drawable;
boolean isReady = false;
}
public interface OnDrawableLoadedListener {
public void onDrawableLoaded(List<MyFrame> myFrames);
}
public static void loadRaw(final int resourceId, final Context context, final OnDrawableLoadedListener onDrawableLoadedListener) {
loadFromXml(resourceId, context, onDrawableLoadedListener);
}
private static void loadFromXml(final int resourceId, final Context context, final OnDrawableLoadedListener onDrawableLoadedListener) {
new Thread(new Runnable() {
@Override
public void run() {
final ArrayList<MyFrame> myFrames = new ArrayList<>();
XmlResourceParser parser = context.getResources().getXml(resourceId);
try {
int eventType = parser.getEventType();
while (eventType != XmlPullParser.END_DOCUMENT) {
if (eventType == XmlPullParser.START_DOCUMENT) {
} else if (eventType == XmlPullParser.START_TAG) {
if (parser.getName().equals("item")) {
byte[] bytes = null;
int duration = 1000;
for (int i=0; i<parser.getAttributeCount(); i++) {
if (parser.getAttributeName(i).equals("drawable")) {
int resId = Integer.parseInt(parser.getAttributeValue(i).substring(1));
bytes = IOUtils.toByteArray(context.getResources().openRawResource(resId));
}
else if (parser.getAttributeName(i).equals("duration")) {
duration = parser.getAttributeIntValue(i, 1000);
}
}
MyFrame myFrame = new MyFrame();
myFrame.bytes = bytes;
myFrame.duration = duration;
myFrames.add(myFrame);
}
} else if (eventType == XmlPullParser.END_TAG) {
} else if (eventType == XmlPullParser.TEXT) {
}
eventType = parser.next();
}
}
catch (IOException | XmlPullParserException e) {
e.printStackTrace();
}
//Run on UI Thread
new Handler(context.getMainLooper()).post(new Runnable() {
@Override
public void run() {
if (onDrawableLoadedListener != null) {
onDrawableLoadedListener.onDrawableLoaded(myFrames);
}
}
});
}
}).run();
}
public static void animateRawManually(int resourceId, final ImageView imageView, final Runnable onStart, final Runnable onComplete) {
loadRaw(resourceId, imageView.getContext(), new OnDrawableLoadedListener() {
@Override
public void onDrawableLoaded(List<MyFrame> myFrames) {
if (onStart != null) {
onStart.run();
}
animateRawManually(myFrames, imageView, onComplete);
}
});
}
public static void animateRawManually(List<MyFrame> myFrames, ImageView imageView, Runnable onComplete) {
animateRawManually(myFrames, imageView, onComplete, 0);
}
private static void animateRawManually(final List<MyFrame> myFrames, final ImageView imageView, final Runnable onComplete, final int frameNumber) {
final MyFrame thisFrame = myFrames.get(frameNumber);
if (frameNumber == 0) {
thisFrame.drawable = new BitmapDrawable(imageView.getContext().getResources(), BitmapFactory.decodeByteArray(thisFrame.bytes, 0, thisFrame.bytes.length));
}
else {
MyFrame previousFrame = myFrames.get(frameNumber - 1);
((BitmapDrawable) previousFrame.drawable).getBitmap().recycle();
previousFrame.drawable = null;
previousFrame.isReady = false;
}
imageView.setImageDrawable(thisFrame.drawable);
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
//Make sure ImageView hasn't been changed to a different Image in this time
if (imageView.getDrawable() == thisFrame.drawable) {
if (frameNumber + 1 < myFrames.size()) {
MyFrame nextFrame = myFrames.get(frameNumber+1);
if (nextFrame.isReady) {
//Animate next frame
animateRawManually(myFrames, imageView, onComplete, frameNumber + 1);
}
else {
nextFrame.isReady = true;
}
}
else {
if (onComplete != null) {
onComplete.run();
}
}
}
}
}, thisFrame.duration);
//Load next frame
if (frameNumber + 1 < myFrames.size()) {
new Thread(new Runnable() {
@Override
public void run() {
MyFrame nextFrame = myFrames.get(frameNumber+1);
nextFrame.drawable = new BitmapDrawable(imageView.getContext().getResources(), BitmapFactory.decodeByteArray(nextFrame.bytes, 0, nextFrame.bytes.length));
if (nextFrame.isReady) {
//Animate next frame
animateRawManually(myFrames, imageView, onComplete, frameNumber + 1);
}
else {
nextFrame.isReady = true;
}
}
}).run();
}
}
}

** Solution n ° 2 **

Il charge la ressource XML, analyse les charges et les ressources brutes - en contournant Android ressource mise à l'échelle (qui est responsable de la plupart des OutOfMemoryExceptions), et crée une AnimationDrawable.

Avantages: fonctionne mieux sur les appareils plus anciens (par exemple. Galaxy S1)

Inconvénients: toujours à court de RAM que c'est la tenue de tous les non compressé des images dans la mémoire (mais ils sont plus petits car ils ne sont pas mis à l'échelle de la façon dont Android normalement échelles images)

public static void animateManuallyFromRawResource(int animationDrawableResourceId, ImageView imageView, Runnable onStart, Runnable onComplete) {
AnimationDrawable animationDrawable = new AnimationDrawable();
XmlResourceParser parser = imageView.getContext().getResources().getXml(animationDrawableResourceId);
try {
int eventType = parser.getEventType();
while (eventType != XmlPullParser.END_DOCUMENT) {
if (eventType == XmlPullParser.START_DOCUMENT) {
} else if (eventType == XmlPullParser.START_TAG) {
if (parser.getName().equals("item")) {
Drawable drawable = null;
int duration = 1000;
for (int i=0; i<parser.getAttributeCount(); i++) {
if (parser.getAttributeName(i).equals("drawable")) {
int resId = Integer.parseInt(parser.getAttributeValue(i).substring(1));
byte[] bytes = IoUtils.readBytes(imageView.getContext().getResources().openRawResource(resId));
drawable = new BitmapDrawable(imageView.getContext().getResources(), BitmapFactory.decodeByteArray(bytes, 0, bytes.length));
}
else if (parser.getAttributeName(i).equals("duration")) {
duration = parser.getAttributeIntValue(i, 66);
}
}
animationDrawable.addFrame(drawable, duration);
}
} else if (eventType == XmlPullParser.END_TAG) {
} else if (eventType == XmlPullParser.TEXT) {
}
eventType = parser.next();
}
}
catch (IOException | XmlPullParserException e) {
e.printStackTrace();
}
if (onStart != null) {
onStart.run();
}
animateDrawableManually(animationDrawable, imageView, onComplete, 0);
}
private static void animateDrawableManually(final AnimationDrawable animationDrawable, final ImageView imageView, final Runnable onComplete, final int frameNumber) {
final Drawable frame = animationDrawable.getFrame(frameNumber);
imageView.setImageDrawable(frame);
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
//Make sure ImageView hasn't been changed to a different Image in this time
if (imageView.getDrawable() == frame) {
if (frameNumber + 1 < animationDrawable.getNumberOfFrames()) {
//Animate next frame
animateDrawableManually(animationDrawable, imageView, onComplete, frameNumber + 1);
}
else {
//Animation complete
if (onComplete != null) {
onComplete.run();
}
}
}
}
}, animationDrawable.getDuration(frameNumber));
}

Si vous rencontrez toujours des problèmes de mémoire, l'utilisation de plus petites images... ou stocker le nom de la ressource + la durée, et de générer le tableau d'octets + Dessinés sur chaque image. Que serait certainement causer trop de découper entre les images, mais utilise presque zéro RAM.

J'ai eu ce problème et l'a résolu par faire les deux choses suivantes:

1. Couper la résolution de l'animation d'images en demi...1/4 de la taille non compressée octets.
2. Mettre les images dans le drawable-nodpi dossier afin de ne pas obtenir les mises à l'échelle par Android pour vous.

Mon animation a toujours pas de charge sur certains téléphones, après avoir fait l'étape 1.
Étape 2 l'ai eu à travailler sur ces téléphones.

Espère que cela sauve quelqu'un d'autre peu de temps.

EDIT: j'avais toujours des plantages après l'Activité, qui joue le AnimationDrawable mais je l'ai déjà travaillé. Voici les choses que j'ai fait:

1. Ne pas utiliser une animation-liste en xml. Au lieu de créer de la AnimationDrawable chaque fois que vous avez besoin de l'utiliser. Sinon, la prochaine fois que vous chargez l'animation dessiné à partir de la ressource, il sera toujours essayer d'utiliser les images, en fin de recyclage.
2. Recycler les bitmaps dans le AnimationDrawable lorsque vous avez terminé de l'utiliser. C'est la magie qui libère de la mémoire.
3. Utilisation de l'Appareil Android monitor pour Surveiller l'allocation d'octets dans votre tas.

Voici le code que j'utilise pour la création de la AnimationDrawable:

    protected AnimationDrawable CreateLoadingAnimationDrawable()
{
AnimationDrawable animation = new AnimationDrawable ();
animation.OneShot = false;
for (int i = 0; i < kNumberOfFrames; ++i) {
int index = (i * 2) + 1;
string stringIndex = index.ToString ("00");
string bitmapStringId = kBaseAnimationName + stringIndex;
int resID = this.Resources.GetIdentifier (bitmapStringId, "drawable", this.PackageName);
Bitmap bitmap = BitmapFactory.DecodeResource (this.Resources, resID);
BitmapDrawable frame = new BitmapDrawable (bitmap);
//Drawable frame = Resources.GetDrawable (resID);
animation.AddFrame (frame, 111);
}
return animation;
}

Et le code pour libérer les images lorsque vous avez terminé de les utiliser. Vous pourriez le faire dans OnPause ou OnDestroy. _loadingAnimation est mon AnimationDrawable créé ci-dessus. J'aimerais savoir ce que SetCallback() le fait pour vous dans ce cas. J'ai juste copié qu'à partir de quelque part d'autre sur soi.

        if (_loadingAnimation != null) {
_loadingAnimation.Stop ();
_loadingImageView.SetBackgroundResource (Resource.Drawable.loading_anim_full7001);
for (int i = 0; i < _loadingAnimation.NumberOfFrames; ++i) {
BitmapDrawable frame = _loadingAnimation.GetFrame (i) as BitmapDrawable;
if (frame != null) {
Android.Graphics.Bitmap bitmap = frame.Bitmap;
bitmap.Recycle ();
frame.SetCallback(null);
}
}
_loadingAnimation.SetCallback(null);
_loadingAnimation = null;
}

Ted

J'ai porté une solution à Xamarin Android et fait quelques améliorations.

Fonctionne très bien avec les changements d'orientation et spécialement avec des images autour de 300 de largeur et de hauteur (la plus grande de l'image, plus il faut de temps pour charger l'image, plus de scintillement).

using Android.Content;
using Android.Graphics;
using Android.OS;
using Android.Widget;
using System;
namespace ...Droid.Util
{
public class FramesSequenceAnimation
{
private int[] animationFrames;
private int currentFrame;
private bool shouldRun;   //true if the animation should continue running. Used to stop the animation
private bool isRunning;   //true if the animation currently running. prevents starting the animation twice
private ImageView imageview;
private Handler handler;
private int delayMillis;
private bool oneShot = false;
private FramesSequenceAnimationListener onAnimationStoppedListener;
private Bitmap bitmap = null;
private BitmapFactory.Options bitmapOptions;
private Action action;
private static object Lock = new object();
public interface FramesSequenceAnimationListener
{
void AnimationStopped();
}
public void SetFramesSequenceAnimationListener(FramesSequenceAnimationListener onAnimationStoppedListener)
{
this.onAnimationStoppedListener = onAnimationStoppedListener;
}
public int GetCurrentFrame()
{
return currentFrame;
}
public void SetCurrentFrame(int currentFrame)
{
this.currentFrame = currentFrame;
}
public FramesSequenceAnimation(FramesSequenceAnimationListener onAnimationStoppedListener, ImageView imageview, int[] animationFrames, int fps)
{
this.onAnimationStoppedListener = onAnimationStoppedListener;
this.imageview = imageview;
this.animationFrames = animationFrames;
delayMillis = 1000 / fps;
currentFrame = -1;
shouldRun = false;
isRunning = false;
handler = new Handler();
imageview.SetImageResource(this.animationFrames[0]);
////use in place bitmap to save GC work (when animation images are the same size & type)
//if (Build.VERSION.SdkInt >= BuildVersionCodes.Honeycomb)
//{
//   Bitmap bmp = ((BitmapDrawable)imageview.Drawable).Bitmap;
//   int width = bmp.Width;
//   int height = bmp.Height;
//   Bitmap.Config config = bmp.GetConfig();
//   bitmap = Bitmap.CreateBitmap(width, height, config);
//   bitmapOptions = new BitmapFactory.Options(); //setup bitmap reuse options
//   bitmapOptions.InBitmap = bitmap; //reuse this bitmap when loading content
//   bitmapOptions.InMutable = true;
//   bitmapOptions.InSampleSize = 1;
//}
bitmapOptions = newOptions();
bitmap = decode(bitmapOptions, getNext());
bitmapOptions.InBitmap = bitmap;
}
private BitmapFactory.Options newOptions()
{
BitmapFactory.Options options = new BitmapFactory.Options();
options.InSampleSize = 1;
options.InMutable = true;
options.InJustDecodeBounds = true;
options.InPurgeable = true;
options.InInputShareable = true;
options.InPreferredConfig = Bitmap.Config.Rgb565;
return options;
}
private Bitmap decode(BitmapFactory.Options options, int imageRes)
{
return BitmapFactory.DecodeResource(imageview.Resources, imageRes, bitmapOptions);
}
public void SetOneShot(bool oneShot)
{
this.oneShot = oneShot;
}
private int getNext()
{
currentFrame++;
if (currentFrame >= animationFrames.Length)
{
if (oneShot)
{
shouldRun = false;
currentFrame = animationFrames.Length - 1;
}
else
{
currentFrame = 0;
}
}
return animationFrames[currentFrame];
}
public void stop()
{
lock (Lock)
{
shouldRun = false;
}
}
public void start()
{
lock (Lock)
{
shouldRun = true;
if (isRunning)
{
return;
}
Action tempAction = new Action(delegate
{
if (!shouldRun || imageview == null)
{
isRunning = false;
if (onAnimationStoppedListener != null)
{
onAnimationStoppedListener.AnimationStopped();
onAnimationStoppedListener = null;
handler.RemoveCallbacks(action);
}
return;
}
isRunning = true;
handler.PostDelayed(action, delayMillis);
if (imageview.IsShown)
{
int imageRes = getNext();
if (bitmap != null)
{
if (Build.VERSION.SdkInt >= BuildVersionCodes.Honeycomb)
{
if (bitmap != null && !bitmap.IsRecycled)
{
bitmap.Recycle();
bitmap = null;
}
}
try
{
bitmap = BitmapFactory.DecodeResource(imageview.Resources, imageRes, bitmapOptions);
}
catch (Exception e)
{
bitmap.Recycle();
bitmap = null;
Console.WriteLine("Exception: " + e.StackTrace);
}
if (bitmap != null)
{
imageview.SetImageBitmap(bitmap);
}
else
{
imageview.SetImageResource(imageRes);
bitmap.Recycle();
bitmap = null;
}
}
else
{
imageview.SetImageResource(imageRes);
}
}
});
action = tempAction;
handler.Post(action);
}
}
}
}

C'est mon écran de démarrage de classe: (cette classe lit les images à partir du dossier drawable qui sont nommés "splash_0001, splash_0002 ...". Donc pas besoin de le nom de votre image à des ressources sur un tableau. Augmenter le nombre d'images par seconde (FPS) à la vitesse de l'animation).

using Android.App;
using Android.Content;
using Android.OS;
using Android.Widget;
using ...Droid.Base;
using ...Droid.Util;
using System;
using System.Collections.Generic;
using static ...Util.FramesSequenceAnimation;
namespace ...Droid.Activities
{
[Activity(MainLauncher = true)]
public class SplashActivity : BaseActivity, FramesSequenceAnimationListener
{
private FramesSequenceAnimation framesSequenceAnimation;
private const string
IMAGE_NAME_PREFIX = "splash_",
KEY_CURRENT_FRAME = "key_current_frame";
private int FPS = 50;
private int numberOfImages;
protected override OrientationEnum GetOrientation()
{
return OrientationEnum.ORIENTATION_CHECK_DEVICE_SIZE;
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.activity_splash);
RelativeLayout background = FindViewById<RelativeLayout>(Resource.Id.splash_background);
background.Click += Click;
ImageView imageView = FindViewById<ImageView>(Resource.Id.splash_imageview);
imageView.Click += Click;
numberOfImages = GetSplashImagesCount();
framesSequenceAnimation = new FramesSequenceAnimation(this, imageView, GetImageResourcesIDs(), FPS);
framesSequenceAnimation.SetOneShot(true);
if (savedInstanceState != null)
{
int currentFrame = savedInstanceState.GetInt(KEY_CURRENT_FRAME) + 1;
if (currentFrame < numberOfImages)
{
framesSequenceAnimation.SetCurrentFrame(currentFrame);
}
}
framesSequenceAnimation.start();
}
private int[] GetImageResourcesIDs()
{
List<int> list = new List<int>();
for (int i = 1; i <= numberOfImages; i++)
{
var image_name = IMAGE_NAME_PREFIX + i.ToString().PadLeft(4, '0');
int resID = Resources.GetIdentifier(image_name, "drawable", PackageName);
list.Add(resID);
}
return list.ToArray();
}
private int GetSplashImagesCount()
{
//Count number of images in drawable folder
int count = 0;
var fields = typeof(Resource.Drawable).GetFields();
foreach (var field in fields)
{
if (field.Name.StartsWith(IMAGE_NAME_PREFIX))
{
count++;
}
}
return count;
}
private void Click(object sender, EventArgs e)
{
framesSequenceAnimation.SetFramesSequenceAnimationListener(null);
GoToLoginScreen();
}
private void GoToLoginScreen()
{
Finish();
StartActivity(new Intent(this, typeof(LoginActivity)));
OverridePendingTransition(0, Resource.Animation.abc_fade_out);
}
void FramesSequenceAnimationListener.AnimationStopped()
{
GoToLoginScreen();
}
protected override void OnSaveInstanceState(Bundle outState)
{
base.OnSaveInstanceState(outState);
outState.PutInt(KEY_CURRENT_FRAME, framesSequenceAnimation.GetCurrentFrame());
}
}
}

J'ai résolu mon outOfMemoryError problème en coupant le framerate brutalement et de mise à l'échelle vers le bas les images dans gimp. En fonction de ce que vous faites, vous pouvez probablement vous en sortir avec beaucoup moins de fps que vous attendez.