void ProduceResultsInternal(IConsumer <T> consumer, IProducerContext producerContext)
{
IProducerListener producerListener = producerContext.Listener;
producerListener.OnProducerFinishWithSuccess(producerContext.Id, PRODUCER_NAME, null);
_inputProducer.ProduceResults(new ThrottlerConsumer(this, consumer), producerContext);
}
/// <summary>
/// Called after computing result successfully.
/// </summary>
protected override void OnSuccess(T result)
{
_producerListener.OnProducerFinishWithSuccess(
_requestId,
_producerName,
_producerListener.RequiresExtraMap(_requestId) ? GetExtraMapOnSuccess(result) : null);
_consumer.OnNewResult(result, true);
}
/// <summary>
/// Performs the decode synchronously.
/// </summary>
private async Task DoDecode(EncodedImage encodedImage, bool isLast)
{
if (IsFinished() || !EncodedImage.IsValid(encodedImage))
{
return;
}
try
{
long queueTime = _jobScheduler.GetQueuedTime();
int length = isLast ?
encodedImage.Size : GetIntermediateImageEndOffset(encodedImage);
if (length == 0)
{
return;
}
IQualityInfo quality = isLast ? ImmutableQualityInfo.FULL_QUALITY : GetQualityInfo();
_producerListener.OnProducerStart(_producerContext.Id, PRODUCER_NAME);
CloseableImage image = null;
try
{
image = await _parent._imageDecoder
.DecodeImageAsync(encodedImage, length, quality, _imageDecodeOptions)
.ConfigureAwait(false);
}
catch (Exception e)
{
_producerListener.OnProducerFinishWithFailure(
_producerContext.Id,
PRODUCER_NAME,
e,
GetExtraMap(image, queueTime, quality, isLast));
HandleError(e);
return;
}
_producerListener.OnProducerFinishWithSuccess(
_producerContext.Id,
PRODUCER_NAME,
GetExtraMap(image, queueTime, quality, isLast));
HandleResult(image, isLast);
}
finally
{
EncodedImage.CloseSafely(encodedImage);
}
}
/// <summary>
/// Start producing results for given context.
/// Provided consumer is notified whenever progress is made
/// (new value is ready or error occurs).
/// </summary>
public void ProduceResults(IConsumer <T> consumer, IProducerContext context)
{
IProducerListener producerListener = context.Listener;
string requestId = context.Id;
StatefulProducerRunnable <T> statefulRunnable = new StatefulProducerRunnableImpl <T>(
consumer,
producerListener,
PRODUCER_NAME,
requestId,
(T ignored) =>
{
producerListener.OnProducerFinishWithSuccess(requestId, PRODUCER_NAME, null);
_inputProducer.ProduceResults(consumer, context);
},
null,
null,
(_) =>
{
return(default(IDictionary <string, string>));
},
(_) =>
{
return(default(IDictionary <string, string>));
},
() =>
{
return(default(IDictionary <string, string>));
},
null,
() =>
{
return(Task.FromResult(default(T)));
});
context.AddCallbacks(
new BaseProducerContextCallbacks(
() =>
{
statefulRunnable.Cancel();
_threadHandoffProducerQueue.Remove(statefulRunnable.Runnable);
},
() => { },
() => { },
() => { }));
_threadHandoffProducerQueue.AddToQueueOrExecute(statefulRunnable.Runnable);
}
private void DoPostprocessing(
CloseableReference <CloseableImage> sourceImageRef,
bool isLast)
{
Preconditions.CheckArgument(CloseableReference <CloseableImage> .IsValid(sourceImageRef));
if (!ShouldPostprocess(sourceImageRef.Get()))
{
MaybeNotifyOnNewResult(sourceImageRef, isLast);
return;
}
_listener.OnProducerStart(_requestId, NAME);
CloseableReference <CloseableImage> destImageRef = null;
try
{
try
{
destImageRef = PostprocessInternal(sourceImageRef.Get());
}
catch (Exception e)
{
_listener.OnProducerFinishWithFailure(
_requestId, NAME, e, GetExtraMap(_listener, _requestId, _postprocessor));
MaybeNotifyOnFailure(e);
return;
}
_listener.OnProducerFinishWithSuccess(
_requestId, NAME, GetExtraMap(_listener, _requestId, _postprocessor));
MaybeNotifyOnNewResult(destImageRef, isLast);
}
finally
{
CloseableReference <CloseableImage> .CloseSafely(destImageRef);
}
}
/// <summary>
/// Start producing results for given context.
/// Provided consumer is notified whenever progress is made
/// (new value is ready or error occurs).
/// </summary>
public void ProduceResults(
IConsumer <CloseableReference <CloseableImage> > consumer,
IProducerContext producerContext)
{
IProducerListener listener = producerContext.Listener;
string requestId = producerContext.Id;
listener.OnProducerStart(requestId, ProducerName);
ImageRequest imageRequest = producerContext.ImageRequest;
object callerContext = producerContext.CallerContext;
ICacheKey cacheKey = _cacheKeyFactory.GetBitmapCacheKey(imageRequest, callerContext);
IDictionary <string, string> extraMap = default(IDictionary <string, string>);
CloseableReference <CloseableImage> cachedReference = _memoryCache.Get(cacheKey);
if (cachedReference != null)
{
bool isFinal = cachedReference.Get().QualityInfo.IsOfFullQuality;
if (isFinal)
{
extraMap = new Dictionary <string, string>()
{
{ VALUE_FOUND, "true" }
};
listener.OnProducerFinishWithSuccess(
requestId,
ProducerName,
listener.RequiresExtraMap(requestId) ?
new ReadOnlyDictionary <string, string>(extraMap) :
null);
consumer.OnProgressUpdate(1f);
}
consumer.OnNewResult(cachedReference, isFinal);
cachedReference.Dispose();
if (isFinal)
{
return;
}
}
if (producerContext.LowestPermittedRequestLevel >= RequestLevel.BITMAP_MEMORY_CACHE)
{
extraMap = new Dictionary <string, string>()
{
{ VALUE_FOUND, "false" }
};
listener.OnProducerFinishWithSuccess(
requestId,
ProducerName,
listener.RequiresExtraMap(requestId) ?
new ReadOnlyDictionary <string, string>(extraMap) :
null);
consumer.OnNewResult(null, true);
return;
}
extraMap = new Dictionary <string, string>()
{
{ VALUE_FOUND, "false" }
};
IConsumer <CloseableReference <CloseableImage> > wrappedConsumer =
WrapConsumer(consumer, cacheKey);
listener.OnProducerFinishWithSuccess(
requestId,
ProducerName,
listener.RequiresExtraMap(requestId) ?
new ReadOnlyDictionary <string, string>(extraMap) :
null);
_inputProducer.ProduceResults(wrappedConsumer, producerContext);
}
/// <summary>
/// Start producing results for given context.
/// Provided consumer is notified whenever progress is made
/// (new value is ready or error occurs).
/// </summary>
public void ProduceResults(
IConsumer <CloseableReference <CloseableImage> > consumer,
IProducerContext producerContext)
{
IProducerListener listener = producerContext.Listener;
string requestId = producerContext.Id;
ImageRequest imageRequest = producerContext.ImageRequest;
object callerContext = producerContext.CallerContext;
// If there's no postprocessor or the postprocessor doesn't
// require caching, forward results.
IPostprocessor postprocessor = imageRequest.Postprocessor;
if (postprocessor == null || postprocessor.PostprocessorCacheKey == null)
{
_inputProducer.ProduceResults(consumer, producerContext);
return;
}
listener.OnProducerStart(requestId, ProducerName);
ICacheKey cacheKey = _cacheKeyFactory.GetPostprocessedBitmapCacheKey(
imageRequest, callerContext);
CloseableReference <CloseableImage> cachedReference = _memoryCache.Get(cacheKey);
var extraMap = default(Dictionary <string, string>);
if (cachedReference != null)
{
extraMap = new Dictionary <string, string>()
{
{ VALUE_FOUND, "true" }
};
listener.OnProducerFinishWithSuccess(
requestId,
ProducerName,
listener.RequiresExtraMap(requestId) ?
new ReadOnlyDictionary <string, string>(extraMap) :
null);
consumer.OnProgressUpdate(1.0f);
consumer.OnNewResult(cachedReference, true);
cachedReference.Dispose();
}
else
{
bool isRepeatedProcessor = postprocessor.GetType() == typeof(IRepeatedPostprocessor);
IConsumer <CloseableReference <CloseableImage> > cachedConsumer =
new CachedPostprocessorConsumer(
consumer,
cacheKey,
isRepeatedProcessor,
_memoryCache);
extraMap = new Dictionary <string, string>()
{
{ VALUE_FOUND, "false" }
};
listener.OnProducerFinishWithSuccess(
requestId,
ProducerName,
listener.RequiresExtraMap(requestId) ?
new ReadOnlyDictionary <string, string>(extraMap) :
null);
_inputProducer.ProduceResults(cachedConsumer, producerContext);
}
}
/// <summary>
/// Start producing results for given context.
/// Provided consumer is notified whenever progress is made
/// (new value is ready or error occurs).
/// </summary>
public void ProduceResults(
IConsumer <EncodedImage> consumer,
IProducerContext producerContext)
{
string requestId = producerContext.Id;
IProducerListener listener = producerContext.Listener;
listener.OnProducerStart(requestId, PRODUCER_NAME);
ImageRequest imageRequest = producerContext.ImageRequest;
ICacheKey cacheKey = _cacheKeyFactory.GetEncodedCacheKey(
imageRequest, producerContext.CallerContext);
CloseableReference <IPooledByteBuffer> cachedReference = _memoryCache.Get(cacheKey);
IDictionary <string, string> extraMap = default(IDictionary <string, string>);
try
{
if (cachedReference != null)
{
EncodedImage cachedEncodedImage = new EncodedImage(cachedReference);
try
{
extraMap = new Dictionary <string, string>()
{
{ VALUE_FOUND, "true" }
};
listener.OnProducerFinishWithSuccess(
requestId,
PRODUCER_NAME,
listener.RequiresExtraMap(requestId) ?
new ReadOnlyDictionary <string, string>(extraMap) :
null);
consumer.OnProgressUpdate(1f);
consumer.OnNewResult(cachedEncodedImage, true);
return;
}
finally
{
EncodedImage.CloseSafely(cachedEncodedImage);
}
}
if (producerContext.LowestPermittedRequestLevel >= RequestLevel.ENCODED_MEMORY_CACHE)
{
extraMap = new Dictionary <string, string>()
{
{ VALUE_FOUND, "false" }
};
listener.OnProducerFinishWithSuccess(
requestId,
PRODUCER_NAME,
listener.RequiresExtraMap(requestId) ?
new ReadOnlyDictionary <string, string>(extraMap) :
null);
consumer.OnNewResult(null, true);
return;
}
IConsumer <EncodedImage> consumerOfInputProducer =
new EncodedMemoryCacheConsumer(_memoryCache, consumer, cacheKey);
extraMap = new Dictionary <string, string>()
{
{ VALUE_FOUND, "false" }
};
listener.OnProducerFinishWithSuccess(
requestId,
PRODUCER_NAME,
listener.RequiresExtraMap(requestId) ?
new ReadOnlyDictionary <string, string>(extraMap) :
null);
_inputProducer.ProduceResults(consumerOfInputProducer, producerContext);
}
finally
{
CloseableReference <IPooledByteBuffer> .CloseSafely(cachedReference);
}
}
private void OnFinishDiskReads(
Task <EncodedImage> task,
IConsumer <EncodedImage> consumer,
BufferedDiskCache preferredCache,
ICacheKey preferredCacheKey,
IProducerContext producerContext)
{
string requestId = producerContext.Id;
IProducerListener listener = producerContext.Listener;
if (IsTaskCancelled(task))
{
listener.OnProducerFinishWithCancellation(requestId, PRODUCER_NAME, null);
consumer.OnCancellation();
}
else if (task.IsFaulted)
{
listener.OnProducerFinishWithFailure(requestId, PRODUCER_NAME, task.Exception, null);
MaybeStartInputProducer(
consumer,
new DiskCacheConsumer(
_defaultBufferedDiskCache,
_smallImageBufferedDiskCache,
_chooseCacheByImageSize,
_forceSmallCacheThresholdBytes,
consumer,
preferredCache,
preferredCacheKey),
producerContext);
}
else
{
EncodedImage cachedReference = task.Result;
if (cachedReference != null)
{
listener.OnProducerFinishWithSuccess(
requestId,
PRODUCER_NAME,
GetExtraMap(listener, requestId, true));
consumer.OnProgressUpdate(1);
consumer.OnNewResult(cachedReference, true);
cachedReference.Dispose();
}
else
{
listener.OnProducerFinishWithSuccess(
requestId,
PRODUCER_NAME,
GetExtraMap(listener, requestId, false));
MaybeStartInputProducer(
consumer,
new DiskCacheConsumer(
_defaultBufferedDiskCache,
_smallImageBufferedDiskCache,
_chooseCacheByImageSize,
_forceSmallCacheThresholdBytes,
consumer,
preferredCache,
preferredCacheKey),
producerContext);
}
}
}