public virtual void addListener(ImageListener listener, ImageErrorListener onError = null) { this._listeners.Add(new _ImageListenerPair { listener = listener, errorListener = onError }); if (this.currentImage != null) { try { listener(this.currentImage, true); } catch (Exception ex) { this.reportError( context: "by a synchronously-called image listener", exception: ex ); } } if (this.currentError != null && onError != null) { try { onError(this.currentError.exception); } catch (Exception ex) { UIWidgetsError.reportError( new UIWidgetsErrorDetails( exception: ex, library: "image resource service", context: "when reporting an error to an image listener" ) ); } } }
public ImageStreamCompleter putIfAbsent(object key, Func <ImageStreamCompleter> loader) { D.assert(key != null); D.assert(loader != null); if (this._pendingImages.TryGetValue(key, out var result)) { return(result); } if (this._cache.TryGetValue(key, out var image)) { // put to the MRU position this._lruKeys.Remove(image.node); image.node = this._lruKeys.AddLast(key); return(image.completer); } result = loader(); if (this._maximumSize > 0 && this._maximumSizeBytes > 0) { D.assert(!this._pendingImages.ContainsKey(key)); this._pendingImages[key] = result; ImageListener listener = null; listener = (info, syncCall) => { result.removeListener(listener); D.assert(this._pendingImages.ContainsKey(key)); this._pendingImages.Remove(key); int imageSize = info?.image == null ? 0 : info.image.width & (info.image.height * 4); _CachedImage cachedImage = new _CachedImage { completer = result, sizeBytes = imageSize, }; // If the image is bigger than the maximum cache size, and the cache size // is not zero, then increase the cache size to the size of the image plus // some change. if (this._maximumSizeBytes > 0 && imageSize > this._maximumSizeBytes) { this._maximumSizeBytes = imageSize + 1000; } this._currentSizeBytes += imageSize; D.assert(!this._cache.ContainsKey(key)); this._cache[key] = cachedImage; cachedImage.node = this._lruKeys.AddLast(key); this._checkCacheSize(); }; result.addListener(listener); } return(result); }
public _PendingImage( ImageStreamCompleter completer, ImageListener listener ) { this.completer = completer; this.listener = listener; }
public override void removeListener(ImageListener listener) { base.removeListener(listener); if (!this.hasListeners) { this._timer?.cancel(); this._timer = null; } }
public override void addListener(ImageListener listener, ImageErrorListener onError = null) { if (!this.hasListeners && this._codec != null) { this._decodeNextFrameAndSchedule(); } base.addListener(listener, onError: onError); }
public virtual void removeListener(ImageListener listener) { for (int i = 0; i < this._listeners.Count; i++) { if (this._listeners[i].listener == listener) { this._listeners.RemoveAt(i); break; } } }
public ImageStreamListener( ImageListener onImage, ImageChunkListener onChunk = null, ImageErrorListener onError = null ) { D.assert(onImage != null); this.onImage = onImage; this.onChunk = onChunk; this.onError = onError; }
public EmotionRecognizer(ImageListener listener) { detector = new PhotoDetector(3, FaceDetectorMode.SMALL_FACES); var classifierPath = @"D:\dev\AffdexSDK\data"; detector.setClassifierPath(classifierPath); detector.setDetectAllEmotions(true); detector.setImageListener(listener); detector.start(); }
public void addListener(ImageListener listener, ImageErrorListener onError = null) { if (this._completer != null) { this._completer.addListener(listener, onError); return; } if (this._listeners == null) { this._listeners = new List <_ImageListenerPair>(); } this._listeners.Add(new _ImageListenerPair { listener = listener, errorListener = onError }); }
public void removeListener(ImageListener listener) { if (this._completer != null) { this._completer.removeListener(listener); return; } D.assert(this._listeners != null); for (int i = 0; i < this._listeners.Count; i++) { if (this._listeners[i].listener == listener) { this._listeners.RemoveAt(i); break; } } }
public ImageModuleData([NotNull] ModuleDataConstructor constructor) : base(constructor.GetConfiguration <ImageConfiguration>()?.Topic ?? constructor.Topic, constructor.GetConfiguration <ImageConfiguration>()?.Type ?? constructor.Type) { panel = DataPanelManager.GetPanelByResourceType <ImagePanelContents>(ModuleType.Image); listener = new ImageListener(this); if (constructor.Configuration != null) { listener.Config = (ImageConfiguration)constructor.Configuration; } else { listener.Config.Topic = Topic; listener.Config.Type = Type; } listener.StartListening(); UpdateModuleButton(); }
private static async Task <Bitmap> InnerLoadImageAsync(CancellationToken ct, string uri, ImageView imageView, Size?targetSize, DisplayImageOptions options) { TaskCompletionSource <Bitmap> source = new TaskCompletionSource <Bitmap>(); options = options ?? new DisplayImageOptions.Builder() .CacheInMemory(true) .CacheOnDisk(true) .Build(); // Propagate cancellation to the managed TCS, even though we don't propagate it to Universal Image Loader. This is because UIL has // the air of cancelling downloads itself if another uri is requested for the same ImageView, leading us to wait on a task that // will never complete (thanks to the concurrency logic reusing existing tasks). using (ct.Register(() => source.TrySetCanceled())) { using (var aware = imageView != null ? new ImageViewAwareCancellable(imageView, ct) : null ) { using (var listener = new ImageListener(source)) { if (targetSize != null && imageView != null) { imageView.SetMaxHeight(targetSize.Value.Height); imageView.SetMaxWidth(targetSize.Value.Width); ImageLoader.Instance.DisplayImage( uri, aware, options, listener ); } else if (targetSize != null && imageView == null) { var targetImageSize = new ImageSize(targetSize.Value.Width, targetSize.Value.Height); ImageLoader.Instance.LoadImage( uri, targetImageSize, options, listener ); } else { ImageLoader.Instance.LoadImage( uri, options, listener ); } var target = await source.Task; return(target); } } } }