关于一段案例的业务逻辑整理

1.jpg

单一类型选择，只能选择图片或视频

2.jpg

多类型选择，可同时选择图片和视频（例如抖音、ins可以图片和视频拼合）

3.jpg

记录逻辑复杂的情景启发（这段代码可以换种写法，且不论）

    
    private func _remove(itemModel: KSMediaPickerItemModel) -> UInt {
        let selectedAssetArray = _selectedAssetArray
        let index = selectedAssetArray.index(of: itemModel) // 0 - 8
        let count = selectedAssetArray.count  // 1 - 9
        
        // 元素不在选择池直接返回
        guard index >= 0, index < count else {
            return 0
        }
        // 重置元素index，从选择池中删除元素
        itemModel.index = 0
        selectedAssetArray.removeObject(at: index)
        
        let view = self.view as! KSMediaPickerView
        // 媒体类型
        let assetMediaType = itemModel.asset.mediaType
        // 选择上限数
        var k_maxItemCount = maxItemCount
        var needUpdateSingleType = false
        let isSingleType = _currentSingleType != nil
        if isSingleType {
            if _currentSingleType! == .video {
                k_maxItemCount = maxVideoItemCount
            } else if _currentSingleType! == .picture {
                k_maxItemCount = maxPictureItemCount
            }
            needUpdateSingleType = count == 1
        }
        let needUpdateIndexNumber = index != count-1   // 不是序号最大的那一个
        let needUpdateFocus = count == k_maxItemCount  // 池满
        
        // 不是序号最大的那个，而且选择池满的时候 需要更新label num。
       //多类型选择的情况下：不在选择池的元素都去遮罩；
       //而单类型：同类型的不在选择池的都去遮罩，异己类型不去遮罩层
        if needUpdateIndexNumber && needUpdateFocus {
            let assetList = _selectedAlbum!.assetList
            var j = Int(1)
            for k_itemModel in assetList {
                if selectedAssetArray.contains(k_itemModel) {
                    k_itemModel.index = UInt(j)  //更新num
                    j += 1
                    print("1111111111")
                } else {
                    print("22222222222") 
                    // 不在选择池的元素， 单一选择的话，和当前元素类型相同的话，
                    // 而且有遮罩层的元素，则隐藏遮罩层
                    // 多类型选择的情况下：有遮罩的元素都去遮罩
                    let ok = isSingleType ? (assetMediaType == k_itemModel.asset.mediaType) : true
                    // 选择池满，但就一个元素
                    // needUpdateSingleType 不是索引最大的那个而且满额的情况下，
// needUpdateSingleType = count == 1 永远为假
                    if (needUpdateSingleType || (ok && k_itemModel.isLoseFocus)) {
                        print("333333333333")
                        k_itemModel.isLoseFocus = false 
 // 这里隐藏遮罩层，叫失去焦点，没有遮罩层才可点击操作，叫获得焦点，才对
                        break
                    }
                }
            }
            let collectionView = view.collectionView
            collectionView.reloadData()
            // 不是序号最大的那个，选择池没满，要更新label num 
//（单类型选择无需考虑不同类型遮罩层的隐藏，多类型无遮罩层）
        } else if needUpdateIndexNumber {
            let assetList = _selectedAlbum!.assetList as NSArray
            let assetListCount = assetList.count
            var indexPaths = Array<IndexPath>()
            for (i, k_itemModel) in selectedAssetArray.enumerated() {
                let l_itemModel = k_itemModel as! KSMediaPickerItemModel
                l_itemModel.index = UInt(i+1) // 更新num
                let k_index = assetList.index(of: l_itemModel)
                if k_index >= 0 && k_index < assetListCount {
                    let indexPath = IndexPath(item: k_index, section: 0)
                    indexPaths.append(indexPath)
                }
            }
            let collectionView = view.collectionView
            collectionView.performBatchUpdates({
                collectionView.reloadItems(at: indexPaths)
            }, completion: nil)
        } else {
            // 当前元素是序号最大的元素
            let collectionView = view.collectionView
            let assetList = _selectedAlbum!.assetList
            // （找临界值）单一类型选择而且池中就一个元素，要对不同媒体类型元素去除遮罩层（复位）
            if needUpdateSingleType {
                for k_itemModel in assetList {
                    k_itemModel.isLoseFocus = false  // 所有遮罩层都隐藏，即复位
                }
                collectionView.reloadData()
                // （找临界值）池满
            } else if needUpdateFocus {
                var indexPaths = Array<IndexPath>()
                for (i, k_itemModel) in assetList.enumerated() {
                    // 单一类型选择的同媒体类型或者非单一
                    let ok = isSingleType ? (assetMediaType == k_itemModel.asset.mediaType) : true
                    // 有遮罩层的
                    if (ok && k_itemModel.isLoseFocus) {
                        k_itemModel.isLoseFocus = false  // 隐藏遮罩层
                        let indexPath = IndexPath(item: i, section: 0)
                        indexPaths.append(indexPath)
                    }
                }
                collectionView.performBatchUpdates({
                    collectionView.reloadItems(at: indexPaths)
                }, completion: nil)
            }
        }
        let albumNavigationView = view.albumNavigationView
        albumNavigationView.centerButton.isEnabled = true
        albumNavigationView.nextButton.isEnabled = selectedAssetArray.count > 0
        return 0
    }