iOS で音声をリアルタイムアップロードする方法を学ぶ

    override init() {
        super.init()
        setupRecorder()
        setupAudioSession()
        enableBuiltInMic()
    }

    func setupRecorder() {
        let tempDir = URL(fileURLWithPath: NSTemporaryDirectory())
        let fileURL = tempDir.appendingPathComponent("recording.wav")

        do {
            let settings: [String: Any] = [
                AVFormatIDKey: Int(kAudioFormatLinearPCM),
                AVLinearPCMIsNonInterleaved: false,
                AVSampleRateKey: 44_100.0,
                AVNumberOfChannelsKey: isStereoSupported ? 2 : 1,
                AVLinearPCMBitDepthKey: 16
            ]
            recorder = try AVAudioRecorder(url: fileURL, settings: settings)
        } catch {
            fatalError("Unable to create audio recorder: \(error.localizedDescription)")
        }
        
        recorder.delegate = self
        recorder.isMeteringEnabled = true
        recorder.prepareToRecord()
    }

    func setupAudioSession() {
        do {
            let session = AVAudioSession.sharedInstance()
            try session.setCategory(.playAndRecord, options: [.defaultToSpeaker, .allowBluetooth])
            try session.setActive(true)
        } catch {
            fatalError("Failed to configure and activate session.")
        }
    }

    private func enableBuiltInMic() {
        // Get the shared audio session.
        let session = AVAudioSession.sharedInstance()
        
        // Find the built-in microphone input.
        guard let availableInputs = session.availableInputs,
              let builtInMicInput = availableInputs.first(where: { $0.portType == .builtInMic }) else {
            print("The device must have a built-in microphone.")
            return
        }
        
        // Make the built-in microphone input the preferred input.
        do {
            try session.setPreferredInput(builtInMicInput)
        } catch {
            print("Unable to set the built-in mic as the preferred input.")
        }
    }

    @discardableResult
    func record() -> Bool {
        let started = recorder.record()
        state = .recording
        return started
    }
    
    // Stops recording and calls the completion callback when the recording finishes.
    func stopRecording() {
        recorder.stop()
        state = .stopped
    }

extension AudioController: AVAudioRecorderDelegate {
    
    // AVAudioRecorderDelegate method.
    func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder, successfully flag: Bool) {
        
        let destURL = FileManager.default.urlInDocumentsDirectory(named: "recording.wav")
        try? FileManager.default.removeItem(at: destURL)
        try? FileManager.default.copyItem(at: recorder.url, to: destURL)
        recorder.prepareToRecord()
        
        audioURL = destURL
    }
}

    func play() {
        guard let url = audioURL else { print("No recording to play"); return }
        player = try? AVAudioPlayer(contentsOf: url)
        player?.isMeteringEnabled = true
        player?.delegate = self
        player?.play()
        state = .playing
    }
    
    func stopPlayback() {
        player?.stop()
        state = .stopped
    }

-(void)audioRecorderDidFinishRecording:(AVAudioRecorder *)recorder successfully:(BOOL)flag
{
NSLog(@"stoped");
    if (!stoped) {
        NSData *data = [NSData dataWithContentsOfURL:recorder.url];
        [self sendAudioToServer:data];
        [recorder record];
NSLog(@"stoped sent and restarted");
    }
}
- (IBAction)startRec:(id)sender {
if (!audioRecorder.recording)
{
    sendButton.enabled = YES;
    stopButton.enabled = YES;
    [audioRecorder record];
}
}

- (IBAction)sendToServer:(id)sender {
stoped = NO;
[audioRecorder stop];
}

- (IBAction)stop:(id)sender {
stopButton.enabled = NO;
sendButton.enabled = NO;
recordButton.enabled = YES;

stoped = YES;
if (audioRecorder.recording)
{
    [audioRecorder stop];
}
}

struct ContentView: View {
    let manager = AudioManager()

    var body: some View {
        VStack(spacing: 8) {
            Button {
                manager.engineStart()
            } label: {
                Text("Start engine!")
            }
            Button {
                manager.engineStop()
            } label: {
                Text("Stop engine!")
            }
        }
        .padding()
    }
}

final class AudioManager {
    let engine = AVAudioEngine()
    
    init() {
        configureAVAudioSession()
        configureEngine()
    }

    private func configureAVAudioSession() {
        try! AVAudioSession.sharedInstance()
            .setCategory(.playAndRecord, mode: .voiceChat, options: .allowBluetooth)
    }

    private func configureEngine() {
        let input = engine.inputNode
        let output = engine.outputNode
        let format = engine.inputNode.inputFormat(forBus: 0)

        engine.connect(
            input,
            to: output,
            format: format
        )
        engine.inputNode.volume = 1.0
    }

    func engineStart() {
        try! engine.start()

        let format = engine.inputNode.outputFormat(forBus: 0)
        engine.inputNode.installTap(onBus: 0, bufferSize: 1024, format: format) { buffer, _ in
            print(buffer)
        }
    }

    func engineStop() {
        engine.stop()
        
        engine.inputNode.removeTap(onBus: 0)
    }
}

<AVAudioFormat 0x283fa20d0:  1 ch,  48000 Hz, Float32>

final class AudioManager {
    let engine = AVAudioEngine()

    var convertedStreamBasicDescription = AudioStreamBasicDescription(
        mSampleRate: 8000,
        mFormatID: kAudioFormatULaw,
        mFormatFlags: 0,
        mBytesPerPacket: 1,
        mFramesPerPacket: 1,
        mBytesPerFrame: 1,
        mChannelsPerFrame: 1,
        mBitsPerChannel: 8,
        mReserved: 0
    )
    var convertedAudioFormat: AVAudioFormat {
        AVAudioFormat(streamDescription: &convertedStreamBasicDescription)!
    }

    // ...

    func engineStart() {
        try! engine.start()

        let format = engine.inputNode.outputFormat(forBus: 0)
        engine.inputNode.installTap(onBus: 0, bufferSize: 1024, format: format) { [weak self] buffer, _ in
            guard let self else { return }

            let convertedBuffer = AVAudioPCMBuffer(pcmFormat: self.convertedAudioFormat, frameCapacity: buffer.frameCapacity)!

            let converter = AVAudioConverter(from: format, to: self.convertedAudioFormat)

            var error: NSError? = nil
            converter?.convert(to: convertedBuffer, error: &error) { _, inputStatus in
                inputStatus.pointee = .haveData
                return buffer
            }
        }
    }
    // ...
}

extension AVAudioPCMBuffer {
    func data() -> Data {
        let channelCount = 1  // given PCMBuffer channel count is 1
        let channels = UnsafeBufferPointer(start: self.floatChannelData, count: channelCount)
        let ch0Data = NSData(bytes: channels[0], length:Int(self.frameCapacity * self.format.streamDescription.pointee.mBytesPerFrame))
        return ch0Data as Data
    }
}

extension AVAudioPCMBuffer {
    func data() -> Data? {
        guard let channels = self.floatChannelData else { return nil }
        let ch0Data = NSData(bytes: channels[0], length:Int(self.frameCapacity * self.format.streamDescription.pointee.mBytesPerFrame))
        return ch0Data as Data
    }
}