解决了语音上传到问题，接下来要解决下载播放问题

Pods/Qiniu/QiniuSDK/Utils/QNCache.m

@@ -0,0 +1,193 @@
+//
+//  QNCache.m
+//  QiniuSDK
+//
+//  Created by yangsen on 2023/9/20.
+//  Copyright © 2023 Qiniu. All rights reserved.
+//
+
+#import "QNCache.h"
+#import "QNAsyncRun.h"
+#import "QNUtils.h"
+#import "QNFileRecorder.h"
+
+@implementation QNCacheOption
+- (instancetype)init {
+    if (self = [super init]) {
+        self.flushCount = 1;
+    }
+    return self;
+}
+
+- (NSString *)version {
+    if (_version == nil || _version.length == 0) {
+        _version = @"v1.0.0";
+    }
+    return _version;
+}
+@end
+
+@interface QNCache()
+
+@property (nonatomic, strong) Class objectClass;
+@property (nonatomic, strong) QNCacheOption *option;
+@property (nonatomic, strong) QNFileRecorder *diskCache;
+@property (nonatomic, assign) BOOL isFlushing;
+@property (nonatomic, assign) int needFlushCount;
+@property (nonatomic, strong) NSMutableDictionary<NSString *, id <QNCacheObject>> *memCache;
+
+@end
+@implementation QNCache
+
++ (instancetype)cache:(Class)objectClass option:(QNCacheOption *)option {
+    QNCache *cache = [[QNCache alloc] init];
+    cache.objectClass = objectClass;
+    cache.option = option ? option : [[QNCacheOption alloc] init];
+    cache.isFlushing = false;
+    cache.needFlushCount = 0;
+    cache.memCache = [[NSMutableDictionary alloc] init];
+    NSString *path = [[QNUtils sdkCacheDirectory] stringByAppendingFormat:@"/%@", objectClass];
+    cache.diskCache = [QNFileRecorder fileRecorderWithFolder:path error:nil];
+    [cache load];
+    return cache;
+}
+
+- (void)load {
+    if (![self.objectClass conformsToProtocol:@protocol(QNCacheObject)]) {
+        return;
+    }
+    
+    NSData *data = nil;
+    @synchronized (self) {
+        data = [self.diskCache get:self.option.version];
+    }
+    if (data == nil) {
+        return;
+    }
+    
+    NSError *error = nil;
+    NSDictionary *cacheDict = [NSJSONSerialization JSONObjectWithData:data
+                                                              options:NSJSONReadingMutableLeaves
+                                                                error:&error];
+    if (error != nil || cacheDict == nil || cacheDict.count == 0) {
+        [self.diskCache del:self.option.version];
+        return;
+    }
+    
+    NSMutableDictionary<NSString *, id<QNCacheObject>> *cache = [NSMutableDictionary dictionary];
+    for (NSString *key in cacheDict.allKeys) {
+        NSDictionary *objectDict = cacheDict[key];
+        if (!objectDict || objectDict.count == 0) {
+            continue;
+        }
+        
+        id<QNCacheObject> object = [[self.objectClass alloc] initWithDictionary:objectDict];
+        if (object != nil) {
+            cache[key] = object;
+        }
+    }
+    
+    if (!cache || cache.count == 0) {
+        [self.diskCache del:self.option.version];
+        return;
+    }
+    
+    @synchronized (self) {
+        self.memCache = cache;
+    }
+}
+
+- (NSDictionary<NSString *,id<QNCacheObject>> *)allMemoryCache {
+    @synchronized (self) {
+        return [self.memCache copy];
+    }
+}
+
+- (void)cache:(id<QNCacheObject>)object forKey:(NSString *)cacheKey atomically:(BOOL)atomically {
+    if (!cacheKey || [cacheKey isEqualToString:@""] || object == nil ||
+        ![object isKindOfClass:self.objectClass]) {
+        return;
+    }
+    
+    @synchronized (self) {
+        self.needFlushCount ++;
+        self.memCache[cacheKey] = object;
+    }
+    
+    if (self.needFlushCount >= self.option.flushCount) {
+        [self flush:atomically];
+    }
+}
+
+- (void)flush:(BOOL)atomically {
+    @synchronized (self) {
+        if (self.isFlushing) {
+            return;
+        }
+        self.needFlushCount = 0;
+        self.isFlushing = true;
+    }
+    
+    NSDictionary<NSString *, id <QNCacheObject>> *flushCache = nil;
+    @synchronized (self) {
+        if (self.memCache == nil || self.memCache.count == 0) {
+            return;
+        }
+        
+        flushCache = [self.memCache copy];
+    }
+    
+    if (atomically) {
+        [self flushCache:flushCache];
+    } else {
+        QNAsyncRun(^{
+            [self flushCache:flushCache];
+        });
+    }
+}
+
+- (void)flushCache:(NSDictionary <NSString *, id <QNCacheObject>> *)flushCache {
+    if (flushCache == nil || flushCache.count == 0) {
+        return;
+    }
+    
+    NSMutableDictionary *flushDict = [NSMutableDictionary dictionary];
+    for (NSString *key in flushCache.allKeys) {
+        id <QNCacheObject> object = flushCache[key];
+        if (![object respondsToSelector:@selector(toDictionary)]) {
+            continue;
+        }
+        flushDict[key] = [object toDictionary];
+    }
+    
+    NSData *data = [NSJSONSerialization dataWithJSONObject:flushDict options:NSJSONWritingPrettyPrinted error:nil];
+    if (!data || data.length == 0) {
+        return;
+    }
+    
+    [self.diskCache set:self.option.version data:data];
+    
+    @synchronized (self) {
+        self.isFlushing = false;
+    }
+}
+
+- (id <QNCacheObject>)cacheForKey:(NSString *)cacheKey {
+    @synchronized (self) {
+        return [self.memCache valueForKey:cacheKey];
+    }
+}
+
+- (void)clearMemoryCache {
+    @synchronized (self) {
+        self.memCache = [NSMutableDictionary dictionary];
+    }
+}
+
+- (void)clearDiskCache {
+    @synchronized (self) {
+        [self.diskCache deleteAll];
+    }
+}
+
+@end