Recording audio in Swift

Audio Problem Overview

Does anyone know where I can find info on how to record audio in a Swift application? I've been looking at some of the audio playback examples but I can't seem to be able to find anything on implementing the audio recording. Thanks

Audio Solutions

Solution 1 - Audio

In Swift 3

Add framework AVFoundation
**In info.plist add key value

> Key = Privacy - Microphone Usage Description and Value = For using > microphone

(the apps will crash if you don't provide the value - description why you are asking for the permission)**

Import AVFoundation & AVAudioRecorderDelegate, AVAudioPlayerDelegate

 import AVFoundation

  class RecordVC: UIViewController , AVAudioRecorderDelegate, AVAudioPlayerDelegate

Create button for record audio & play audio , and label for display recording timing & give outlets and action as start_recording , play_recording & declare some variables which we will use later

 @IBOutlet var recordingTimeLabel: UILabel!
 @IBOutlet var record_btn_ref: UIButton!
 @IBOutlet var play_btn_ref: UIButton!
 
 var audioRecorder: AVAudioRecorder!
 var audioPlayer : AVAudioPlayer!
 var meterTimer:Timer!
 var isAudioRecordingGranted: Bool!
 var isRecording = false
 var isPlaying = false

In viewDidLoad check record permission

 override func viewDidLoad() {
     super.viewDidLoad()
     check_record_permission()
 }

 func check_record_permission()
 {
     switch AVAudioSession.sharedInstance().recordPermission() {
     case AVAudioSessionRecordPermission.granted:
         isAudioRecordingGranted = true
         break
     case AVAudioSessionRecordPermission.denied:
         isAudioRecordingGranted = false
         break
     case AVAudioSessionRecordPermission.undetermined:
         AVAudioSession.sharedInstance().requestRecordPermission({ (allowed) in
                 if allowed {
                     self.isAudioRecordingGranted = true
                 } else {
                     self.isAudioRecordingGranted = false
                 }
         })
         break
     default:
         break
     }
 }

generate path where you want to save that recording as myRecording.m4a

 func getDocumentsDirectory() -> URL
 {
     let paths = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)
     let documentsDirectory = paths[0]
     return documentsDirectory
 }

 func getFileUrl() -> URL
 {
     let filename = "myRecording.m4a"
     let filePath = getDocumentsDirectory().appendingPathComponent(filename)
 return filePath
 }

Setup the recorder

 func setup_recorder()
 {
     if isAudioRecordingGranted
     {
         let session = AVAudioSession.sharedInstance()
         do
         {
             try session.setCategory(AVAudioSessionCategoryPlayAndRecord, with: .defaultToSpeaker)
             try session.setActive(true)
             let settings = [
                 AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
                 AVSampleRateKey: 44100,
                 AVNumberOfChannelsKey: 2,
                 AVEncoderAudioQualityKey:AVAudioQuality.high.rawValue
             ]
             audioRecorder = try AVAudioRecorder(url: getFileUrl(), settings: settings)
             audioRecorder.delegate = self
             audioRecorder.isMeteringEnabled = true
             audioRecorder.prepareToRecord()
         }
         catch let error {
             display_alert(msg_title: "Error", msg_desc: error.localizedDescription, action_title: "OK")
         }
     }
     else
     {
         display_alert(msg_title: "Error", msg_desc: "Don't have access to use your microphone.", action_title: "OK")
     }
 }

Start recording when button start_recording press & display seconds using updateAudioMeter, & if recording is start then finish the recording

 @IBAction func start_recording(_ sender: UIButton)
 {
     if(isRecording)
     {
         finishAudioRecording(success: true)
         record_btn_ref.setTitle("Record", for: .normal)
         play_btn_ref.isEnabled = true
         isRecording = false
     }
     else
     {
         setup_recorder()
     
         audioRecorder.record()
         meterTimer = Timer.scheduledTimer(timeInterval: 0.1, target:self, selector:#selector(self.updateAudioMeter(timer:)), userInfo:nil, repeats:true)
         record_btn_ref.setTitle("Stop", for: .normal)
         play_btn_ref.isEnabled = false
         isRecording = true
     }
 }

 func updateAudioMeter(timer: Timer)
 {
     if audioRecorder.isRecording
     {
         let hr = Int((audioRecorder.currentTime / 60) / 60)
         let min = Int(audioRecorder.currentTime / 60)
         let sec = Int(audioRecorder.currentTime.truncatingRemainder(dividingBy: 60))
         let totalTimeString = String(format: "%02d:%02d:%02d", hr, min, sec)
         recordingTimeLabel.text = totalTimeString
         audioRecorder.updateMeters()
     }
 }

 func finishAudioRecording(success: Bool)
 {
     if success
     {
         audioRecorder.stop()
         audioRecorder = nil
         meterTimer.invalidate()
         print("recorded successfully.")
     }
     else
     {
         display_alert(msg_title: "Error", msg_desc: "Recording failed.", action_title: "OK")
     }
 }

Play the recording

 func prepare_play()
 {
     do
     {
         audioPlayer = try AVAudioPlayer(contentsOf: getFileUrl())
         audioPlayer.delegate = self
         audioPlayer.prepareToPlay()
     }
     catch{
         print("Error")
     }
 }

 @IBAction func play_recording(_ sender: Any)
 {
     if(isPlaying)
     {
         audioPlayer.stop()
         record_btn_ref.isEnabled = true
         play_btn_ref.setTitle("Play", for: .normal)
         isPlaying = false
     }
     else
     {
         if FileManager.default.fileExists(atPath: getFileUrl().path)
         {
             record_btn_ref.isEnabled = false
             play_btn_ref.setTitle("pause", for: .normal)
             prepare_play()
             audioPlayer.play()
             isPlaying = true
         }
         else
         {
             display_alert(msg_title: "Error", msg_desc: "Audio file is missing.", action_title: "OK")
         }
     }
 }

When recording is finish enable the play button & when play is finish enable the record button

 func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder, successfully flag: Bool)
 {
     if !flag
     {
         finishAudioRecording(success: false)
     }
     play_btn_ref.isEnabled = true
 }

 func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool)
 {
     record_btn_ref.isEnabled = true
 }

Generalize function for display alert

 func display_alert(msg_title : String , msg_desc : String ,action_title : String)
 {
     let ac = UIAlertController(title: msg_title, message: msg_desc, preferredStyle: .alert)
     ac.addAction(UIAlertAction(title: action_title, style: .default)
     {
         (result : UIAlertAction) -> Void in
     _ = self.navigationController?.popViewController(animated: true)
     })
     present(ac, animated: true)
 }

Solution 2 - Audio

Here is code.You can record easily.Write this code on IBAction.It will save the recording in Documents by name recordTest.caf

//declare instance variable 
var audioRecorder:AVAudioRecorder!
func record(){        
    var audioSession:AVAudioSession = AVAudioSession.sharedInstance()
    audioSession.setCategory(AVAudioSessionCategoryPlayAndRecord, error: nil)
    audioSession.setActive(true, error: nil)
    
    var documents: AnyObject = NSSearchPathForDirectoriesInDomains( NSSearchPathDirectory.DocumentDirectory,  NSSearchPathDomainMask.UserDomainMask, true)[0]
    var str =  documents.stringByAppendingPathComponent("recordTest.caf")
    var url = NSURL.fileURLWithPath(str as String)
    
    var recordSettings = [AVFormatIDKey:kAudioFormatAppleIMA4,
        AVSampleRateKey:44100.0,
        AVNumberOfChannelsKey:2,AVEncoderBitRateKey:12800,
        AVLinearPCMBitDepthKey:16,
        AVEncoderAudioQualityKey:AVAudioQuality.Max.rawValue]
    
    println("url : \(url)")
    var error: NSError?
    
    audioRecorder = AVAudioRecorder(URL:url, settings: recordSettings, error: &error)
    if let e = error {
        println(e.localizedDescription)
    } else {
        audioRecorder.record()
    }        
}

Solution 3 - Audio

Swift2 version of @codester's answer.

func record() {
    //init
    let audioSession:AVAudioSession = AVAudioSession.sharedInstance()
    
    //ask for permission
    if (audioSession.respondsToSelector("requestRecordPermission:")) {
        AVAudioSession.sharedInstance().requestRecordPermission({(granted: Bool)-> Void in
            if granted {
                print("granted")
                
                //set category and activate recorder session
                try! audioSession.setCategory(AVAudioSessionCategoryPlayAndRecord)
                try! audioSession.setActive(true)
                
                
                //get documnets directory
                let documentsDirectory = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0]
                let fullPath = documentsDirectory.stringByAppendingPathComponent("voiceRecording.caf")
                let url = NSURL.fileURLWithPath(fullPath)
                
                //create AnyObject of settings
                let settings: [String : AnyObject] = [
                    AVFormatIDKey:Int(kAudioFormatAppleIMA4), //Int required in Swift2
                    AVSampleRateKey:44100.0,
                    AVNumberOfChannelsKey:2,
                    AVEncoderBitRateKey:12800,
                    AVLinearPCMBitDepthKey:16,
                    AVEncoderAudioQualityKey:AVAudioQuality.Max.rawValue
                ]
                
                //record
                try! self.audioRecorder = AVAudioRecorder(URL: url, settings: settings)

            } else{
                print("not granted")
            }
        })
    }
    
}

Solution 4 - Audio

In addition to previous answers, I tried to make it work on Xcode 7.2 and I couldn't hear any sound after, neither when I sent the file via email. No warning or exception. So I changed settings to the following and stored as an .m4a file.

let recordSettings = [AVSampleRateKey : NSNumber(float: Float(44100.0)),
    AVFormatIDKey : NSNumber(int: Int32(kAudioFormatMPEG4AAC)),
    AVNumberOfChannelsKey : NSNumber(int: 1),
    AVEncoderAudioQualityKey : NSNumber(int: Int32(AVAudioQuality.Medium.rawValue))]

After that I could listen to sound. For saving the file, I added this on viewDidLoad to initialise the recorder:

let audioSession = AVAudioSession.sharedInstance()
    do {
        try audioSession.setCategory(AVAudioSessionCategoryPlayAndRecord)
        try audioRecorder = AVAudioRecorder(URL: self.directoryURL()!,
            settings: recordSettings)
        audioRecorder.prepareToRecord()
    } catch {
    }

And for creating the directory:

func directoryURL() -> NSURL? {
    let fileManager = NSFileManager.defaultManager()
    let urls = fileManager.URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)
    let documentDirectory = urls[0] as NSURL
    let soundURL = documentDirectory.URLByAppendingPathComponent("sound.m4a")
    return soundURL 
}

I also add the actions used to start recording, stop, and play after

@IBAction func doRecordAction(sender: AnyObject) {
    if !audioRecorder.recording {
        let audioSession = AVAudioSession.sharedInstance()
        do {
            try audioSession.setActive(true)
            audioRecorder.record()
        } catch {
        }
   }
}
@IBAction func doStopRecordingAction(sender: AnyObject) {
    audioRecorder.stop()
    let audioSession = AVAudioSession.sharedInstance()

    do {
        try audioSession.setActive(false)
    } catch {
    }
}

@IBAction func doPlayAction(sender: AnyObject) {
    if (!audioRecorder.recording){
        do {
            try audioPlayer = AVAudioPlayer(contentsOfURL: audioRecorder.url)
            audioPlayer.play()
        } catch {
        }
    }
}

Solution 5 - Audio

Here audio recorder with simple interface written on Swift 4.2 .

final class AudioRecorderImpl: NSObject {
  private let session = AVAudioSession.sharedInstance()
  private var player: AVAudioPlayer?
  private var recorder: AVAudioRecorder?
  private lazy var permissionGranted = false
  private lazy var isRecording = false
  private lazy var isPlaying = false
  private var fileURL: URL?
  private let settings = [
    AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
    AVSampleRateKey: 44100,
    AVNumberOfChannelsKey: 2,
    AVEncoderAudioQualityKey:AVAudioQuality.high.rawValue
  ]
  
  override init() {
    fileURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first?.appendingPathComponent("note.m4a")
  }
  
  func record(to url: URL?) {
    guard permissionGranted,
      let url = url ?? fileURL else { return }
    
    setupRecorder(url: url)
    
    if isRecording {
      stopRecording()
    }
    
    isRecording = true
    recorder?.record()
  }
  
  func stopRecording() {
    isRecording = false
    recorder?.stop()
    try? session.setActive(false)
  }
  
  func play(from url: URL?) {
    guard let url = url ?? fileURL else { return }
    
    setupPlayer(url: url)
    
    if isRecording {
      stopRecording()
    }
    
    if isPlaying {
      stopPlaying()
    }
    
    if FileManager.default.fileExists(atPath: url.path) {
      isPlaying = true
      setupPlayer(url: url)
      player?.play()
    }
  }
  
  func stopPlaying() {
    player?.stop()
  }
  
  func pause() {
    player?.pause()
  }
  
  func resume() {
    if player?.isPlaying == false {
      player?.play()
    }
  }
  
  func checkPermission(completion: ((Bool) -> Void)?) {
    func assignAndInvokeCallback(_ granted: Bool) {
      self.permissionGranted = granted
      completion?(granted)
    }
    
    switch session.recordPermission {
    case .granted:
      assignAndInvokeCallback(true)
      
    case .denied:
      assignAndInvokeCallback(false)
      
    case .undetermined:
      session.requestRecordPermission(assignAndInvokeCallback)
    }
  }
}

extension AudioRecorderImpl: AVAudioRecorderDelegate, AVAudioPlayerDelegate {
  
}

private extension AudioRecorderImpl {
  func setupRecorder(url: URL) {
    guard
      permissionGranted else { return }
    try? session.setCategory(.playback, mode: .default)
    try? session.setActive(true)
    let settings = [
      AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
      AVSampleRateKey: 44100,
      AVNumberOfChannelsKey: 2,
      AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
    ]
    recorder = try? AVAudioRecorder(url: url, settings: settings)
    recorder?.delegate = self
    recorder?.isMeteringEnabled = true
    recorder?.prepareToRecord()
  }
  
  func setupPlayer(url: URL) {
    player = try? AVAudioPlayer(contentsOf: url)
    player?.delegate = self
    player?.prepareToPlay()
  }
}

Solution 6 - Audio

Code in Class file Using Swift 4

Class is AGAudioRecorder

Code is

class AudioRecordViewController: UIViewController {

    @IBOutlet weak var recodeBtn: UIButton!
    @IBOutlet weak var playBtn: UIButton!

    var state: AGAudioRecorderState = .Ready
    
    var recorder: AGAudioRecorder = AGAudioRecorder(withFileName: "TempFile")
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        recodeBtn.setTitle("Recode", for: .normal)
        playBtn.setTitle("Play", for: .normal)
        recorder.delegate = self
    }
    
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }
    
    @IBAction func recode(_ sender: UIButton) {
        recorder.doRecord()
    }
    
    @IBAction func play(_ sender: UIButton) {
        recorder.doPlay()
    }
}

extension AudioRecordViewController: AGAudioRecorderDelegate {
    func agAudioRecorder(_ recorder: AGAudioRecorder, withStates state: AGAudioRecorderState) {
        switch state {
        case .error(let e): debugPrint(e)
        case .Failed(let s): debugPrint(s)

        case .Finish:
            recodeBtn.setTitle("Recode", for: .normal)

        case .Recording:
            recodeBtn.setTitle("Recoding Finished", for: .normal)

        case .Pause:
            playBtn.setTitle("Pause", for: .normal)

        case .Play:
            playBtn.setTitle("Play", for: .normal)

        case .Ready:
            recodeBtn.setTitle("Recode", for: .normal)
            playBtn.setTitle("Play", for: .normal)
            refreshBtn.setTitle("Refresh", for: .normal)
        }
        debugPrint(state)
    }
    
    func agAudioRecorder(_ recorder: AGAudioRecorder, currentTime timeInterval: TimeInterval, formattedString: String) {
        debugPrint(formattedString)
    }
}

Solution 7 - Audio

For Swift 5,

 func setup_recorder()
{
    if isAudioRecordingGranted
    {
        let session = AVAudioSession.sharedInstance()
        do
        {
            try session.setCategory(.playAndRecord, mode: .default)
            try session.setActive(true)
            let settings = [
                AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
                AVSampleRateKey: 44100,
                AVNumberOfChannelsKey: 2,
                AVEncoderAudioQualityKey:AVAudioQuality.high.rawValue
            ]
            audioRecorder = try AVAudioRecorder(url: getFileUrl(), settings: settings)
            audioRecorder.delegate = self
            audioRecorder.isMeteringEnabled = true
            audioRecorder.prepareToRecord()
        }
        catch let error {
            display_alert(msg_title: "Error", msg_desc: error.localizedDescription, action_title: "OK")
        }
    }
    else
    {
        display_alert(msg_title: "Error", msg_desc: "Don't have access to use your microphone.", action_title: "OK")
    }

Solution 8 - Audio

Swift 3 Code Version: Complete Solution for Audio Recording!

import UIKit
import AVFoundation

class ViewController: UIViewController, AVAudioRecorderDelegate {
    
    //Outlets
    @IBOutlet weak var recordingTimeLabel: UILabel!
    
    //Variables
    var audioRecorder: AVAudioRecorder!
    var meterTimer:Timer!
    var isAudioRecordingGranted: Bool!
    
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        switch AVAudioSession.sharedInstance().recordPermission() {
        case AVAudioSessionRecordPermission.granted:
            isAudioRecordingGranted = true
            break
        case AVAudioSessionRecordPermission.denied:
            isAudioRecordingGranted = false
            break
        case AVAudioSessionRecordPermission.undetermined:
            AVAudioSession.sharedInstance().requestRecordPermission() { [unowned self] allowed in
                DispatchQueue.main.async {
                    if allowed {
                        self.isAudioRecordingGranted = true
                    } else {
                        self.isAudioRecordingGranted = false
                    }
                }
            }
            break
        default:
            break
        }
    }
    
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        
        audioRecorder = nil
    }
    
    //MARK:- Audio recorder buttons action.
    @IBAction func audioRecorderAction(_ sender: UIButton) {
        
        if isAudioRecordingGranted {
            
            //Create the session.
            let session = AVAudioSession.sharedInstance()
            
            do {
                //Configure the session for recording and playback.
                try session.setCategory(AVAudioSessionCategoryPlayAndRecord, with: .defaultToSpeaker)
                try session.setActive(true)
                //Set up a high-quality recording session.
                let settings = [
                    AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
                    AVSampleRateKey: 44100,
                    AVNumberOfChannelsKey: 2,
                    AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
                ]
                //Create audio file name URL
                let audioFilename = getDocumentsDirectory().appendingPathComponent("audioRecording.m4a")
                //Create the audio recording, and assign ourselves as the delegate
                audioRecorder = try AVAudioRecorder(url: audioFilename, settings: settings)
                audioRecorder.delegate = self
                audioRecorder.isMeteringEnabled = true
                audioRecorder.record()
                meterTimer = Timer.scheduledTimer(timeInterval: 0.1, target:self, selector:#selector(self.updateAudioMeter(timer:)), userInfo:nil, repeats:true)
            }
            catch let error {
                print("Error for start audio recording: \(error.localizedDescription)")
            }
        }
    }
    
    @IBAction func stopAudioRecordingAction(_ sender: UIButton) {
        
        finishAudioRecording(success: true)
        
    }
    
    func finishAudioRecording(success: Bool) {
        
        audioRecorder.stop()
        audioRecorder = nil
        meterTimer.invalidate()
        
        if success {
            print("Recording finished successfully.")
        } else {
            print("Recording failed :(")
        }
    }
    
    func updateAudioMeter(timer: Timer) {
        
        if audioRecorder.isRecording {
            let hr = Int((audioRecorder.currentTime / 60) / 60)
            let min = Int(audioRecorder.currentTime / 60)
            let sec = Int(audioRecorder.currentTime.truncatingRemainder(dividingBy: 60))
            let totalTimeString = String(format: "%02d:%02d:%02d", hr, min, sec)
            recordingTimeLabel.text = totalTimeString
            audioRecorder.updateMeters()
        }
    }
    
    func getDocumentsDirectory() -> URL {
        
        let paths = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)
        let documentsDirectory = paths[0]
        return documentsDirectory
    }
    
    //MARK:- Audio recoder delegate methods
    func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder, successfully flag: Bool) {
        
        if !flag {
            finishAudioRecording(success: false)
        }
    }
}

Content Type	Original Author	Original Content on Stackoverflow
Question	Michael Bain	View Question on Stackoverflow
Solution 1 - Audio	Mili Shah	View Answer on Stackoverflow
Solution 2 - Audio	codester	View Answer on Stackoverflow
Solution 3 - Audio	Kristian	View Answer on Stackoverflow
Solution 4 - Audio	Andreas777	View Answer on Stackoverflow
Solution 5 - Audio	Bohdan Savych	View Answer on Stackoverflow
Solution 6 - Audio	AshvinGudaliya	View Answer on Stackoverflow
Solution 7 - Audio	ssowri1	View Answer on Stackoverflow
Solution 8 - Audio	mriaz0011	View Answer on Stackoverflow