-
Notifications
You must be signed in to change notification settings - Fork 0
/
DataCache.swift
335 lines (258 loc) · 11.8 KB
/
DataCache.swift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
//
// Cache.swift
// CacheDemo
//
// Created by Nguyen Cong Huy on 7/4/16.
// Copyright © 2016 Nguyen Cong Huy. All rights reserved.
//
import UIKit
public enum ImageFormat {
case unknown, png, jpeg
}
open class DataCache {
static let cacheDirectoryPrefix = "com.nch.cache."
static let ioQueuePrefix = "com.nch.queue."
static let defaultMaxCachePeriodInSecond: TimeInterval = 60 * 60 * 24 * 7 // a week
open static var instance = DataCache(name: "default")
var cachePath: String
let memCache = NSCache<AnyObject, AnyObject>()
let ioQueue: DispatchQueue
let fileManager: FileManager
/// Name of cache
open var name: String = ""
/// Life time of disk cache, in second. Default is a week
open var maxCachePeriodInSecond = DataCache.defaultMaxCachePeriodInSecond
/// Size is allocated for disk cache, in byte. 0 mean no limit. Default is 0
open var maxDiskCacheSize: UInt = 0
/// Specify distinc name param, it represents folder name for disk cache
public init(name: String, path: String? = nil) {
self.name = name
cachePath = path ?? NSSearchPathForDirectoriesInDomains(.cachesDirectory, FileManager.SearchPathDomainMask.userDomainMask, true).first!
cachePath = (cachePath as NSString).appendingPathComponent(DataCache.cacheDirectoryPrefix + name)
ioQueue = DispatchQueue(label: DataCache.ioQueuePrefix + name)
self.fileManager = FileManager()
#if !os(OSX) && !os(watchOS)
NotificationCenter.default.addObserver(self, selector: #selector(DataCache.cleanExpiredDiskCache), name: NSNotification.Name.UIApplicationWillTerminate, object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(DataCache.cleanExpiredDiskCache), name: NSNotification.Name.UIApplicationDidEnterBackground, object: nil)
#endif
}
deinit {
NotificationCenter.default.removeObserver(self)
}
}
// MARK: Store data
extension DataCache {
/// Write data for key. This is an async operation.
public func write(data: Data, forKey key: String) {
memCache.setObject(data as AnyObject, forKey: key as AnyObject)
writeDataToDisk(data: data, key: key)
}
func writeDataToDisk(data: Data, key: String) {
ioQueue.async {
if self.fileManager.fileExists(atPath: self.cachePath) == false {
do {
try self.fileManager.createDirectory(atPath: self.cachePath, withIntermediateDirectories: true, attributes: nil)
}
catch {
print("Error while creating cache folder")
}
}
self.fileManager.createFile(atPath: self.cachePath(forKey: key), contents: data, attributes: nil)
}
}
/// Read data for key
public func readData(forKey key:String) -> Data? {
var data = memCache.object(forKey: key as AnyObject) as? Data
if data == nil {
if let dataFromDisk = readDataFromDisk(forKey: key) {
data = dataFromDisk
memCache.setObject(dataFromDisk as AnyObject, forKey: key as AnyObject)
}
}
return data
}
/// Read data from disk for key
public func readDataFromDisk(forKey key: String) -> Data? {
return self.fileManager.contents(atPath: cachePath(forKey: key))
}
// MARK: Read & write utils
/// Write an object for key. This object must inherit from `NSObject` and implement `NSCoding` protocol. `String`, `Array`, `Dictionary` conform to this method.
///
/// NOTE: Can't write `UIImage` with this method. Please use `writeImage(_:forKey:)` to write an image
public func write(object: NSCoding, forKey key: String) {
let data = NSKeyedArchiver.archivedData(withRootObject: object)
write(data: data, forKey: key)
}
/// Read an object for key. This object must inherit from `NSObject` and implement NSCoding protocol. `String`, `Array`, `Dictionary` conform to this method
public func readObject(forKey key: String) -> NSObject? {
let data = readData(forKey: key)
if let data = data {
return NSKeyedUnarchiver.unarchiveObject(with: data) as? NSObject
}
return nil
}
/// Read a string for key
public func readString(forKey key: String) -> String? {
return readObject(forKey: key) as? String
}
/// Read an array for key
public func readArray(forKey key: String) -> Array<Any>? {
return readObject(forKey: key) as? Array<Any>
}
/// Read a dictionary for key
public func readDictionary(forKey key: String) -> Dictionary<String, Any>? {
return readObject(forKey: key) as? Dictionary<String, Any>
}
// MARK: Read & write image
/// Write image for key. Please use this method to write an image instead of `writeObject(_:forKey:)`
public func write(image: UIImage, forKey key: String, format: ImageFormat? = nil) {
var data: Data? = nil
if let format = format, format == .png {
data = UIImagePNGRepresentation(image)
}
else {
data = UIImageJPEGRepresentation(image, 0.9)
}
if let data = data {
write(data: data, forKey: key)
}
}
/// Read image for key. Please use this method to write an image instead of `readObjectForKey(_:)`
public func readImageForKey(key: String) -> UIImage? {
let data = readData(forKey: key)
if let data = data {
return UIImage(data: data, scale: 1.0)
}
return nil
}
}
// MARK: Utils
extension DataCache {
/// Check if has data on disk
public func hasDataOnDiskForKey(key: String) -> Bool {
return self.fileManager.fileExists(atPath: self.cachePath(forKey: key))
}
/// Check if has data on mem
public func hasDataOnMemForKey(key: String) -> Bool {
return (memCache.object(forKey: key as AnyObject) != nil)
}
}
// MARK: Clean
extension DataCache {
/// Clean all mem cache and disk cache. This is an async operation.
public func cleanAll() {
cleanMemCache()
cleanDiskCache()
}
/// Clean cache by key. This is an async operation.
public func clean(byKey key: String) {
memCache.removeObject(forKey: key as AnyObject)
ioQueue.async {
do {
try self.fileManager.removeItem(atPath: self.cachePath(forKey: key))
} catch {}
}
}
public func cleanMemCache() {
memCache.removeAllObjects()
}
public func cleanDiskCache() {
ioQueue.async {
do {
try self.fileManager.removeItem(atPath: self.cachePath)
} catch {}
}
}
/// Clean expired disk cache. This is an async operation.
@objc public func cleanExpiredDiskCache() {
cleanExpiredDiskCacheWithCompletionHander(completionHandler: nil)
}
// This method is from Kingfisher
/**
Clean expired disk cache. This is an async operation.
- parameter completionHandler: Called after the operation completes.
*/
public func cleanExpiredDiskCacheWithCompletionHander(completionHandler: (()->())?) {
// Do things in cocurrent io queue
ioQueue.async(execute: { () -> Void in
var (URLsToDelete, diskCacheSize, cachedFiles) = self.travelCachedFiles()
for fileURL in URLsToDelete {
do {
try self.fileManager.removeItem(at: fileURL)
} catch {}
}
if self.maxDiskCacheSize > 0 && diskCacheSize > self.maxDiskCacheSize {
let targetSize = self.maxDiskCacheSize / 2
// Sort files by last modify date. We want to clean from the oldest files.
let sortedFiles = cachedFiles.keysSortedByValue {
resourceValue1, resourceValue2 -> Bool in
if let date1 = resourceValue1[URLResourceKey.contentModificationDateKey] as? Date,
let date2 = resourceValue2[URLResourceKey.contentModificationDateKey] as? Date {
return date1.compare(date2) == .orderedAscending
}
// Not valid date information. This should not happen. Just in case.
return true
}
for fileURL in sortedFiles {
do {
try self.fileManager.removeItem(at: fileURL)
} catch {}
URLsToDelete.append(fileURL)
if let fileSize = cachedFiles[fileURL]?[URLResourceKey.totalFileAllocatedSizeKey] as? NSNumber {
diskCacheSize -= fileSize.uintValue
}
if diskCacheSize < targetSize {
break
}
}
}
DispatchQueue.main.async(execute: { () -> Void in
completionHandler?()
})
})
}
}
// MARK: Helpers
extension DataCache {
// This method is from Kingfisher
fileprivate func travelCachedFiles() -> (URLsToDelete: [URL], diskCacheSize: UInt, cachedFiles: [URL: [URLResourceKey: Any]]) {
let diskCacheURL = URL(fileURLWithPath: cachePath)
let resourceKeys = [URLResourceKey.isDirectoryKey, URLResourceKey.contentModificationDateKey, URLResourceKey.totalFileAllocatedSizeKey]
let expiredDate = Date(timeIntervalSinceNow: -self.maxCachePeriodInSecond)
var cachedFiles = [URL: [URLResourceKey: Any]]()
var URLsToDelete = [URL]()
var diskCacheSize: UInt = 0
if let fileEnumerator = self.fileManager.enumerator(at: diskCacheURL, includingPropertiesForKeys: resourceKeys, options: FileManager.DirectoryEnumerationOptions.skipsHiddenFiles, errorHandler: nil),
let urls = fileEnumerator.allObjects as? [URL] {
for fileURL in urls {
do {
let bookmarkData = try fileURL.bookmarkData()
let resourceValues = URL.resourceValues(forKeys: Set(resourceKeys), fromBookmarkData: bookmarkData)?.allValues
// If it is a Directory. Continue to next file URL.
if let isDirectory = resourceValues?[URLResourceKey.isDirectoryKey] as? NSNumber {
if isDirectory.boolValue {
continue
}
}
// If this file is expired, add it to URLsToDelete
if let modificationDate = resourceValues?[URLResourceKey.contentModificationDateKey] as? NSDate {
if modificationDate.laterDate(expiredDate) == expiredDate {
URLsToDelete.append(fileURL)
continue
}
}
if let fileSize = resourceValues?[URLResourceKey.totalFileSizeKey] as? NSNumber {
diskCacheSize += fileSize.uintValue
cachedFiles[fileURL] = resourceValues
}
} catch _ {
}
}
}
return (URLsToDelete, diskCacheSize, cachedFiles)
}
func cachePath(forKey key: String) -> String {
let fileName = key.md5
return (cachePath as NSString).appendingPathComponent(fileName)
}
}