Android ViewPager с изображениями: утечка памяти/сбои приложений

Ответ 1

Поэтому используйте

1

@Override
public Object instantiateItem(ViewGroup collection, int position)
@Override
public void destroyItem(ViewGroup collection, int position, Object view)

вместо

 public Object instantiateItem(View collection, int position)
 public void destroyItem(View collection, int position, Object view)

2 Протестировано на 6 изображений размером 400 тыс. каждый работает нормально

@Override
public Object instantiateItem(ViewGroup collection, int position)
{
    LayoutInflater inflater = (LayoutInflater) collection.getContext()
            .getSystemService(Context.LAYOUT_INFLATER_SERVICE);



    int resId = 0;
    switch (position) {
    case 0:
        resId = R.layout.farleft;
        break;
    case 1:
        resId = R.layout.left;
        break;
    case 2:
        resId = R.layout.middle;
        break;
    case 3:
        resId = R.layout.right;
        break;
    case 4:
        resId = R.layout.farright;
        break;
    case 5:
        resId = R.layout.farfarright;
        break;
    }

View view = (View) inflater.inflate(resId, null);


 //get Image view from layout   
//ImageView imageView = (ImageView) view.findViewById(resId);

//imageView.setImageResource(resId);

    collection.addView(view, 0);

    return view;
}

@Override
public void destroyItem(ViewGroup collection, int position, Object view)
{
    collection.removeView((View) view);
}

3 Полезная ссылка PageAdapter

Гудлак

Ответ 2

Немного поздно с ответом, но проблема довольно проста на самом деле, и я не вижу других ответов, нацеленных на нее.

Дело в том, что когда вы вручную декодируете растровые изображения (как и в тех пронумерованных строках), , вам нужно .recycle() их. Итак, вернемся к вашему коду, в вашем адаптере вы должны дополнить это:

@Override
public Object instantiateItem(View collection, int position) {
    // ...
    View view = inflater.inflate(resId, null);
    ImageView imageView = (ImageView) view.findViewById(R.id.imageView);
    imageView.setImageBitmap(BitmapFactory.decodeResource(getResources(),
            ids[position]));
    ((ViewPager) collection).addView(view, 0);
    return view;
}

С этим - перезагрузите Bitmap в дополнение к удалению View из иерархии:

@Override
public void destroyItem(View collection, int position, Object o) {
    View view = (View)o;
    ImageView imgView = (ImageView) view.findViewById(R.id.imageView);
    BitmapDrawable bmpDrawable = (BitmapDrawable) imgView.getDrawable();
    if (bmpDrawable != null && bmpDrawable.getBitmap() != null) {
            // This is the important part
            bmpDrawable.getBitmap().recycle();
    }
    ((ViewPager) collection).removeView(view);
    view = null;
}

Это так просто, не нужно использовать отдельное управление растровым изображением или что-то еще.

Ответ 3

Хорошо документированный вопрос, и даже если вы, похоже, решили его, вот крошечный бит потенциально полезной информации.

От вас logcat, я обнаруживаю, что вы разрабатываете (или, по крайней мере, тестирование) на Gingerbread (потому что Honeycomb onward не включает в себя "внешнюю" часть на выходе. Это важно только потому, что в нем подчеркивается, что происходит с вашими растровыми изображениями В Gingerbread данные в растровых изображениях помещаются в встроенную память, за пределами кучи. Затем указатель на эти данные помещается в кучу вместе с некоторой другой ссылочной информацией. Удаление каждой ссылки на растровое изображение освобождает ссылочную информацию (в в какой-то момент, когда выполняется System.gc()). Однако данные растровых изображений никогда не будут выпущены, если ваше устройство не пострадает от астероида - или (менее драматично) вы вызываете метод recycle() на этом растровом изображении. Следует отметить, что действительно освобождает встроенную память, поэтому вам действительно нужно повторно создать растровое изображение с нуля, когда это необходимо снова с помощью ViewPager (скорее всего, в instantiateItem. Сотовые и последующие помещают растровые данные в пределах стека, который немного менее раздражает. data по-прежнему выпускается только тогда, когда вы recycle() растровое изображение (так что вам нужно копать немного глубже, используя DDMS, чтобы определить, что происходит - например, я сейчас борюсь с этой же проблемой на JB и в ICS, 4.0.3 ведет себя иначе, чем 4.0.4, но я отвлекаюсь).

Это, вероятно, слишком много, но мое решение заключалось в том, чтобы реализовать класс для отслеживания моих растровых изображений и быть уверенным, что я их переработал - в вашем случае это произойдет, когда вы destroyItem() в ViewPager.

Здесь (несколько пешеходный) класс, который я использую для отслеживания вещей, fwiw.

public class BitmapManager {

private final String TAG = "DEBUG -- " + ClassUtils.getShortClassName(this.getClass());
Context mContext = null;

private class BitmapVectorEntry {
    public Bitmap bm = null;
    public String name = null;
}

Vector<BitmapVectorEntry> mBitmapVector = new Vector<BitmapVectorEntry>();

public BitmapManager( Context aContext ) {
    mContext = aContext;
}

public void setContext( Context aContext ) {
    mContext = aContext;
}

public void registerBitmap( String name, Bitmap b) {

    if(mBitmapVector == null) {
        mBitmapVector = new Vector<BitmapVectorEntry>();
    }
    if(b == null) {
        Log.e(TAG, "Bitmap is NULL!!  ");
        return;
    }
    // Log.d(TAG, "        ~~~~~~ Registering ["+name+"]  ["+b+"]");
    BitmapVectorEntry be = new BitmapVectorEntry();
    be.bm = b;
    be.name = name;
    mBitmapVector.add(be);
}

public void registerBitmapForBackgroundDrawable( String name, View v ) {
    if(v != null) {
        Drawable d = v.getBackground();
        if(d != null) {
            if(d instanceof BitmapDrawable) {
                Bitmap bm = ((BitmapDrawable) d).getBitmap();
                if(bm != null) {
                    // Log.w(TAG, "     ~~~~  Registering Background Bitmap [" + bm + "]");
                    registerBitmap(name, bm);
                }  else  {
                    Log.w(TAG, " ~~~~ Background does not have a bitmap in the BitmapDrawable (Probably, but not necessarily, and error)");
                }
            }  else  {
                Log.w(TAG, " ~~~~ Background does not have a BitmapDrawable (Might not be an error)");
            }
        }  else  {
            Log.w(TAG, " ~~~~~ Background is null, no drawable (Might not be an error)");
        }
    } else  {
        Log.e(TAG, "  ~~~~~ View is null, is there no background for this view?");
    }
}

// We cannot recycle certain bitmaps, like the background for the page which houses
    // the ViewPager, since the pager reuses it, so we just delete it from vector
public void clear(Bitmap bm) {
    removeBitmap(bm, false);
}

// In most cases, when we are done with a bitmap, we want to recycle it.  This is a
    // synchronous call that frees external heap (in 2.3.x) or internal heap (3.x < ).
    // And when I say 'synchronous' I mean 'slow' and 'should not be run on the UI Thread,
    // So be sure to throw this on an async thread
public void recycleBitmap(Bitmap bm) {
    removeBitmap(bm, true);
}

private void removeBitmap(Bitmap bm, boolean andRecycleToo) {

    if(bm == null) {
        Log.e(TAG, "(RECYCLE BITMAP)  !!!! Bitmap is NULL!!, cannot recycle");
        return;
    }
    if(mBitmapVector == null) {
        Log.e(TAG, "(RECYCLE BITMAP)  !!!! Bitmap Vector is NULL!!");
        return;
    }

    boolean foundIt = false;
    Bitmap targetBm = null;
    int i = (mBitmapVector.size() - 1);
    try {
        for(; i >= 0; i--)  {
            BitmapVectorEntry b = mBitmapVector.get(i);
            targetBm = b.bm;
            if(targetBm.equals(bm)) {
                foundIt = true;
                if(andRecycleToo) {
                    if(!targetBm.isRecycled()) {
                        targetBm.recycle();
                    }
                }
                mBitmapVector.removeElementAt(i);
                // Log.e(TAG, "       Recycling ["+targetBm.name+"]  ["+targetBm.bm+"]");
                break;
            }
        }
    }  catch(Exception e) {

        Log.e(TAG, "Exception during recycling bitmap position ["+i+"] ["+bm+"] ["+e+"]");

    }  finally {

        mBitmapVector.trimToSize();
        if(andRecycleToo) {
            if(!foundIt && targetBm != null) {
                if(!targetBm.isRecycled())  {
                    targetBm.recycle();
                } 
                Log.e(TAG, "(RECYCLE BITMAP)   ========================= !!! RECYCLING Bitmap ["+targetBm+"], was unregistered, recycled is ["+targetBm.isRecycled()+"]");
            }  else  {
                // Log.i(TAG, "(RECYCLE BITMAP)   ========================= !!! RECYCLING Bitmap ["+targBe.name+"] ["+targBe.bm+"], was registered");
            }
        }

    }

}

public void flush() {
    if(mBitmapVector == null) {
        // Log.e(TAG, "!!!! Bitmap Vector is NULL!!");
        return;
    }
    for(int i = 0; i < mBitmapVector.size(); i++) {
        BitmapVectorEntry bme = mBitmapVector.get(i);
        if(!bme.bm.isRecycled()) {
            // Log.e(TAG, "Flushing Bitmap ["+bme.name+"] ["+bme.bm+"]");
            bme.bm.recycle();
        }
    }
    mBitmapVector.clear();
    mBitmapVector.trimToSize();

}

public void dumpBitmaps() {
    if(mBitmapVector == null) {
        // Log.e(TAG, "!!!! Bitmap Vector is NULL!!");
        return;
    }
    boolean foundOne = false;
    for(int i = 0; i < mBitmapVector.size(); i++) {
        Bitmap bm0 = mBitmapVector.get(i).bm;
        if(!bm0.isRecycled()) {
            foundOne = true;
            break;
        }
    }
    if(mBitmapVector.size() > 0 && foundOne) {
        Log.e(TAG, " ========= Dumping Bitmap Vector === (Found a leaker) ===== ");
        Log.e(TAG, "            "+mBitmapVector.size()+" entries");
        for(BitmapVectorEntry b : mBitmapVector) {
            if(!b.bm.isRecycled()) {
                Log.e(TAG, "       ["+b.name+"]  ["+b.bm+"]  Recycled ["+b.bm.isRecycled()+"]");
            }
        }
        Log.e(TAG, " ========= End of Bitmap Dump    ======== ");
    }
}
}

Бит ключа - это вызов dumpBitmaps() (по крайней мере, для описанной выше проблемы). Если усердно регистрирует все растровые изображения, то вызов dumpBitmaps() будет вызывать любые, которые требуют вычистки. Если вам не важно, где находится утечка, и просто хотите, чтобы он ушел, вы можете просто вызвать flush(), который удалит все растровые изображения.

Вам нужно разместить registerBitmap() везде, где вы создаете растровое изображение. У меня была страшная удача, когда надуватель делал непредсказуемые вещи, поэтому я предпочитаю что-то вроде:

    public Drawable getPreformattedFile() {
    // Log.d(TAG, "Loading in Drawable ["+preformattedFileName()+"]");
    if( preformattedFileName() == null) {
        Log.e(TAG, "Formatted Filename is null");
        return(null);
    }

    Drawable ret = null;
    try {

        BitmapFactory.Options opts = new BitmapFactory.Options();
        opts.inScaled = false;
        opts.inPurgeable = true;

        Bitmap bm = BitmapFactory.decodeFile(preformattedFileName(), opts);
        if(bm == null) {
            return(null);
        }
        mBitmapManager.registerBitmap(mItem.name(), bm);
        ret = new BitmapDrawable(mContext.getResources(), bm);

        // Log.i(TAG, "         ~~~~~~~~~~~~~~~~~ JUST CHECKING ["+bm+"]  ["+((BitmapDrawable) ret).getBitmap()+"]");

    } catch( OutOfMemoryError e ) {
        // Log.e(TAG, " ============== Before gc ==== OOME  Thread ["+Thread.currentThread().getName()+"]  getPreformattedFile.Before GC Heap Available [[[ "+(Debug.getNativeHeapFreeSize()/1024)+"k ]]]");
        System.gc();
        // Log.e(TAG, " ============== After gc  ==== OOME  Thread ["+Thread.currentThread().getName()+"]  getPreformattedFile.Before GC Heap Available [[[ "+(Debug.getNativeHeapFreeSize()/1024)+"k ]]]");
        e.printStackTrace();
    } catch( Exception e) {
        Log.e(TAG, "Trouble reading PNG file ["+e+"]");
    }
    return(ret);
}

Я упомянул пару раз, делая асинхронно, и вы упомянули, что вы новичок на Android. Для полноты я должен упомянуть, что мне также не нравится использование AsyncTask, так как у него есть довольно серьезные ограничения на многопоточность, и изображения, как правило, требуют много многопоточности. Таким образом, вместо этого я использую Executor и делаю что-то вроде этого (что, как вы заметили, использовали вышеописанный метод для выполнения фактической работы):

public Drawable getPreformattedFileAsync() {
    if(mItem == null) {
        Log.e(TAG, " -- ITEM is NULL!!");
        return(mErrorDrawable);
    }
    if(mFetchFileTask == null) {
        Log.e(TAG, " -- Task is Null!!, Need to start an executor");
        return(mErrorDrawable);
    }
    Runnable job = new Runnable() {
         public void run() {
             Thread.currentThread().setName("ImagePipeline");
             Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
             Thread.currentThread().yield();
             if(mItemDelegate != null) {
                 Drawable retDrawable = getPreformattedFile();
                 if(showAllDebugInformation) {
                     Log.w(TAG, "   ^^^^ Getting preformatted file size ["+retDrawable.getIntrinsicWidth()+"] x ["+retDrawable.getIntrinsicHeight()+"]");
                 }
                 if(retDrawable != null) {
                     Bitmap bm = ((BitmapDrawable) retDrawable).getBitmap();
                     // Log.w(TAG, "       Size of Bitmap is ["+(bm.getRowBytes()*bm.getHeight())+"]");
                     mItemDelegate.onDrawableRequest(mItem, retDrawable);
                     if(mBitmapManager != null) {
                         if(mBusyDrawable != null) {
                             mBitmapManager.recycleBitmap(((BitmapDrawable) mBusyDrawable).getBitmap());
                         }
                         if(mErrorDrawable != null) {
                             mBitmapManager.recycleBitmap(((BitmapDrawable) mErrorDrawable).getBitmap());
                         }
                     }
                 }  else  {
                     mItemDelegate.onDrawableRequest(mItem, mErrorDrawable);
                 }
             }
             // Log.i(TAG, "  RUNNABLE - Set the background");
         }
     };
     mImagePipelineTask.execute(job);
     return(mBusyDrawable);
}

Это, конечно, требует Исполнитель:

    private ExecutorService mImagePipelineTask = null;

Что может быть создано таким образом:

    mImagePipelineTask = Executors.newSingleThreadExecutor();

(Или, если вы предприимчивы, вы можете использовать многопоточный исполнитель, такую ​​же общую идею).

Возможно, это помогает уточнить.

Ответ 4

pager.setOffscreenPageLimit(MAX_PAGE);  //pager is the ViewPager instance

здесь MAX_PAGE - количество страниц, которые могут оставаться за пределами видимости. Любое дополнение к ним будет уничтожено и только воссоздается, когда пользователь переместится обратно в ближайшую позицию.