src/Tizen.NUI/src/internal/XamlBinding/ImageSource.cs

   1 using System;
   2 using System.IO;
   3 using System.Reflection;
   4 using System.Threading;
   5 using System.Threading.Tasks;
   6
   7 namespace Tizen.NUI.Binding
   8 {
   9     [TypeConverter(typeof(ImageSourceConverter))]
  10     internal abstract class ImageSource : Element
  11     {
  12         readonly object _synchandle = new object();
  13         CancellationTokenSource _cancellationTokenSource;
  14
  15         TaskCompletionSource<bool> _completionSource;
  16
  17         readonly WeakEventManager _weakEventManager = new WeakEventManager();
  18
  19         protected ImageSource()
  20         {
  21         }
  22
  23         protected CancellationTokenSource CancellationTokenSource
  24         {
  25             get { return _cancellationTokenSource; }
  26             private set
  27             {
  28                 if (_cancellationTokenSource == value)
  29                     return;
  30                 if (_cancellationTokenSource != null)
  31                     _cancellationTokenSource.Cancel();
  32                 _cancellationTokenSource = value;
  33             }
  34         }
  35
  36         bool IsLoading
  37         {
  38             get { return _cancellationTokenSource != null; }
  39         }
  40
  41         public virtual Task<bool> Cancel()
  42         {
  43             if (!IsLoading)
  44                 return Task.FromResult(false);
  45
  46             var tcs = new TaskCompletionSource<bool>();
  47             TaskCompletionSource<bool> original = Interlocked.CompareExchange(ref _completionSource, tcs, null);
  48             if (original == null)
  49             {
  50                 _cancellationTokenSource.Cancel();
  51             }
  52             else
  53                 tcs = original;
  54
  55             return tcs.Task;
  56         }
  57
  58         public static ImageSource FromFile(string file)
  59         {
  60             return new FileImageSource { File = file };
  61         }
  62
  63         public static ImageSource FromResource(string resource, Type resolvingType)
  64         {
  65             return FromResource(resource, resolvingType.GetTypeInfo().Assembly);
  66         }
  67
  68         public static ImageSource FromResource(string resource, Assembly sourceAssembly = null)
  69         {
  70 #if NETSTANDARD2_0
  71             sourceAssembly = sourceAssembly ?? Assembly.GetCallingAssembly();
  72 #else
  73             if (sourceAssembly == null)
  74             {
  75                 MethodInfo callingAssemblyMethod = typeof(Assembly).GetTypeInfo().GetDeclaredMethod("GetCallingAssembly");
  76                 if (callingAssemblyMethod != null)
  77                 {
  78                     sourceAssembly = (Assembly)callingAssemblyMethod.Invoke(null, new object[0]);
  79                 }
  80                 else
  81                 {
  82                     Internals.Log.Warning("Warning", "Can not find CallingAssembly, pass resolvingType to FromResource to ensure proper resolution");
  83                     return null;
  84                 }
  85             }
  86 #endif
  87             return FromStream(() => sourceAssembly.GetManifestResourceStream(resource));
  88         }
  89
  90         public static ImageSource FromStream(Func<Stream> stream)
  91         {
  92             // return new StreamImageSource { Stream = token => Task.Run(stream, token) };
  93             return null;
  94         }
  95
  96         public static ImageSource FromUri(Uri uri)
  97         {
  98             if (!uri.IsAbsoluteUri)
  99                 throw new ArgumentException("uri is relative");
 100             // return new UriImageSource { Uri = uri };
 101             return null;
 102         }
 103
 104         public static implicit operator ImageSource(string source)
 105         {
 106             Uri uri;
 107             return Uri.TryCreate(source, UriKind.Absolute, out uri) && uri.Scheme != "file" ? FromUri(uri) : FromFile(source);
 108         }
 109
 110         public static implicit operator ImageSource(Uri uri)
 111         {
 112             if (!uri.IsAbsoluteUri)
 113                 throw new ArgumentException("uri is relative");
 114             return FromUri(uri);
 115         }
 116
 117         protected void OnLoadingCompleted(bool cancelled)
 118         {
 119             if (!IsLoading || _completionSource == null)
 120                 return;
 121
 122             TaskCompletionSource<bool> tcs = Interlocked.Exchange(ref _completionSource, null);
 123             if (tcs != null)
 124                 tcs.SetResult(cancelled);
 125
 126             lock (_synchandle)
 127             {
 128                 CancellationTokenSource = null;
 129             }
 130         }
 131
 132         protected void OnLoadingStarted()
 133         {
 134             lock (_synchandle)
 135             {
 136                 CancellationTokenSource = new CancellationTokenSource();
 137             }
 138         }
 139
 140         protected void OnSourceChanged()
 141         {
 142             _weakEventManager.HandleEvent(this, EventArgs.Empty, nameof(SourceChanged));
 143         }
 144
 145         internal event EventHandler SourceChanged
 146         {
 147             add { _weakEventManager.AddEventHandler(nameof(SourceChanged), value); }
 148             remove { _weakEventManager.RemoveEventHandler(nameof(SourceChanged), value); }
 149         }
 150     }
 151 }