Java ResourceCallback类代码示例

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
@Synthetic
void handleExceptionOnMainThread() {
  stateVerifier.throwIfRecycled();
  if (isCancelled) {
    release(false /*isRemovedFromQueue*/);
    return;
  } else if (cbs.isEmpty()) {
    throw new IllegalStateException("Received an exception without any callbacks to notify");
  } else if (hasLoadFailed) {
    throw new IllegalStateException("Already failed once");
  }
  hasLoadFailed = true;

  listener.onEngineJobComplete(key, null);

  for (ResourceCallback cb : cbs) {
    if (!isInIgnoredCallbacks(cb)) {
      cb.onLoadFailed(exception);
    }
  }

  release(false /*isRemovedFromQueue*/);
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
@Test
public void testNotifiesNewCallbackOfResourceIfCallbackIsAddedDuringOnResourceReady() {
  final EngineJob<Object> job = harness.getJob();
  final ResourceCallback existingCallback = mock(ResourceCallback.class);
  final ResourceCallback newCallback = mock(ResourceCallback.class);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      job.addCallback(newCallback);
      return null;
    }
  }).when(existingCallback).onResourceReady(anyResource(), isADataSource());

  job.addCallback(existingCallback);
  job.start(harness.decodeJob);
  job.onResourceReady(harness.resource, harness.dataSource);

  verify(newCallback).onResourceReady(eq(harness.engineResource), eq(harness.dataSource));
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
@Test
public void testNotifiesNewCallbackOfExceptionIfCallbackIsAddedDuringOnException() {
  harness = new EngineJobHarness();
  final EngineJob<Object> job = harness.getJob();
  final ResourceCallback existingCallback = mock(ResourceCallback.class);
  final ResourceCallback newCallback = mock(ResourceCallback.class);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      job.addCallback(newCallback);
      return null;
    }
  }).when(existingCallback).onLoadFailed(any(GlideException.class));

  GlideException exception = new GlideException("test");
  job.addCallback(existingCallback);
  job.start(harness.decodeJob);
  job.onLoadFailed(exception);

  verify(newCallback).onLoadFailed(eq(exception));
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
@Test
public void testRemovingCallbackDuringOnResourceReadyIsIgnoredIfCallbackHasAlreadyBeenCalled() {
  final EngineJob<Object> job = harness.getJob();
  final ResourceCallback cb = mock(ResourceCallback.class);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      job.removeCallback(cb);
      return null;
    }
  }).when(cb).onResourceReady(anyResource(), isADataSource());

  job.addCallback(cb);
  job.start(harness.decodeJob);
  job.onResourceReady(harness.resource, harness.dataSource);

  verify(cb, times(1)).onResourceReady(anyResource(), isADataSource());
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
@Test
public void testRemovingCallbackDuringOnExceptionIsIgnoredIfCallbackHasAlreadyBeenCalled() {
  harness = new EngineJobHarness();
  final EngineJob<Object> job = harness.getJob();
  final ResourceCallback cb = mock(ResourceCallback.class);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      job.removeCallback(cb);
      return null;
    }
  }).when(cb).onLoadFailed(any(GlideException.class));

  GlideException exception = new GlideException("test");
  job.addCallback(cb);
  job.start(harness.decodeJob);
  job.onLoadFailed(exception);

  verify(cb, times(1)).onLoadFailed(eq(exception));
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
@Test
public void
testRemovingCallbackDuringOnResourceReadyPreventsCallbackFromBeingCalledIfNotYetCalled() {
  final EngineJob<Object> job = harness.getJob();
  final ResourceCallback notYetCalled = mock(ResourceCallback.class);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      job.removeCallback(notYetCalled);
      return null;
    }
  }).when(harness.cb).onResourceReady(anyResource(), isADataSource());

  job.addCallback(notYetCalled);
  job.start(harness.decodeJob);
  job.onResourceReady(harness.resource, harness.dataSource);

  verify(notYetCalled, never()).onResourceReady(anyResource(), isADataSource());
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
@Test
public void
testRemovingCallbackDuringOnResourceReadyPreventsResourceFromBeingAcquiredForCallback() {
  final EngineJob<Object> job = harness.getJob();
  final ResourceCallback notYetCalled = mock(ResourceCallback.class);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      job.removeCallback(notYetCalled);
      return null;
    }
  }).when(harness.cb).onResourceReady(anyResource(), isADataSource());

  job.addCallback(notYetCalled);
  job.start(harness.decodeJob);

  job.onResourceReady(harness.resource, harness.dataSource);

  // Once for notifying, once for called.
  verify(harness.engineResource, times(2)).acquire();
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
@Test
public void testRemovingCallbackDuringOnExceptionPreventsCallbackFromBeingCalledIfNotYetCalled() {
  harness = new EngineJobHarness();
  final EngineJob<Object> job = harness.getJob();
  final ResourceCallback called = mock(ResourceCallback.class);
  final ResourceCallback notYetCalled = mock(ResourceCallback.class);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      job.removeCallback(notYetCalled);
      return null;
    }
  }).when(called).onLoadFailed(any(GlideException.class));

  job.addCallback(called);
  job.addCallback(notYetCalled);
  job.start(harness.decodeJob);
  job.onLoadFailed(new GlideException("test"));

  verify(notYetCalled, never()).onResourceReady(anyResource(), isADataSource());
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
public MultiCbHarness() {
  when(factory.build(eq(resource), eq(isCacheable))).thenReturn(engineResource);
  job =
      new EngineJob<>(
          diskCacheService,
          sourceService,
          sourceUnlimitedService,
          animationService,
          listener,
          pool,
          factory).init(key, isCacheable, useUnlimitedSourceGeneratorPool, useAnimationPool);
  for (int i = 0; i < numCbs; i++) {
    cbs.add(mock(ResourceCallback.class));
  }
  for (ResourceCallback cb : cbs) {
    job.addCallback(cb);
  }
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
@Override
public void onException(final Exception e) {
    mainHandler.post(new Runnable() {
        @Override
        public void run() {
            if (isCancelled) {
                return;
            }
            isComplete = true;

            listener.onEngineJobComplete(key);
            for (ResourceCallback cb : cbs) {
                cb.onException(e);
            }
        }
    });
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
public void addCallback(ResourceCallback cb) {
  Util.assertMainThread();
  stateVerifier.throwIfRecycled();
  if (hasResource) {
    cb.onResourceReady(engineResource, dataSource);
  } else if (hasLoadFailed) {
    cb.onLoadFailed(exception);
  } else {
    cbs.add(cb);
  }
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
public void removeCallback(ResourceCallback cb) {
  Util.assertMainThread();
  stateVerifier.throwIfRecycled();
  if (hasResource || hasLoadFailed) {
    addIgnoredCallback(cb);
  } else {
    cbs.remove(cb);
    if (cbs.isEmpty()) {
      cancel();
    }
  }
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
private void addIgnoredCallback(ResourceCallback cb) {
  if (ignoredCallbacks == null) {
    ignoredCallbacks = new ArrayList<>(2);
  }
  if (!ignoredCallbacks.contains(cb)) {
    ignoredCallbacks.add(cb);
  }
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
@Synthetic
void handleResultOnMainThread() {
  stateVerifier.throwIfRecycled();
  if (isCancelled) {
    resource.recycle();
    release(false /*isRemovedFromQueue*/);
    return;
  } else if (cbs.isEmpty()) {
    throw new IllegalStateException("Received a resource without any callbacks to notify");
  } else if (hasResource) {
    throw new IllegalStateException("Already have resource");
  }
  engineResource = engineResourceFactory.build(resource, isCacheable);
  hasResource = true;

  // Hold on to resource for duration of request so we don't recycle it in the middle of
  // notifying if it synchronously released by one of the callbacks.
  engineResource.acquire();
  listener.onEngineJobComplete(key, engineResource);

  for (ResourceCallback cb : cbs) {
    if (!isInIgnoredCallbacks(cb)) {
      engineResource.acquire();
      cb.onResourceReady(engineResource, dataSource);
    }
  }
  // Our request is complete, so we can release the resource.
  engineResource.release();

  release(false /*isRemovedFromQueue*/);
}
 

import com.bumptech.glide.request.ResourceCallback; //导入依赖的package包/类
@Test
public void testCallbackIsAddedToExistingRunnerWithExistingLoad() {
  harness.doLoad();

  ResourceCallback newCallback = mock(ResourceCallback.class);
  harness.cb = newCallback;
  harness.doLoad();

  verify(harness.job).addCallback(eq(newCallback));
}