1 files changed, 160 insertions, 0 deletions
diff --git a/Juick/Storage/ImageCache.cs b/Juick/Storage/ImageCache.cs
new file mode 100644
index 0000000..e45dc62
--- /dev/null
+++ b/Juick/Storage/ImageCache.cs
@@ -0,0 +1,160 @@
+// Copyright 2010 Andreas Saudemont (andreas.saudemont@gmail.com)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Windows;
+using System.Windows.Media;
+
+namespace Kawagoe.Storage
+{
+    /// <summary>
+    /// Defines the base clase for image cache implementations.
+    /// </summary>
+    public abstract class ImageCache
+    {
+        /// <summary>
+        /// The name of the default image cache.
+        /// </summary>
+        public const string DefaultImageCacheName = "default";
+
+        private static ImageCache _defaultImageCache = null;
+        private static object _defaultImageCacheLock = new object();
+
+        /// <summary>
+        /// The default image cache.
+        /// If not set explicitely, a <see cref="PersistentImageCache"/> instance is used by default.
+        /// </summary>
+        public static ImageCache Default
+        {
+            get
+            {
+                if (!Deployment.Current.Dispatcher.CheckAccess())
+                {
+                    throw new UnauthorizedAccessException("invalid cross-thread access");
+                }
+                lock (_defaultImageCacheLock)
+                {
+                    if (_defaultImageCache == null)
+                    {
+                        _defaultImageCache = new PersistentImageCache(DefaultImageCacheName);
+                    }
+                    return _defaultImageCache;
+                }
+            }
+            set
+            {
+                if (!Deployment.Current.Dispatcher.CheckAccess())
+                {
+                    throw new UnauthorizedAccessException("invalid cross-thread access");
+                }
+                lock (_defaultImageCacheLock)
+                {
+                    _defaultImageCache = value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new <see cref="ImageCache"/> instance.
+        /// </summary>
+        protected ImageCache(string name)
+        {
+            if (string.IsNullOrEmpty(name))
+            {
+                throw new ArgumentException();
+            }
+            Name = name;
+        }
+
+        /// <summary>
+        /// The name of the image cache.
+        /// </summary>
+        protected string Name
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Retrieves the source for the image with the specified URI from the cache, downloading it
+        /// if needed.
+        /// </summary>
+        /// <param name="imageUri">The URI of the image. Must be an absolute URI.</param>
+        /// <returns>An ImageSource object, or <c>null</c> if <paramref name="imageUri"/> is <c>null</c> or not an absolute URI.</returns>
+        /// <exception cref="UnauthorizedAccessException">The method is not called in the UI thread.</exception>
+        public ImageSource Get(Uri imageUri)
+        {
+            if (!Deployment.Current.Dispatcher.CheckAccess())
+            {
+                throw new UnauthorizedAccessException("invalid cross-thread access");
+            }
+            if (imageUri == null || !imageUri.IsAbsoluteUri)
+            {
+                return null;
+            }
+            return GetInternal(imageUri);
+        }
+
+        /// <summary>
+        /// Retrieves the source for the image with the specified URI from the cache, downloading it
+        /// if needed.
+        /// </summary>
+        /// <param name="imageUriString">The URI of the image. Must be an absolute URI.</param>
+        /// <returns>An ImageSource object, or <c>null</c> if <paramref name="imageUriString"/> is <c>null</c>,
+        /// the empty string, or not an absolute URI.</returns>
+        /// <exception cref="UnauthorizedAccessException">The method is not called in the UI thread.</exception>
+        public ImageSource Get(string imageUriString)
+        {
+            if (!Deployment.Current.Dispatcher.CheckAccess())
+            {
+                throw new UnauthorizedAccessException("invalid cross-thread access");
+            }
+            if (string.IsNullOrEmpty(imageUriString))
+            {
+                return null;
+            }
+            Uri imageUri;
+            try
+            {
+                imageUri = new Uri(imageUriString, UriKind.Absolute);
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+            return Get(imageUri);
+        }
+
+        /// <summary>
+        /// The actual implementation of <see cref="ImageCache.Get"/>.
+        /// </summary>
+        protected abstract ImageSource GetInternal(Uri imageUri);
+
+        /// <summary>
+        /// Deletes all the images from the cache.
+        /// This method can block the current thread for a long time; it is advised to call it from
+        /// a background thread.
+        /// </summary>
+        public abstract void Clear();
+
+        /// <summary>
+        /// Overrides object.ToString().
+        /// </summary>
+        /// <returns></returns>
+        public override string ToString()
+        {
+            return string.Format("ImageCache:{0}", Name);
+        }
+    }
+}