OpenTween/ImageCache.cs

   1 // OpenTween - Client of Twitter
   2 // Copyright (c) 2013 kim_upsilon (@kim_upsilon) <https://upsilo.net/~upsilon/>
   3 // All rights reserved.
   4 //
   5 // This file is part of OpenTween.
   6 //
   7 // This program is free software; you can redistribute it and/or modify it
   8 // under the terms of the GNU General Public License as published by the Free
   9 // Software Foundation; either version 3 of the License, or (at your option)
  10 // any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14 // or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  15 // for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License along
  18 // with this program. If not, see <http://www.gnu.org/licenses/>, or write to
  19 // the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
  20 // Boston, MA 02110-1301, USA.
  21
  22 #nullable enable
  23
  24 using System;
  25 using System.Collections.Generic;
  26 using System.Linq;
  27 using System.Net;
  28 using System.Net.Http;
  29 using System.Text;
  30 using System.Threading;
  31 using System.Threading.Tasks;
  32 using System.Xml.Serialization;
  33 using OpenTween.Connection;
  34
  35 namespace OpenTween
  36 {
  37     public class ImageCache : IDisposable
  38     {
  39         /// <summary>
  40         /// キャッシュとして URL と取得した画像を対に保持する辞書
  41         /// </summary>
  42         internal LRUCacheDictionary<string, Task<MemoryImage>> InnerDictionary;
  43
  44         /// <summary>
  45         /// 非同期タスクをキャンセルするためのトークンのもと
  46         /// </summary>
  47         private CancellationTokenSource cancelTokenSource;
  48
  49         /// <summary>
  50         /// innerDictionary の排他制御のためのロックオブジェクト
  51         /// </summary>
  52         private readonly object lockObject = new object();
  53
  54         /// <summary>
  55         /// オブジェクトが破棄された否か
  56         /// </summary>
  57         private bool disposed = false;
  58
  59         public ImageCache()
  60         {
  61             this.InnerDictionary = new LRUCacheDictionary<string, Task<MemoryImage>>(trimLimit: 300, autoTrimCount: 100);
  62             this.InnerDictionary.CacheRemoved += (s, e) =>
  63             {
  64                 // まだ参照されている場合もあるのでDisposeはファイナライザ任せ
  65                 this.CacheRemoveCount++;
  66             };
  67
  68             this.cancelTokenSource = new CancellationTokenSource();
  69         }
  70
  71         /// <summary>
  72         /// 保持しているキャッシュの件数
  73         /// </summary>
  74         public long CacheCount
  75             => this.InnerDictionary.Count;
  76
  77         /// <summary>
  78         /// 破棄されたキャッシュの件数
  79         /// </summary>
  80         public int CacheRemoveCount { get; private set; }
  81
  82         /// <summary>
  83         /// 指定された URL にある画像を非同期に取得するメソッド
  84         /// </summary>
  85         /// <param name="address">取得先の URL</param>
  86         /// <param name="force">キャッシュを使用せずに取得する場合は true</param>
  87         /// <returns>非同期に画像を取得するタスク</returns>
  88         public Task<MemoryImage> DownloadImageAsync(string address, bool force = false)
  89         {
  90             var cancelToken = this.cancelTokenSource.Token;
  91
  92             return Task.Run(() =>
  93             {
  94                 lock (this.lockObject)
  95                 {
  96                     this.InnerDictionary.TryGetValue(address, out var cachedImageTask);
  97
  98                     if (cachedImageTask != null)
  99                     {
 100                         if (force)
 101                             this.InnerDictionary.Remove(address);
 102                         else
 103                             return cachedImageTask;
 104                     }
 105
 106                     cancelToken.ThrowIfCancellationRequested();
 107
 108                     var imageTask = this.FetchImageAsync(address, cancelToken);
 109                     this.InnerDictionary[address] = imageTask;
 110
 111                     return imageTask;
 112                 }
 113             },
 114             cancelToken);
 115         }
 116
 117         private async Task<MemoryImage> FetchImageAsync(string uri, CancellationToken cancelToken)
 118         {
 119             using var response = await Networking.Http.GetAsync(uri, cancelToken)
 120                 .ConfigureAwait(false);
 121
 122             response.EnsureSuccessStatusCode();
 123
 124             using var imageStream = await response.Content.ReadAsStreamAsync()
 125                 .ConfigureAwait(false);
 126
 127             return await MemoryImage.CopyFromStreamAsync(imageStream)
 128                 .ConfigureAwait(false);
 129         }
 130
 131         public MemoryImage? TryGetFromCache(string address)
 132         {
 133             lock (this.lockObject)
 134             {
 135                 if (!this.InnerDictionary.TryGetValue(address, out var imageTask) ||
 136                     imageTask.Status != TaskStatus.RanToCompletion)
 137                     return null;
 138
 139                 return imageTask.Result;
 140             }
 141         }
 142
 143         public void CancelAsync()
 144         {
 145             lock (this.lockObject)
 146             {
 147                 var oldTokenSource = this.cancelTokenSource;
 148                 this.cancelTokenSource = new CancellationTokenSource();
 149
 150                 oldTokenSource.Cancel();
 151                 oldTokenSource.Dispose();
 152             }
 153         }
 154
 155         protected virtual void Dispose(bool disposing)
 156         {
 157             if (this.disposed) return;
 158
 159             if (disposing)
 160             {
 161                 this.CancelAsync();
 162
 163                 lock (this.lockObject)
 164                 {
 165                     foreach (var (_, task) in this.InnerDictionary)
 166                     {
 167                         if (task.Status == TaskStatus.RanToCompletion)
 168                             task.Result?.Dispose();
 169                     }
 170
 171                     this.InnerDictionary.Clear();
 172                     this.cancelTokenSource.Dispose();
 173                 }
 174             }
 175
 176             this.disposed = true;
 177         }
 178
 179         public void Dispose()
 180         {
 181             this.Dispose(true);
 182             GC.SuppressFinalize(this);
 183         }
 184
 185         ~ImageCache()
 186             => this.Dispose(false);
 187     }
 188 }