LinkedBlockingQueue iOS Swift 4

Question

我正试图在Swift中实现一些已经在安卓上使用LinkedBlockingQueue.实现的功能

我正在开发的应用程序使用红蜘蛛库连接到一个使用WebSocket连接的设备。

该应用程序可以向设备发送一条消息，请求一段数据。如果没有收到回复，则只能发送一次此消息。最后将使用所有数据块来创建一个文件。

从应用程序发送/接收的数据和设备是从Proto文件序列化数据。

我面临的问题是，我不知道如何在需要请求一定数量数据的函数中处理这个问题，因为来自设备的响应发生在我的功能之外。

func getFile(at index:Int, outputFormat:RecordQuality){

    let aFile= fileArray[index]

    var bytesRemaining = aFle.lengthBytes
    var offset:Int64 = 0

    while bytesRemaining > 0{

        //This function deals with the webSocket write action and deals with all the proto Classes
        readFileReq(fileName: aTrack.name, offset: ofset, length: AppSocketManager.dataReqSize)

        isWaitingForData = true
        print("\(logClassName) TEST -> Blocking!")
        while isWaitingForData{

        }

        print("\(logClassName) TEST -> End Blocking!")

        offset += Int64(2352 * 8)
        bytesRemaining -= offset
        print("\(logClassName) TEST -> \(offset)")

    }

    print("\(logClassName) get file finished")

}

aFile是一个可变类型的ReqFile

private struct ReqFile{
    var name:String
    var lengthBytes:Int64
    var startAddress:UInt32
    var isAudio:Bool
    var numberBlock:UInt32

    init(name:String, lengthBytes:Int64) {
        self.name = name
        self.lengthBytes = lengthBytes
        self.startAddress = 0
        self.isAudio = false
        self.numberBlock = 0
    }

}

另一方面，接收到的数据的webSocket委托方法是

func websocketDidReceiveData(socket: WebSocketClient, data: Data) {
    /* Deal with data */
    isWaitingForData = false 
}

这个代码永远不会到达websocketDidReceiveData，因为我基本上是在阻塞期望isWaitingData为假退出的时间，是吗？

有什么想法吗？

Answer 1

经过一些研究，我决定将操作子类划分为：

import UIKit

class TrackOperation:Operation{

    //MARK: Vars
    private var _executing  = true
    private var _finished  = false

    override var isAsynchronous: Bool{return true}
    override var isConcurrent: Bool{return true}

    override var isExecuting: Bool{
        get{
            return _executing
        }
        set{
            willChangeValue(for: \.isExecuting)
            _executing = newValue
            didChangeValue(for: \.isExecuting)
        }
    }
    override var isFinished: Bool{
        get{
            return _finished
        }
        set{
            willChangeValue(for: \.isFinished)
            _finished = newValue
            didChangeValue(for: \.isFinished)
        }

    }

    private (set) var fileName:String
    private (set) var bytesRemaining:Int64

    var offset:Int64{
        return Int64(data.count)
    }
    private (set) var data:Data = Data()
    var incomingData:Data? {
        didSet{
            updateData()
        }
    }

    /*** Completion Blocks ***/
    var onMore:(()->())?



    //MARK:- Constructor
    init(fileName:String, bytesRemaining:Int64) {

        self.fileName = fileName
        self.bytesRemaining = bytesRemaining

        super.init()

        qualityOfService = .background
        queuePriority = .normal

    }



    //MARK:- Lifecycle methods
    override func start() {

        print("\(logClassName) Start ripping process \(bytesRemaining)")

        isExecuting = true
        isFinished = false

        onMore?()

    }


    //MARK:- Private methods
    private func updateData(){
        guard let incomingData = incomingData else { return }

        data += incomingData
        print("\(logClassName) Total \(offset) of \(bytesRemaining)")

        if bytesRemaining > offset{
            onMore?()
        }
        else{
            print("\(logClassName) Finished RIPPING")
            isExecuting = false
            isFinished = true
        }

    }



    //MARK:- Public methods




}

代码在后台运行，并要求在提供请求后使用onMore块提供更多数据。所以可以这样宣布：

func ripTrack(at index:Int, outputFormat:RecordQuality){

    let aTrack = cdTrackArray[0]

    trackOperation = TrackOperation(fileName: aTrack.name, bytesRemaining: aTrack.lengthBytes)

    trackOperation?.onMore = {
        print("\(self.logClassName) GIVE More Cookies!")

        self.dealWithOperation()

    }

    trackOperation?.completionBlock = {
        print("\(self.logClassName) COMPLETION BLOCK FOR Track Operation")
    }

    currentState = .ripping
    self.trackOperation?.start()

}


func websocketDidReceiveData(socket: WebSocketClient, data: Data) {

    trackOperation?.incomingData = data 

}

我在问题中提到的文件是当我被撕掉的时候，一段数据的音频轨道。