             cacheInWatch = ((options & KingfisherOptions.CacheInWatchApp) != KingfisherOptions.None)
             forceRefresh = ((options & KingfisherOptions.ForceRefresh) != KingfisherOptions.None)
         } else {
-            cacheInWatch = true
+            cacheInWatch = false
             forceRefresh = false
         }
         
-        let imageKey = URL.absoluteString?.kf_MD5()
-        if imageKey == nil {
+        let imageKey: String
+        if let URLString = URL.absoluteString {
+            imageKey = WKInterfaceImage.kf_hashForURLString(URLString)
+        } else {
             return (false, cacheInWatch)
         }
         
         if forceRefresh {
-            WKInterfaceDevice.currentDevice().removeCachedImageWithName(imageKey!)
-        }
-        
-        if WKInterfaceDevice.currentDevice().cachedImages[imageKey!] != nil {
+            WKInterfaceDevice.currentDevice().removeCachedImageWithName(imageKey)
+        }
+        
+        if WKInterfaceDevice.currentDevice().cachedImages[imageKey] != nil {
             
             dispatch_async(dispatch_get_main_queue(), { () -> Void in
-                self.setImageNamed(imageKey!)
+                self.setImageNamed(imageKey)
                 completionHandler?(error: nil, cacheType: .Watch, imageURL: URL, cachedInWatch: true)
             })
             
             return (true, cacheInWatch)
         }
- 
+        
         return (false, cacheInWatch)
     }
     
     private func kf_retrieveImageWithURL(URL: NSURL,
-                                 optionsInfo: KingfisherOptionsInfo?,
-                                cacheInWatch: Bool,
-                               progressBlock: DownloadProgressBlock?,
-                           completionHandler: WatchImageCompletionHandler?) -> RetrieveImageTask?
+        optionsInfo: KingfisherOptionsInfo?,
+        cacheInWatch: Bool,
+        progressBlock: DownloadProgressBlock?,
+        completionHandler: WatchImageCompletionHandler?) -> RetrieveImageTask?
     {
         let task = KingfisherManager.sharedManager.retrieveImageWithURL(URL, optionsInfo: optionsInfo, progressBlock: { (receivedSize, totalSize) -> () in
             if let progressBlock = progressBlock {

                    progressBlock(receivedSize: receivedSize, totalSize: totalSize)
                })
            }
        }) { (image, error, cacheType, imageURL) -> () in
            dispatch_async(dispatch_get_main_queue(), { () -> Void in
                var cachedInWatch: Bool = false
                
                if (imageURL == self.kf_webURL && image != nil) {
                    self.setImage(image)
                    
                    if cacheInWatch {
                        if let key = URL.absoluteString?.kf_MD5() {
                            cachedInWatch = WKInterfaceDevice.currentDevice().addCachedImage(image!, name: key)
                        }
                    }
                }
                
                completionHandler?(error: error, cacheType: cacheType, imageURL: imageURL, cachedInWatch: cachedInWatch)
            })
        }
        
        return task
    }
}

// MARK: - Associated Object
private var lastURLkey: Void?

        }
    }
    
    /**
    Set an image with a URL and a named image resource file as placeholder, options progress handler and completion handler.
    
    :param: URL               The URL of image.
    :param: name              The name of an image in WatchKit app bundle or the device-side cache.
    :param: optionsInfo       A dictionary could control some behaviors. See `KingfisherOptionsInfo` for more.
    :param: progressBlock     Called when the image downloading progress gets updated.
    :param: completionHandler Called when the image retrieved and set.
    
    :returns: A task represents the retriving process or `nil` if device cache is used.
    */
    public func kf_setImageWithURL(URL: NSURL,
            placeholderImageNamed name: String?,
                           optionsInfo: KingfisherOptionsInfo?,
