iOS Team / CNLiveMateCode · Files

//
//  CNLiveAddGoodsSelectUploadImageView.swift
//  metaCode
//
//  Created by zx on 2023/11/8.
//

import Foundation
import UIKit
import UniformTypeIdentifiers
import AVFoundation
import HXPHPicker
import SKPhotoBrowser
import AVKit
///类型
enum CNLiveSelectUploadImageViewDisplayType:Int {
    ///选择
    case select = 0
    ///展示
    case display
}

enum CNLiveSelectUploadImageViewHeightStyle:Int {
    ///高度自动控制
    case autoCalc = 0
    ///高度固定
    case fixed
}
let DS_SUIV_ADD_TAG_COUNT = 123321 //所有view加一个默认tag值 以防和别的tag重复

typealias clickCallBackBlock = ()->Void
typealias changeFrameCallBackBlock = ()->Void
typealias changeUploadDataCallBackBlock = (_ imageUrls:Array<String> ,_ videoUrl:String)->Void
typealias beginUploadImageCallBackBlock = ()->Void
typealias endUploadImageCallBackBlock = ()->Void


class CNLiveAddGoodsSelectUploadImageView: UIView,UIImagePickerControllerDelegate, PhotoPickerControllerDelegate {
    
    // MARK: - 属性
    /// 显示类型
    var _displayType:CNLiveSelectUploadImageViewDisplayType = .select
    var displayType:CNLiveSelectUploadImageViewDisplayType{
        get{
            _displayType
        }
        set{
            _displayType = newValue
            self.resetUI()
        }
    }
    
    /// 高度类型
    var heightStyle:CNLiveSelectUploadImageViewHeightStyle = .autoCalc
    /// 每张图的间距 默认DS_adapt_length(15)
    var _space:CGFloat = 15
    var space:CGFloat{
        get{
            _space
        }
        set{
            _space = newValue
            self.resetUI()
            self.autoAdjustHeight()
        }
    }
    /// 每行第一张图距左边的间距 默认DS_adapt_length(15)
    var _lSpace:CGFloat = 15
    var lSpace:CGFloat{
        get{
            _lSpace
        }
        set{
            _lSpace = newValue
            self.resetUI()
            self.autoAdjustHeight()
        }
    }
    /// 每行最后一张图距右边的间距 默认DS_adapt_length(15)
    var _rSpace:CGFloat = 15
    var rSpace:CGFloat{
        get{
            _rSpace
        }
        set{
            _rSpace = newValue
            self.resetUI()
            self.autoAdjustHeight()
        }
    }
    /// 图片的宽高(正方形) heightStyle=DSSelectUploadImageViewHeightStyleAutoCalc时自动计算 heightStyle=DSSelectUploadImageViewHeightStyleFixed时为0需自己赋值 （提示：图片右上角需留出DS_adapt_length(17)/2的空间，给X的图片留位置）
    var WHeight:CGFloat = 0
    /// 自定义删除图片 默认DS_SelUplImageView_delete
    var _deleteImage:UIImage?
    var deleteImage:UIImage?{
        get{
            _deleteImage
        }
        set{
            _deleteImage = newValue
            self.resetUI()
        }
    }
    /// 是否显示选取封面
    var _isDisplySelectCover:Bool = false
    var isDisplySelectCover:Bool?{
        get{
            _isDisplySelectCover
        }
        set{
            _isDisplySelectCover = newValue!
            self.resetUI()
        }
    }

    // MARK: - 回调
    /// 点击处理事务前回调
    var clickCallBack:clickCallBackBlock?
    /// 修改自身高度回调
    var changeFrameCallBack:changeFrameCallBackBlock?
    /// 修改上传数据回调
    var changeUploadDataCallBack:changeUploadDataCallBackBlock?

    // MARK: - 展示属性
    /// 获取的网络图片数组
    var _networkImageArr:Array<String> = Array()
    var networkImageArr:Array<String>{
        get{
            _networkImageArr
        }
        set{
            _networkImageArr = newValue
            self.deleteUploadImageUrl()
            self.uploadImageUrls.removeAll()
            self.replaceImageUrls.removeAll()
            for imageUrl in self.networkImageArr{
                let uploadImageModel = CNLiveSelectUploadImageModel()
                uploadImageModel.imageUrl = imageUrl
                uploadImageModel.isUploading = false
                self.uploadImageUrls.append(uploadImageModel)
            }
            self.resetUI()
            self.autoAdjustHeight()
        }
    }
    
    /// 获取的网络视频url
    var networkVideoUrl:String?
    /// 获取的网络视频图片
    var networkVideoImageUrl:String?

    // MARK: - 选择属性
    /// 列数默认4
    var _column:Int = 4
    var column:Int{
        get{
            _column
        }
        set{
            _column = newValue
            self.resetUI()
            self.autoAdjustHeight()
        }
    }
    /// 图片选取最大数量 默认0 必传
    var _maxSelectImageCount:Int = 0
    var maxSelectImageCount:Int{
        get{
            _maxSelectImageCount
        }
        set{
            _maxSelectImageCount = newValue
            if self.uploadImageUrls.count > self.maxSelectImageCount{
                var i = self.uploadImageUrls.count-1
                while i >= self.maxSelectImageCount {
                    i -= 1
                    let model = self.uploadImageUrls[i]
                    if model.isUploading == true{
                        UploadManager.shared.cancelUploadKey(key: model.uploadKey!)
                    }else{
                        UploadManager.shared.requestQiNiuDeleteImageUrl(imageUrl: model.imageUrl!) { result, status in
                            
                        }
                        self.uploadImageUrls.remove(model)
                    }
                }
            }
            self.resetUI()
        }
    }
    
    /// 是否可以选择视频 (目前只能选取一个，在索引1显示)
    var _isAbleSelectVideo:Bool = false
    var isAbleSelectVideo:Bool?{
        get{
            _isAbleSelectVideo
        }
        set{
            _isAbleSelectVideo = newValue!
            self.resetUI()
        }
    }
    // MARK: - 上传操作
    /// 是否正在上传图片中
    var isUploading:Bool = false
    /// 开始上传图片
    var beginUploadImageCallBack:beginUploadImageCallBackBlock?
    /// 结束上传图片
    var endUploadImageCallBack:endUploadImageCallBackBlock?
   
    /// 获取的网络视频属性
    /// @param networkVideoUrl 获取的网络视频url
    /// @param networkVideoImageUrl 获取的网络视频图片
    func setNetworkVideoUrl(networkVideoUrl:String,networkVideoImageUrl:String){
        self.networkVideoUrl = networkVideoUrl
        self.networkVideoImageUrl = networkVideoImageUrl
        self.deleteUploadVideoUrl()
        self.uploadVideoModel = nil
        self.uploadVideoModel = CNLiveSelectUploadImageModel()
        self.uploadVideoModel?.isVideo = true
        self.uploadVideoModel?.videoUrl = self.networkVideoUrl
        self.uploadVideoModel?.imageUrl = self.networkVideoImageUrl
        self.uploadVideoModel?.isUploading = false
        self.resetUI()
        
    }

    // MARK: - 私有属性
    /**
     这次要上传的视频url
    */
    var _uploadVideoModel:CNLiveSelectUploadImageModel?
    var uploadVideoModel:CNLiveSelectUploadImageModel?{
        get{
            if _uploadVideoModel == nil{
                _uploadVideoModel = CNLiveSelectUploadImageModel()
                _uploadVideoModel?.isVideo = true
            }
            return _uploadVideoModel
        }
        set{
            _uploadVideoModel = newValue
        }
    }
    /**
     需要删除的视频urls
    */
    var replaceVideoUrls = [CNLiveSelectUploadImageModel]()
    /**
     这次要上传的图片urls
     */
    var uploadImageUrls = [CNLiveSelectUploadImageModel]()
    /**
     需要删除的图片urls
     */
    var replaceImageUrls = [CNLiveSelectUploadImageModel]()
    /**
     正在上传的图片数量
     */
    var _uploadingCount:Int = 0
    var uploadingCount:Int{
        get{
            _uploadingCount
        }
        set{
            _uploadingCount = newValue
            if _uploadingCount > 0{
                self.isUploading = true
            }else{
                self.isUploading = false
            }
        }
    }
    
    // MARK: - 公开方法
    /**
     获取当前选取的网络图片Url数组
     @return 网络图片Url数组
     */
    func getCurrentSelectImageUrls()->Array<String>{
        let imageUrls = NSMutableArray()
        for uploadImageModel in self.uploadImageUrls{
            if uploadImageModel.isUploading == true || uploadImageModel.imageUrl?.isEmpty == true{
                return Array()
            }
            imageUrls.add(uploadImageModel.imageUrl!)
        }
        let arr = imageUrls as NSArray
        return arr as! Array<String>
    }
    /**
     获取当前选取的网络视频Url

     @return 网络视频Url
     */
    func getCurrentSelectVideoUrl()->String{
        if ((self.uploadVideoModel?.isUploading == true) || self.uploadVideoModel?.videoUrl?.count == 0){
            return ""
        }
        return self.uploadVideoModel?.videoUrl ?? ""
    }
    /**
     获取当前选取的本地视频Url

     @return 网络视频Url
     */
    func getCurrentSelectLocalVideoUrl()->URL{
        return (self.uploadVideoModel?.localVideoUrl)!
    }
    /**
     获取当前选取的本地视频Url第一帧图片

     @return 网络视频Url第一帧图片
     */
    func getCurrentSelectLocalVideoUrlFirstImage() -> UIImage? {
        return self.uploadVideoModel?.image
    }
    /**
     提交成功XXX后 删除(云中)替换掉的图片 （提交成功调用）
     */
    func deleteReplaceImageUrlAfterSuccessUploadThings(){
        for replaceImageModel in self.replaceImageUrls {
            UploadManager.shared.requestQiNiuDeleteImageUrl(imageUrl: replaceImageModel.imageUrl!) { result, status in
                
            }
        }
        self.networkImageArr = self.getCurrentSelectImageUrls()
        for replaceVideoModel in self.replaceVideoUrls {
            UploadManager.shared.requestQiNiuDeleteImageUrl(imageUrl: replaceVideoModel.videoUrl!) { result, status in
                
            }
        }
        self.networkVideoUrl = self.getCurrentSelectVideoUrl()
    }
    /**
     不上传了 删除(云中)新上传的图片 （dealloc调用）
     */
    func deleteUploadImageUrlAfterCancelUploadThings(){
        self.deleteUploadImageUrl()
        self.deleteUploadVideoUrl()
    }
    /**
     不上传了 删除(云中)新上传的图片
     */
    func deleteUploadImageUrl(){
        for uploadImageModel in self.uploadImageUrls {
            if !self.networkImageArr.contains(uploadImageModel.imageUrl!){
                UploadManager.shared.requestQiNiuDeleteImageUrl(imageUrl: uploadImageModel.imageUrl!) { result, status in
                    
                }
            }else if uploadImageModel.isUploading == true{
                UploadManager.shared.cancelUploadKey(key: uploadImageModel.uploadKey!)
            }
        }
        for replaceImageModel in self.replaceImageUrls{
            if !self.networkImageArr.contains(replaceImageModel.imageUrl!){
                UploadManager.shared.requestQiNiuDeleteImageUrl(imageUrl: replaceImageModel.imageUrl!) { result, status in
                    
                }
            }
        }
    }
    /**
     不上传了 删除(云中)新上传的视频
     */
    func deleteUploadVideoUrl(){
        if self.networkVideoUrl != self.uploadVideoModel?.videoUrl{
            UploadManager.shared.requestQiNiuDeleteImageUrl(imageUrl: (self.uploadVideoModel?.videoUrl)!) { result, status in
                
            }
        }else if self.uploadVideoModel?.isUploading == true{
            UploadManager.shared.cancelUploadKey(key: self.uploadVideoModel!.uploadKey!)
        }
        for replaceVideoModel in self.replaceVideoUrls {
            if self.networkVideoUrl != replaceVideoModel.videoUrl{
                UploadManager.shared.requestQiNiuDeleteImageUrl(imageUrl: replaceVideoModel .videoUrl!) { result, status in
                    
                }
            }
        }
    }
    // MARK: - 系统属性
    override var frame: CGRect{
        didSet {
            if self.heightStyle == .autoCalc{
                //算出带X图片的间距 X图片宽高均为DS_adapt_length(17)
                let addXRSpace = self.rSpace - 17*0.5
                let addXSpace = self.space - 17*0.5
                let column = self.maxSelectImageCount < self.column ? self.maxSelectImageCount : self.column
                
                let totalSpace = self.lSpace + addXRSpace + addXSpace*CGFloat(column - 1)
                let aHeight = column == 0 ? 0.0 : ((frame.size.width - totalSpace) / CGFloat(column))
                
                let subviewsCount = self.subviews.count
                var row = 1
                if column > 0{
                    row = subviewsCount / column + (subviewsCount % column > 0 ? 1 : 0)
                }
                let height = aHeight * CGFloat(row) + (row > 1 ? addXSpace : 0) + 10
                var isNeedCallBack = false
                if self.height != 0 && self.height != height{
                    isNeedCallBack = true
                }
                super.frame = CGRect(x: frame.origin.x, y: frame.origin.y, width: frame.size.width, height: height == 0 ? frame.size.height : height)
                if isNeedCallBack{
                    self.changeFrameCallBack!()
                }
            }else{
                super.frame = frame
            }
        }
    }

    // MARK: - 自动调整高度
    func autoAdjustHeight(){
        if self.heightStyle == .autoCalc{
            self.frame = self.frame
        }
    }
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        self.initData()
        self.resetUI()
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    // MARK: - 初始化
    init(frame:CGRect ,heightStyle:CNLiveSelectUploadImageViewHeightStyle,maxSelectImageCount:Int) {
        super.init(frame: frame)
        self.initData()
        self.resetUI()
    }
    
    func initData(){
        self.backgroundColor = .clear
        self.clipsToBounds = true
        self.column = 4
        self.space = 15
        self.lSpace = 15
        self.rSpace = 15
        NotificationCenter.default.addObserver(self, selector: #selector(willTerminateNotification), name: UIApplication.willTerminateNotification, object: nil)
    }
    override func layoutSubviews() {
        super.layoutSubviews()
        
        //算出带X图片的间距 X图片宽高均为DS_adapt_length(17)
        let addXRSpace = self.rSpace - 17*0.5
        let addXSpace = self.space - 17*0.5
        let column = self.maxSelectImageCount < self.column ? self.maxSelectImageCount : self.column
        var width = 0.0
        if self.heightStyle == .autoCalc{
            let totalSpace = self.lSpace + addXRSpace + addXSpace * CGFloat(column - 1)
            width = (self.width - totalSpace) / Double(column)
        }else{
            width = self.WHeight
        }
        let height = width
        let subViews = self.subviews
        for i in 0..<subViews.count {
            let singleImageView = self.viewWithTag(i+1+DS_SUIV_ADD_TAG_COUNT)
            singleImageView?.frame = CGRect(x: self.lSpace+(width+addXSpace)*Double((i%column)), y: (height+addXSpace)*Double((i/column)), width: width, height: height)
        }
    }
    deinit {
        NotificationCenter.default.removeObserver(self, name: UIApplication.willTerminateNotification, object: nil)
    }

    // MARK: - 通知
    @objc func willTerminateNotification(){
        self.deleteUploadImageUrlAfterCancelUploadThings()
    }

    // MARK: - resetUI
    func resetUI(){
        self.subviews.forEach { $0.removeFromSuperview() }
        var isHideDeleteBtn = false
        if self.displayType == .display{
            isHideDeleteBtn = true
        }
        if self.displayType == .select{
            var lastIsSelectImage = false
            if self.isAbleSelectVideo == true{
                //可以选择视频,索引1
                //前2个为 选择图片和选择视频占位图,最多7个图片 1个视频
                let model1 = CNLiveSelectUploadImageModel()
                model1.isSelectPhotoPlaceholder = true
                //选择照片
                let singleImageView1 = self.createSingleImageView()
                singleImageView1.tag = 1+DS_SUIV_ADD_TAG_COUNT
                singleImageView1.setModel(model: model1, isHideDeleteBtn: isHideDeleteBtn, isCover: false)
                self.addSubview(singleImageView1)
                //选择视频
                let singleImageView2 = self.createSingleImageView()
                singleImageView2.tag = 2+DS_SUIV_ADD_TAG_COUNT
                singleImageView2.setModel(model: self.uploadVideoModel!, isHideDeleteBtn: isHideDeleteBtn, isCover: false)
                self.addSubview(singleImageView2)
            }else if self.uploadImageUrls.count < self.maxSelectImageCount{
                //不可以选择视频,最后一个图片
                lastIsSelectImage = true
            }
            var lastView:CNLiveSelUplSingleImageView? = nil
            for i in 0..<self.uploadImageUrls.count {
                //给图片赋值
                let model = self.uploadImageUrls[i]
                let singleImageView = self.createSingleImageView()
                if self.isAbleSelectVideo == true{
                    //有2个默认占位图
                    singleImageView.tag = i+3+DS_SUIV_ADD_TAG_COUNT
                }else{
                    //全是图片,没有占位图
                    singleImageView.tag = i+1+DS_SUIV_ADD_TAG_COUNT
                }
                singleImageView.setModel(model: model, isHideDeleteBtn: isHideDeleteBtn, isCover: i == 0 ? true : false)
                self.addSubview(singleImageView)
                lastView = singleImageView
            }
            if lastIsSelectImage{
                //最后一张图片
                let model = CNLiveSelectUploadImageModel()
                model.isSelectPhotoPlaceholder = true
                let singleImageView = self.createSingleImageView()
                if (lastView != nil){
                    singleImageView.tag = lastView!.tag + 1
                }else{
                    singleImageView.tag = DS_SUIV_ADD_TAG_COUNT+1
                }
                singleImageView.setModel(model: model, isHideDeleteBtn: isHideDeleteBtn, isCover: false)
                self.addSubview(singleImageView)
            }
        }else{
            //纯展示,不可选择
            if self.networkVideoUrl?.count ?? 0 > 0{
                //给视频配置model
                let model = CNLiveSelectUploadImageModel()
                model.videoUrl = self.networkVideoUrl
                model.imageUrl = self.networkVideoImageUrl
                model.isVideo = true
                
                let singleImageView = self.createSingleImageView()
                singleImageView.tag = 1+DS_SUIV_ADD_TAG_COUNT
                singleImageView.setModel(model: model, isHideDeleteBtn: isHideDeleteBtn, isCover: false)
                self.addSubview(singleImageView)
            }
            for i in 0..<self.networkImageArr.count {
                //给图片配置model
                let model = CNLiveSelectUploadImageModel()
                model.imageUrl = self.networkImageArr[i]
                
                let singleImageView = self.createSingleImageView()
                if self.networkVideoUrl!.count > 0{
                    singleImageView.tag = i + 2+DS_SUIV_ADD_TAG_COUNT
                }else{
                    singleImageView.tag = i+1+DS_SUIV_ADD_TAG_COUNT
                }
                singleImageView.setModel(model: model, isHideDeleteBtn: isHideDeleteBtn, isCover: i == 0 ? true : false)
                self.addSubview(singleImageView)
            }
        }
        
    }
    
    /// 创建单个视图
    func createSingleImageView()->CNLiveSelUplSingleImageView{
        let singleImageView = CNLiveSelUplSingleImageView()
        singleImageView.deleteImage = self.deleteImage
        singleImageView.isDisplySelectCover = self.isDisplySelectCover
        singleImageView.displayType = self.displayType
        singleImageView.clickCallBack = {model in
            self.selectImageModel(model: model)
        }
        singleImageView.clickDeleteCallBack = {model in
            self.delteImageModel(model: model)
        }
        singleImageView.clickSettingCoverCallBack = {model in
            self.clickCallBack!()
            UIApplication.shared.keyWindow?.endEditing(true)
            
            if let index = self.uploadImageUrls.firstIndex(of: model){
                self.uploadImageUrls.remove(at: index)
                self.uploadImageUrls.insert(model, at: 0)
            }else{
                return
            }
            self.resetUI()
        }
        return singleImageView
    }

    // MARK: - 选取图片/视频
    func selectImageModel(model:CNLiveSelectUploadImageModel){
        if self.clickCallBack != nil{
            self.clickCallBack!()
        }
        UIApplication.shared.keyWindow?.endEditing(true)
        if (model.isVideo == true){
            if (model.localVideoUrl != nil){
                CNLiveCommonManager.shared.skipPlayerVCWithPlayURL(playURL: URL(string: model.videoUrl ?? "")!, coverImage: model.image!, coverImageUrl: nil)
            }else if model.videoUrl?.count ?? 0 > 0{
                CNLiveCommonManager.shared.skipPlayerVCWithPlayURL(playURL: model.localVideoUrl!, coverImage: nil, coverImageUrl: model.imageUrl)
            }else{
                //TODO:后面再调整具体的配置
                // 设置与微信主题一致的配置
                let config = PhotoTools.getWXPickerConfig()
                config.selectOptions = [.video]
                config.previewView.bottomView.editButtonHidden = false
                let pickerController = PhotoPickerController(picker: config)
                pickerController.pickerDelegate = self
                // 是否选中原图
                pickerController.isOriginal = true
                pickerController.modalPresentationStyle = .fullScreen
                currentViewController()?.present(pickerController, animated: true)
            }
        }else{
            if (model.isSelectPhotoPlaceholder != nil) && (model.isSelectPhotoPlaceholder == true){
                if self.uploadImageUrls.count >= self.maxSelectImageCount{
                    let message = String(format: "最多只能选取%ld张图片", self.maxSelectImageCount)
                    showMessage(message: message)
                    return
                }
                let config = PhotoTools.getWXPickerConfig()
                config.selectMode = .multiple
                config.selectOptions = .photo
                config.maximumSelectedPhotoCount = self.maxSelectImageCount-self.uploadImageUrls.count
                let pickerController = PhotoPickerController(picker: config)
                pickerController.pickerDelegate = self
                // 是否选中原图
                pickerController.isOriginal = false
                pickerController.modalPresentationStyle = .fullScreen
                //TODO 少了一个不允许拍摄视频 allowTakeVideo=false
                currentViewController()?.present(pickerController, animated: true)
                
            }else{
                if model.isUploading == true || model.imageUrl == nil{
                    return
                }
                let subviews = self.subviews
                var currentPage = 0
                var images = [SKPhoto]()
                for i in 0..<self.uploadImageUrls.count {
                    let cmodel = self.uploadImageUrls[i]
                    if cmodel.isUploading == false && cmodel.imageUrl?.count ?? 0 > 0{
                        let photo = SKPhoto.photoWithImageURL(cmodel.imageUrl!)
                        photo.shouldCachePhotoURLImage = false
                        photo.photoURL = cmodel.imageUrl
                        images.append(photo)
                    }
                    if cmodel.imageUrl == model.imageUrl{
                        currentPage = i
                    }
                }
                
                let browser = SKPhotoBrowser(photos: images)
                browser.initializePageIndex(currentPage)
                currentViewController()?.present(browser, animated: true)
            }
        }
    }

    // MARK: - 删除图片/视频
    func delteImageModel(model:CNLiveSelectUploadImageModel){
        if  self.clickCallBack?() != nil{
            self.clickCallBack!()
        }
        
        UIApplication.shared.keyWindow?.endEditing(true)
        let subviews = self.subviews
        for i in 0..<subviews.count {
            let singleImageView = self.viewWithTag(i+1+DS_SUIV_ADD_TAG_COUNT) as! CNLiveSelUplSingleImageView
            
            
            
            if (model.imageUrl?.count ?? 0 > 0) && (singleImageView.model?.imageUrl?.count ?? 0 > 0){
                if model.imageUrl == singleImageView.model?.imageUrl{
                    if singleImageView.model?.isVideo == true{
                        //subview是视频
                        if singleImageView.model?.isUploading == true{
                            //subview正在上传中
                            UploadManager.shared.cancelUploadKey(key: singleImageView.model!.uploadKey!)
                        }else{
                            //subview上传完成
                            //标记当前有视频,并替换model
                            self.replaceVideoUrls.append(singleImageView.model!)
                            let videoModel = CNLiveSelectUploadImageModel()
                            videoModel.isVideo = true
                            self.uploadVideoModel = videoModel
                        }
                    }else{
                        //subview是纯图片
                        if singleImageView.model?.isUploading == true{
                            //上传中
                            UploadManager.shared.cancelUploadKey(key: singleImageView.model!.uploadKey!)
                        }else{
                            //上传完成
                            if let index = self.uploadImageUrls.firstIndex(of: singleImageView.model!){
                                //移除上传完成的model
                                self.uploadImageUrls.remove(at: index)
                                self.replaceImageUrls.append(singleImageView.model!)
                            }
                        }
                    }
                    break
                }
            }else{
                //imageUrl有空值
                if model.videoUrl?.count ?? 0 > 0 && self.uploadVideoModel?.videoUrl?.count ?? 0 > 0 && model.videoUrl == self.uploadVideoModel?.videoUrl{
                    //当前要删除的是视频
                    if self.uploadVideoModel?.isVideo == true{
                        //subview是视频
                        if self.uploadVideoModel?.isUploading == true{
                            //subview正在上传中
                            UploadManager.shared.cancelUploadKey(key: self.uploadVideoModel!.uploadKey!)
                        }else{
                            //subview上传完成
                            //标记当前有视频,并替换model
                            self.replaceVideoUrls.append(self.uploadVideoModel!)
                            let videoModel = CNLiveSelectUploadImageModel()
                            videoModel.isVideo = true
                            self.uploadVideoModel = videoModel
                        }
                    }
                    break
                }
                
            }
            
            
            
            /*
            //TODO 目前imageUrl为nil
            if model.imageUrl == singleImageView.model?.imageUrl{
                //要删除model的imageUrl和subview的imageUrl相等
                if singleImageView.model?.isVideo == true{
                    //subview是视频
                    if singleImageView.model?.isUploading == true{
                        //subview正在上传中
                        UploadManager.shared.cancelUploadKey(key: singleImageView.model!.uploadKey!)
                    }else{
                        //subview上传完成
                        //标记当前有视频,并替换model
                        self.replaceVideoUrls.append(singleImageView.model!)
                        let videoModel = CNLiveSelectUploadImageModel()
                        videoModel.isVideo = true
                        self.uploadVideoModel = videoModel
                    }
                }else{
                    //subview是纯图片
                    if singleImageView.model?.isUploading == true{
                        //上传中
                        UploadManager.shared.cancelUploadKey(key: singleImageView.model!.uploadKey!)
                    }else{
                        //上传完成
                        if let index = self.uploadImageUrls.firstIndex(of: singleImageView.model!){
                            //移除上传完成的model
                            self.uploadImageUrls.remove(at: index)
                            self.replaceImageUrls.append(singleImageView.model!)
                        }
                    }
                }
                break
            }*/
        }
        self.resetUI()
        self.autoAdjustHeight()
        if self.changeUploadDataCallBack?(self.getCurrentSelectImageUrls(),self.getCurrentSelectVideoUrl()) != nil{
            self.changeUploadDataCallBack!(self.getCurrentSelectImageUrls(),self.getCurrentSelectVideoUrl())
        }
    }
    
    // MARK: - PickerControllerDelegate
    func pickerController(_ pickerController: HXPHPicker.PhotoPickerController, didFinishSelection result: HXPHPicker.PickerResult) {
        result.getVideoURL { videoUrls in
            if videoUrls.count == 0{
                return
            }
            let videoUrl = videoUrls.first! as URL
            let videoData:NSData
            do {
                videoData = try NSData(contentsOf: videoUrl) ?? NSData()
                print(videoData)
            }catch{
                print("无法加载视频数据")
            }
            self.splitVideoFileUrlFps(splitFileUrl: videoUrl, fps: 1) { isSucc,firstImage in
                if isSucc{
                    self.uploadVideoModel?.videoUrl = nil
                    self.uploadVideoModel?.image = firstImage.first
                    self.uploadVideoModel?.localVideoUrl = videoUrl
                    self.uploadVideoModel?.isUploading = true
                    
                    self.uploadVideoModel?.uploadKey = UploadManager.uploadVideo(videoData: videoData, progressBlock: { [weak self] key, progress in
                        self!.uploadVideoModel?.uploadingPercent = progress
                        self?.replaceVideoModelInSubviews(model: (self?.uploadVideoModel)!, target: firstImage.first!)
                    }, successBlock: { [weak self] key,url in
                        self?.uploadVideoModel?.videoUrl = url
                        self?.uploadVideoModel?.isUploading = false
                        self?.uploadVideoModel?.uploadKey = nil
                        self?.replaceVideoModelInSubviews(model: (self?.uploadVideoModel)!, target: firstImage.first!)
                        self?.uploadingCount = self!.uploadingCount - 1
                        if self?.uploadingCount == 0{
                            if ((self?.endUploadImageCallBack?()) != nil){
                                self?.endUploadImageCallBack!()
                            }
                        }
                        if ((self?.changeUploadDataCallBack?((self?.getCurrentSelectImageUrls())!,(self?.getCurrentSelectVideoUrl())!)) != nil){
                            self?.changeUploadDataCallBack!((self?.getCurrentSelectImageUrls())!,(self?.getCurrentSelectVideoUrl())!)
                        }
                    })
                    DispatchQueue.main.async {
                        self.resetUI()
                        self.autoAdjustHeight()
                        self.uploadingCount = self.uploadingCount + 1
                        if self.uploadingCount == 1{
                            if ((self.beginUploadImageCallBack?()) != nil){
                                self.beginUploadImageCallBack!()
                            }
                        }

                    }
                }
            }
            
        }
        result.getImage { [weak self] img, photoAsset, index in
            if photoAsset.mediaType == .video {
                return
            }
            if let image = img {
                let imageData = image.jpegData(compressionQuality: 1.0)! as NSData
                let model = CNLiveSelectUploadImageModel()
                model.image = image
                model.isUploading = true
                
                self!.uploadVideoModel?.uploadKey = UploadManager.uploadImage(imageData: imageData) { [weak self] key, percent in
                    model.uploadingPercent = percent
                    self?.replaceImageModelInDataArr(model: model, target: image)
                } successBlock: { key, url in
                    model.imageUrl = url
                    model.isUploading = false
                    model.uploadKey = nil
                    self!.replaceImageModelInDataArr(model: model, target: image)
                    
                    self!.uploadingCount = self!.uploadingCount - 1
                    
                    if self!.uploadingCount == 0{
                        if self!.endUploadImageCallBack?() != nil{
                            self!.endUploadImageCallBack!()
                        }
                    }
                    
                    if self!.changeUploadDataCallBack?(self!.getCurrentSelectImageUrls(),self!.getCurrentSelectVideoUrl()) != nil{
                        self!.changeUploadDataCallBack!(self!.getCurrentSelectImageUrls(),self!.getCurrentSelectVideoUrl())
                    }
                }
                self!.uploadImageUrls.append(model)
                self!.resetUI()
                self!.autoAdjustHeight()
                self!.uploadingCount = self!.uploadingCount + 1
                if self!.uploadingCount == 1{
                    if self!.beginUploadImageCallBack?() != nil{
                        self!.beginUploadImageCallBack!()
                    }
                }
            }else{
                print("failed")
            }
        } completionHandler: { (images) in
            
        }
        pickerController.dismiss(animated: true)
    }
       
 

    // MARK: - 获取视频的第一帧
    func splitVideoFileUrlFps(splitFileUrl: URL, fps: Float, splitCompleteClosure: @escaping (Bool, [UIImage]) -> Void) {

        var splitImages = [UIImage]()
        let optDict = NSDictionary(object: NSNumber(value: false), forKey: AVURLAssetPreferPreciseDurationAndTimingKey as NSCopying)
        let urlAsset = AVURLAsset(url: splitFileUrl, options: optDict as? [String: Any])

        let cmTime = urlAsset.duration
        let durationSeconds: Float64 = CMTimeGetSeconds(cmTime) //视频总秒数

        var times = [NSValue]()
        let totalFrames: Float64 = durationSeconds * Float64(fps) //获取视频的总帧数
        var timeFrame: CMTime

        for i in 0...Int(totalFrames) {
            timeFrame = CMTimeMake(value: Int64(i), timescale: Int32(fps)) //第i帧， 帧率
            let timeValue = NSValue(time: timeFrame)

            times.append(timeValue)
        }

        let imgGenerator = AVAssetImageGenerator(asset: urlAsset)
        imgGenerator.requestedTimeToleranceBefore = CMTime.zero //防止时间出现偏差
        imgGenerator.requestedTimeToleranceAfter = CMTime.zero
        imgGenerator.appliesPreferredTrackTransform = true //不知道是什么属性，不写true视频帧图方向不对

        let timesCount = times.count

        //获取每一帧的图片
        imgGenerator.generateCGImagesAsynchronously(forTimes: times) { (requestedTime, image, actualTime, result, error) in

            //times有多少次body就循环多少次。。。

            var isSuccess = false
            switch (result) {
            case AVAssetImageGenerator.Result.cancelled:
                print("cancelled------")

            case AVAssetImageGenerator.Result.failed:
                print("failed++++++")

            case AVAssetImageGenerator.Result.succeeded:
                let framImg = UIImage(cgImage: image!)
                splitImages.append(framImg)

                if (Int(requestedTime.value) == (timesCount - 1)) { //最后一帧时 回调赋值
                    isSuccess = true
                    splitCompleteClosure(isSuccess, splitImages)
                    print("completed")
                }
            }
        }
    }

    // MARK: - 刷新数组中的图片model

    /**
     刷新数组中的图片model
     
     @param model model
     @param target 目标图片
     */
    func replaceImageModelInDataArr(model:CNLiveSelectUploadImageModel,target:UIImage){
        var muteArr = NSMutableArray(array: self.uploadImageUrls)
        for (idx,obj) in muteArr.enumerated() {
            let tempObj = obj as! CNLiveSelectUploadImageModel
            if tempObj.image == target{
                muteArr.replaceObject(at: idx, with: tempObj)
                break
            }
        }
        self.uploadImageUrls = muteArr as! [CNLiveSelectUploadImageModel]
        for singleImageView in self.subviews{
            let singleImgView = singleImageView as! CNLiveSelUplSingleImageView

            if singleImgView.model?.image == target{
                singleImgView.setModel(model: model, isHideDeleteBtn: singleImgView.isHideDeleteBtn!, isCover: singleImgView.isCover)
                break
            }
        }
    }

    // MARK: - 刷新视图中视频view的model

    /**
     刷新视图中视频view的model

     @param model model
     @param target 目标图片
    */
    func replaceVideoModelInSubviews(model:CNLiveSelectUploadImageModel,target:UIImage){
        for singleImageView in self.subviews {
            let singleImgView = singleImageView as! CNLiveSelUplSingleImageView
            if singleImgView.model?.image == target{
                singleImgView.setModel(model: model, isHideDeleteBtn: singleImgView.isHideDeleteBtn ?? false, isCover: singleImgView.isCover)
                break
            }
        }
    }

}