PrivateBoxiOS/创维盒子/双子星云手机/Class/Set/uploadFile/uploadFileManager/backupsFileManager.m

//
//  backupsFileManager.m
//  隐私保护
//
//  Created by xd h on 2024/1/3.
//

#import "backupsFileManager.h"
#import "cachesFileManager.h"
#import "connectDeviceManager.h"
@implementation backupsFileManager
static backupsFileManager * cur_backupsFileShareInstance = nil;
+(backupsFileManager *)shareInstance;
{
    static dispatch_once_t onceToken;
    
    dispatch_once(&onceToken, ^{
        cur_backupsFileShareInstance = [[backupsFileManager alloc] init];
        
    });
    
    return cur_backupsFileShareInstance;
}

- (id)init
{
    self = [super init];
    
    if (self) {
        //[self initManager];
    }
    
    return self;
}

- (void)AutohandlePhotosBackupsFun
{
    NSString *curSdnId = [connectDeviceManager shareInstance].DeviceThirdIdMod.data.sdnId;
    if(!_sdnId || ![curSdnId isEqualToString:_sdnId])
    {//没有备份过 或者更换设备了
        [self handlePhotosBackupsFun];
    }
    else{
        [self checkReBackupsFileFun];
    }
    
}

- (void)handlePhotosBackupsFun
{
    BOOL haveOpenBackups = [HWDataManager getBoolWithKey:Const_photo_backups_state];
    if(!haveOpenBackups){
        return;
    }
    
    //相册权限
    if (![[TZImageManager manager] authorizationStatusAuthorized]){
        [HWDataManager setBoolWithKey:Const_photo_backups_state value:NO];
        return;
    }
    
    NSString *curSdnId = [connectDeviceManager shareInstance].DeviceThirdIdMod.data.sdnId;
    _sdnId = curSdnId;
    
    [photosBackupsTaskModel bg_findAsync:backups_photos_tableName limit:0 orderBy:nil desc:YES complete:^(NSArray * _Nullable array) {
        if(!array || array.count == 0){
            [self getAllAlbumsFun];
            return;
        }
        
        if(array.count >1){
            [self keepDatabaseOneDataFun];
        }
        
        photosBackupsTaskModel *lastModel = array.firstObject;
        
        HLog(@"1 bg_id:%@",lastModel.bg_id);
        
        if(lastModel.isBackupsSuspendType == backupsSuspendByUser){
            return;
        }
        
        if(lastModel.curBackupsState == backupsStateFail
           ||lastModel.curBackupsState == backupsStateDone){//上次备份完成
            [self getAllAlbumsFun];
        }
        else{//继续上次的备份任务
            [self handelBackupsModelFun:lastModel];
        }
    }];
    
}

- (void)keepDatabaseOneDataFun
{
    [photosBackupsTaskModel bg_deleteFirstObject:backups_photos_tableName];
    //[photosBackupsTaskModel bg_findAsync:backups_photos_tableName
}

//备份开始查询相册
- (void)getAllAlbumsFun
{
    //
    [[TZImageManager manager] getAllAlbums:YES allowPickingImage:YES needFetchAssets:NO completion:^(NSArray<TZAlbumModel *> *models) {
        
        if(models.count >= 1){
            TZAlbumModel *curAlbumModel= models.firstObject;
            
            photosBackupsTaskModel * taskModel = [photosBackupsTaskModel new];
            taskModel.count = curAlbumModel.count;
            //taskModel.result = curAlbumModel.result;
            
            taskModel.failCount = 0;
            taskModel.didBackupsCount = 0;
            taskModel.bg_tableName = backups_photos_tableName;
            
            NSMutableString *allLocalIdentifier= [NSMutableString new];
            
            for (PHAsset *asset in curAlbumModel.result) {
                if (asset.localIdentifier) {
                    if(allLocalIdentifier.length >0){
                        [allLocalIdentifier appendString:@"&"];
                    }
                    [allLocalIdentifier appendString:asset.localIdentifier];
                }
            }
            
            taskModel.totalLocalIdentifier = allLocalIdentifier;
            
            HLog(@"2 bg_id:%@",taskModel.bg_id);
            
            [taskModel bg_saveAsync:^(BOOL isSuccess) {
                if(!isSuccess){
                    HLog(@"\n\nError!!!\n\n");
                }
                else{
                    //[self handelBackupsModelFun:taskModel];
                    [self handlePhotosBackupsFun];
                }
            }];
        }
    }];
}

- (void)handelBackupsModelFun:(photosBackupsTaskModel*)backupsTaskModel
{
    _curPhotosBackupsTaskMod = backupsTaskModel;
    _curPhotosBackupsTaskMod.isBackupsSuspendType = backupsSuspendNone;
    _curPhotosBackupsTaskMod.curBackupsState = backupsStateUploading;
    
    _curPhotosBackupsTaskMod.LocalIdentifierArr = [backupsTaskModel.totalLocalIdentifier componentsSeparatedByString:@"&"];
    
    if(_curPhotosBackupsTaskMod.LocalIdentifierArr.count
       <= (_curPhotosBackupsTaskMod.didBackupsCount + _curPhotosBackupsTaskMod.failCount))
    {
        _curPhotosBackupsTaskMod.curBackupsState = backupsStateDone;
        [self RefreshDatabaseFun];
        [self changeBackupsFileStateWithSpeedFun];
        return;
    }
    
    [self beginBackupsFileFun];
}

- (void)beginBackupsFileFun
{
    NSInteger index = _curPhotosBackupsTaskMod.didBackupsCount + _curPhotosBackupsTaskMod.failCount;
    
    if(index >= _curPhotosBackupsTaskMod.LocalIdentifierArr.count){
        _curPhotosBackupsTaskMod.curBackupsState = backupsStateDone;
        [self RefreshDatabaseFun];
        [self changeBackupsFileStateWithSpeedFun];
        _curPhotosBackupsTaskMod = nil;
        return;
    }
    
    NSString *curLocalIdentifier = _curPhotosBackupsTaskMod.LocalIdentifierArr[index];
    
    if(!curLocalIdentifier || curLocalIdentifier.length == 0)
    {
        [self getDataWrongToChangeFailFun];
        return;
    }
        
    PHFetchResult *fetchResult = [PHAsset fetchAssetsWithLocalIdentifiers:@[curLocalIdentifier] options:nil];
    PHAsset *curAsset = fetchResult.firstObject;
    
    _curPhotosBackupsTaskMod.filename = [curAsset valueForKey:@"filename"];
    
    
    KWeakSelf
    if(curAsset.mediaType == PHAssetMediaTypeImage){
        _curPhotosBackupsTaskMod.curUploadFileType = uploadFileTypeImage;
        [[PHImageManager defaultManager] requestImageDataForAsset:curAsset options:nil resultHandler:^(NSData * _Nullable imageData, NSString * _Nullable dataUTI, UIImageOrientation orientation, NSDictionary * _Nullable info) {
                // 直接得到最终的 NSData 数据
                if (imageData) {
                    [weakSelf  afterGetImageDataFun:imageData];
                }
                else{
                    [weakSelf getDataWrongToChangeFailFun];
                }
        }];
    }
    else{
        _curPhotosBackupsTaskMod.curUploadFileType = uploadFileTypeVideo;
        
        //判断文件是否在app内
       BOOL didSaveFile = [cachesFileManager  checkFileIsSaveState:_curPhotosBackupsTaskMod.filename withType:uploadFileTypeVideo];
        
        if(didSaveFile){
            [self afterGetVideoDataFun];
            return;
        }
        
        //真正的视频数据
        PHVideoRequestOptions *options = [[PHVideoRequestOptions alloc] init];
        options.version = PHVideoRequestOptionsVersionOriginal;
        [[PHImageManager defaultManager] requestAVAssetForVideo:curAsset options:options resultHandler:^(AVAsset *asset, AVAudioMix *audioMix, NSDictionary *info) {
            if ([asset isKindOfClass:[AVURLAsset class]]) {
                
                AVURLAsset* urlAsset = (AVURLAsset*)asset;
                
                BOOL isSuc = [cachesFileManager copyVideoItemAtPath:[urlAsset.URL path] fileName:self->_curPhotosBackupsTaskMod.filename error:nil];
        
                if (isSuc) {
                    [weakSelf  afterGetVideoDataFun];
                }
                else{
                    [weakSelf getDataWrongToChangeFailFun];
                }
         }
        }];
    }
    
}

- (void)getDataWrongToChangeFailFun
{
    [self deleteVideoFun];
    _curPhotosBackupsTaskMod.failCount += 1;
    
    [self RefreshDatabaseFun];
    
    if(_curPhotosBackupsTaskMod.curBackupsState == backupsStateSuspend){
        return;
    }
    
    [self beginBackupsFileFun];
}

- (void)RefreshDatabaseFun
{
    HLog(@"3 bg_id:%@",_curPhotosBackupsTaskMod.bg_id);
    [_curPhotosBackupsTaskMod bg_saveOrUpdateAsync:^(BOOL isSuccess) {
                if(isSuccess){
                }
    }];
}

- (void)afterGetImageDataFun:(NSData*)imageData
{
    _curPhotosBackupsTaskMod.imageData = imageData;
    _curPhotosBackupsTaskMod.totalBytes = [imageData length];
    [[NSNotificationCenter defaultCenter] postNotificationName:backupsFileBeginNotification object:_curPhotosBackupsTaskMod];
}

- (void)deleteVideoFun
{
    if(_curPhotosBackupsTaskMod.curUploadFileType == uploadFileTypeVideo){
        [cachesFileManager removeItemAtPath:_curPhotosBackupsTaskMod.filename type:uploadFileTypeVideo error:nil];
    }
}

- (void)afterGetVideoDataFun
{
    [[NSNotificationCenter defaultCenter] postNotificationName:backupsFileBeginNotification object:_curPhotosBackupsTaskMod];
}

- (void)backupsFileDoneFun
{
    [self deleteVideoFun];
    _curPhotosBackupsTaskMod.didBackupsCount += 1;
    [self RefreshDatabaseFun];
    [self changeBackupsFileStateWithSpeedFun];
    
    if(_curPhotosBackupsTaskMod.curBackupsState == backupsStateSuspend){
        return;
    }
    
    [self beginBackupsFileFun];
    
}

//修改文件上传的状态
- (void)changeBackupsFileStateWithSpeedFun
{
    [[NSNotificationCenter defaultCenter] postNotificationName:backupsFileRefreshNotification object:_curPhotosBackupsTaskMod];
}

- (void)suspendBackupsFileFun
{
    if(!_curPhotosBackupsTaskMod){
        return;
    }
    
    _curPhotosBackupsTaskMod.curBackupsState = backupsStateSuspend;
    _curPhotosBackupsTaskMod.backupsTipMsg = NSLocalizedString(@"File_backups_Record_tip_Suspend",nil);
    
    [_curPhotosBackupsTaskMod bg_saveOrUpdateAsync:^(BOOL isSuccess) {
        if(isSuccess){
            [self changeBackupsFileStateWithSpeedFun];
        }
    }];
    
}

//文件重新备份
- (void)reBackupsFileFunBy:(photosBackupsTaskModel*)model
{
    model.isBackupsSuspendType = backupsSuspendNone;
    model.curBackupsState = backupsStateUploading;
    _curPhotosBackupsTaskMod = model;
    
    [_curPhotosBackupsTaskMod bg_saveOrUpdateAsync:^(BOOL isSuccess) {
        if(isSuccess){
            [self beginBackupsFileFun];
        }
    }];
    
}

//检查是否需要重新备份
- (void)checkReBackupsFileFun
{
    if(!_curPhotosBackupsTaskMod){
        return;
    }
    
    if(_curPhotosBackupsTaskMod.curBackupsState != backupsStateUploading){
        return;
    }
    
    [self beginBackupsFileFun];
}
@end