Я действительно застрял с этим.
Я читал эту статью из Google: https://developer.android.com/training/tv/playback/transport-controls#java
И они говорят, что я должен использовать этот класс, чтобы сделать вещи возможными:
https://developer.android.com/reference/androidx/leanback/widget/PlaybackSeekDataProvider.html
Я также посмотрел, например, здесь и смог реализовать все:
https://github.com/googlesamples/leanback-showcase
Вот что я получаю:
Исходный код ниже:
Вся логика помещена в два файла
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import androidx.leanback.media.PlaybackGlue;
import androidx.leanback.media.PlaybackTransportControlGlue;
import java.io.File;
/**
* Sample PlaybackSeekDataProvider that reads bitmaps stored on disk.
* e.g. new PlaybackSeekDiskDataProvider(duration, 1000, "/sdcard/frame_%04d.jpg")
* Expects the seek positions are 1000ms interval, snapshots are stored at
* /sdcard/frame_0001.jpg, ...
*/
public class PlaybackSeekDiskDataProvider extends PlaybackSeekAsyncDataProvider {
final Paint mPaint;
final String mPathPattern;
PlaybackSeekDiskDataProvider(long duration, long interval, String pathPattern) {
mPathPattern = pathPattern;
int size = (int) (duration / interval) + 1;
long[] pos = new long[size];
for (int i = 0; i < pos.length; i++) {
pos[i] = i * duration / pos.length;
}
setSeekPositions(pos);
mPaint = new Paint();
mPaint.setTextSize(16);
mPaint.setColor(Color.BLUE);
}
protected Bitmap doInBackground(Object task, int index, long position) {
try {
Thread.sleep(100);
} catch (InterruptedException ex) {
// Thread might be interrupted by cancel() call.
}
if (isCancelled(task)) {
return null;
}
String path = String.format(mPathPattern, (index + 1));
if (new File(path).exists()) {
return BitmapFactory.decodeFile(path);
} else {
Bitmap bmp = Bitmap.createBitmap(160, 160, Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(bmp);
canvas.drawColor(Color.YELLOW);
canvas.drawText(path, 10, 80, mPaint);
canvas.drawText(Integer.toString(index), 10, 150, mPaint);
return bmp;
}
}
/**
* Helper function to set a demo seek provider on PlaybackTransportControlGlue based on
* duration.
*/
public static void setDemoSeekProvider(final PlaybackTransportControlGlue glue) {
if (glue.isPrepared()) {
glue.setSeekProvider(new PlaybackSeekDiskDataProvider(
glue.getDuration(),
glue.getDuration() / 100,
"/sdcard/seek/frame_%04d.jpg"));
} else {
glue.addPlayerCallback(new PlaybackGlue.PlayerCallback() {
@Override
public void onPreparedStateChanged(PlaybackGlue glue) {
if (glue.isPrepared()) {
glue.removePlayerCallback(this);
PlaybackTransportControlGlue transportControlGlue =
(PlaybackTransportControlGlue) glue;
transportControlGlue.setSeekProvider(new PlaybackSeekDiskDataProvider(
transportControlGlue.getDuration(),
transportControlGlue.getDuration() / 100,
"/sdcard/seek/frame_%04d.jpg"));
}
}
});
}
}
}
и в этом:
import android.graphics.Bitmap;
import android.os.AsyncTask;
import android.util.Log;
import android.util.LruCache;
import android.util.SparseArray;
import androidx.leanback.widget.PlaybackSeekDataProvider;
import java.util.Iterator;
import java.util.Map;
public abstract class PlaybackSeekAsyncDataProvider extends PlaybackSeekDataProvider {
static final String TAG = "SeekAsyncProvider";
long[] mSeekPositions;
// mCache is for the bitmap requested by user
final LruCache<Integer, Bitmap> mCache;
// mPrefetchCache is for the bitmap not requested by user but prefetched by heuristic
// estimation. We use a different LruCache so that items in mCache will not be evicted by
// prefeteched items.
final LruCache<Integer, Bitmap> mPrefetchCache;
final SparseArray<LoadBitmapTask> mRequests = new SparseArray<>();
int mLastRequestedIndex = -1;
protected boolean isCancelled(Object task) {
return ((AsyncTask) task).isCancelled();
}
protected abstract Bitmap doInBackground(Object task, int index, long position);
class LoadBitmapTask extends AsyncTask<Object, Object, Bitmap> {
int mIndex;
ResultCallback mResultCallback;
LoadBitmapTask(int index, ResultCallback callback) {
mIndex = index;
mResultCallback = callback;
}
@Override
protected Bitmap doInBackground(Object[] params) {
return PlaybackSeekAsyncDataProvider.this
.doInBackground(this, mIndex, mSeekPositions[mIndex]);
}
@Override
protected void onPostExecute(Bitmap bitmap) {
mRequests.remove(mIndex);
Log.d(TAG, "thumb Loaded " + mIndex);
if (mResultCallback != null) {
mCache.put(mIndex, bitmap);
mResultCallback.onThumbnailLoaded(bitmap, mIndex);
} else {
mPrefetchCache.put(mIndex, bitmap);
}
}
}
public PlaybackSeekAsyncDataProvider() {
this(16, 24);
}
public PlaybackSeekAsyncDataProvider(int cacheSize, int prefetchCacheSize) {
mCache = new LruCache<Integer, Bitmap>(cacheSize);
mPrefetchCache = new LruCache<Integer, Bitmap>(prefetchCacheSize);
}
public void setSeekPositions(long[] positions) {
mSeekPositions = positions;
}
@Override
public long[] getSeekPositions() {
return mSeekPositions;
}
@Override
public void getThumbnail(int index, ResultCallback callback) {
Integer key = index;
Bitmap bitmap = mCache.get(key);
if (bitmap != null) {
callback.onThumbnailLoaded(bitmap, index);
} else {
bitmap = mPrefetchCache.get(key);
if (bitmap != null) {
mCache.put(key, bitmap);
mPrefetchCache.remove(key);
callback.onThumbnailLoaded(bitmap, index);
} else {
LoadBitmapTask task = mRequests.get(index);
if (task == null || task.isCancelled()) {
// no normal task or prefetch for the position, create a new task
task = new LoadBitmapTask(index, callback);
mRequests.put(index, task);
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
} else {
// update existing ResultCallback which might be normal task or prefetch
task.mResultCallback = callback;
}
}
}
if (mLastRequestedIndex != index) {
if (mLastRequestedIndex != -1) {
prefetch(mLastRequestedIndex, index > mLastRequestedIndex);
}
mLastRequestedIndex = index;
}
}
protected void prefetch(int hintIndex, boolean forward) {
for (Iterator<Map.Entry<Integer, Bitmap>> it =
mPrefetchCache.snapshot().entrySet().iterator(); it.hasNext(); ) {
Map.Entry<Integer, Bitmap> entry = it.next();
if (forward ? entry.getKey() < hintIndex : entry.getKey() > hintIndex) {
mPrefetchCache.remove(entry.getKey());
}
}
int inc = forward ? 1 : -1;
for (int i = hintIndex; (mRequests.size() + mPrefetchCache.size()
< mPrefetchCache.maxSize()) && (inc > 0 ? i < mSeekPositions.length : i >= 0);
i += inc) {
Integer key = i;
if (mCache.get(key) == null && mPrefetchCache.get(key) == null) {
LoadBitmapTask task = mRequests.get(i);
if (task == null) {
task = new LoadBitmapTask(key, null);
mRequests.put(i, task);
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
}
}
}
@Override
public void reset() {
for (int i = 0; i < mRequests.size(); i++) {
LoadBitmapTask task = mRequests.valueAt(i);
task.cancel(true);
}
mRequests.clear();
mCache.evictAll();
mPrefetchCache.evictAll();
mLastRequestedIndex = -1;
}
@Override
public String toString() {
StringBuilder b = new StringBuilder();
b.append("Requests<");
for (int i = 0; i < mRequests.size(); i++) {
b.append(mRequests.keyAt(i));
b.append(",");
}
b.append("> Cache<");
for (Iterator<Integer> it = mCache.snapshot().keySet().iterator(); it.hasNext();) {
Integer key = it.next();
if (mCache.get(key) != null) {
b.append(key);
b.append(",");
}
}
b.append(">");
b.append("> PrefetchCache<");
for (Iterator<Integer> it = mPrefetchCache.snapshot().keySet().iterator(); it.hasNext();) {
Integer key = it.next();
if (mPrefetchCache.get(key) != null) {
b.append(key);
b.append(",");
}
}
b.append(">");
return b.toString();
}
}
Я был бы очень признателен за помощь. Спасибо!