DEV Community: Muhammad Rasyad Caesarardhi

Leveraging Xcodegen for Hassle-free iOS Development

Muhammad Rasyad Caesarardhi — Sun, 01 Sep 2024 01:02:12 +0000

Why Use XcodeGen?

Managing Xcode project files manually can quickly become a cumbersome task, especially as projects grow in complexity. With multiple targets, configurations, and dependencies, it's easy for inconsistencies and errors to creep in. XcodeGen addresses these issues by automating the generation of Xcode project files from a configuration file, usually written in YAML or JSON.

Key Benefits:

Consistency Across Teams: XcodeGen ensures that every developer generates the same project structure, minimizing version control conflicts and reducing onboarding time for new team members.
Scalability and Maintainability: As projects evolve, XcodeGen simplifies managing multiple targets and build configurations, making it easier to scale and maintain the project over time.
Reducing Manual Work: By automating the project setup, XcodeGen eliminates the need for tedious manual configuration, reducing the risk of human error.

Current State

In many iOS development teams, managing the Xcode project file (.xcodeproj) manually is the norm. This approach has its drawbacks, particularly in larger teams or projects:

Merge Conflicts: The .xcodeproj file is notorious for generating merge conflicts in version control systems. These conflicts are often difficult to resolve and can lead to wasted time and frustration.
Inconsistent Configurations: When multiple developers manually manage project settings, inconsistencies can arise, leading to unexpected build issues or discrepancies between development environments.
Time-Consuming Processes: Setting up new targets, schemes, or configurations manually can be time-consuming, diverting focus from actual development work.

Our team experienced these issues firsthand. As the project grew, we found ourselves constantly dealing with frustrating conflicts in the .xcodeproj file. The merge conflicts were so frequent and disruptive that they started to slow down our progress significantly. This frustration led us to explore alternatives, and we finally decided to adopt XcodeGen mid-development. It was a game-changer, resolving our conflicts and making the project more manageable.

How Does It Improve Our Development Team?

XcodeGen significantly enhances team productivity and collaboration by addressing several common pain points in iOS development.

Improved Collaboration:

With a single source of truth for the project configuration, XcodeGen minimizes the chances of inconsistencies and conflicts. Team members can work more effectively, knowing that any changes to the project settings are controlled and predictable.

Easier Configuration Management:

Centralizing the project configuration in a project.yml file simplifies making global changes across the project. Whether adding a new target, modifying build settings, or managing dependencies, XcodeGen makes it easy to update and maintain the project.

How to Implement It?

First Configuration of XcodeGen

Getting started with XcodeGen is straightforward. Here’s a step-by-step guide to setting up your first configuration:

Installation:
- Install XcodeGen via Homebrew by running (Alternatively, download and install it from the official GitHub repository):
```
 brew install xcodegen
```
Adding .gitignore:
- Before configuring XcodeGen, ensure that you have a .gitignore file set up in your project. This is crucial to avoid committing the generated .xcodeproj file to your repository.
- Add the following to your .gitignore:
```
 # Ignore Xcode project files
 *.xcworkspace/
 *.xcodeproj/
```

Creating project.yml:

Create a new file named project.yml in the root of your project directory. This file will define the structure and settings of your Xcode project.
Here’s our implementation of project.yml file which defines four targets: App (an iOS application), PukPuk-Tests (a test suite and PukPukIntentsExtension and PukPukIntentsExtensionUI for Extensions (shortcut)

 name: PukPuk
 settings:
  MARKETING_VERSION: '1.0'
  CURRENT_PROJECT_VERSION: 1
 options:
  bundleIdPrefix: com.PukPuk

 targets:
  App:
   type: application
   platform: iOS
   sources: [PukPuk]
   resources: [Resources]
   settings:
    PRODUCT_BUNDLE_IDENTIFIER: com.PukPuk.App
    INFOPLIST_FILE: PukPuk/Info.plist
    GENERATE_INFOPLIST_FILE: true
    base:
     TARGETED_DEVICE_FAMILY: '1' # iPhone only
     SUPPORTED_INTERFACE_ORIENTATIONS: 'UIInterfaceOrientationPortrait' # Portrait only

  PukPuk-Tests:
   type: bundle.unit-test
   platform: iOS
   sources: [PukPuk-Tests]
   dependencies:
    - target: App
   settings:
    base:
     INFOPLIST_FILE: PukPuk/Info.plist
     GENERATE_INFOPLIST_FILE: true
     TEST_HOST: '$(BUILT_PRODUCTS_DIR)/App.app/App'
     BUNDLE_LOADER: '$(TEST_HOST)'

  PukPukIntentsExtension:
   type: app-extension
   platform: iOS
   sources: [PukPukIntentsExtension]
   settings:
    PRODUCT_BUNDLE_IDENTIFIER: com.PukPuk.AppIntentsExtension
    INFOPLIST_FILE: PukPukIntentsExtension/Info.plist
    GENERATE_INFOPLIST_FILE: true
   dependencies:
    - target: App

  PukPukIntentsExtensionUI:
   type: app-extension
   platform: iOS
   sources: [PukPukIntentsExtensionUI]
   settings:
    PRODUCT_BUNDLE_IDENTIFIER: com.PukPuk.AppIntentsExtensionUI
    INFOPLIST_FILE: PukPukIntentsExtensionUI/Info.plist
    GENERATE_INFOPLIST_FILE: true
   dependencies:
    - target: PukPukIntentsExtension

 schemes:
  PukPuk:
   build:
    targets:
     App: all
     PukPuk-Tests: all
     PukPukIntentsExtension: all
     PukPukIntentsExtensionUI: all
   test:
    targets:
     - name: PukPuk-Tests
       gatherCoverageData: true

Generating the Xcode Project:
- To generate the Xcode project based on the project.yml configuration., run:
```
 xcodegen generate
```
Adding ci_post_clone.sh:
- To ensure the project is correctly generated in your CI environment, create a ci_post_clone.sh script in a folder named ci_scripts:
```
 mkdir -p ci_scripts
 touch ci_scripts/ci_post_clone.sh
```

Add the following content to ci_post_clone.sh:

 #!/bin/bash

 # Exit immediately if a command exits with a non-zero status
 set -e

 # Print commands and their arguments as they are executed
 set -x

 # Install Homebrew if it's not already installed
 if ! command -v brew &>/dev/null; then
    echo "Homebrew not found. Installing Homebrew..."
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
 fi

 # Install xcodegen if it's not already installed
 if ! command -v xcodegen &>/dev/null; then
    echo "xcodegen not found. Installing xcodegen..."
    brew install xcodegen
 fi

 # Clean any previous builds or project files
 echo "Cleaning previous builds..."
 rm -rf ./build
 rm -rf ./DerivedData
 rm -rf ./YourProject.xcodeproj

 echo "Moving to the project directory..."
 cd ../
 # Generate the Xcode project using xcodegen
 echo "Generating Xcode project..."
 xcodegen generate

 # # Install CocoaPods dependencies if your project uses CocoaPods
 # if [ -f "Podfile" ]; then
 #  echo "Installing CocoaPods dependencies..."
 #  pod install
 # fi

 echo "Pre-build setup complete!"

Make sure to set the script as executable:
```
 chmod +x ci_scripts/ci_post_clone.sh
```
This script ensures that every time the CI pipeline runs, it installs XcodeGen and generates the project before building.

Conclusion

XcodeGen is a powerful tool for automating and streamlining iOS project management, offering significant benefits in terms of consistency, maintainability, and collaboration. By integrating XcodeGen into your development workflow, you can reduce manual work, minimize errors, and improve team productivity. Whether you're working on a small project or a large-scale app with multiple targets and configurations, XcodeGen is a must-have tool for modern iOS development.

Customizing Calendar with FSCalendar in SwiftUI

Muhammad Rasyad Caesarardhi — Sat, 27 Jul 2024 00:44:06 +0000

Welcome back to my blog on front-end development, code, and iOS development. here, I will tell you about customizing the view of a calendar in SwiftUI using the FSCalendar package (https://github.com/WenchaoD/FSCalendar).

Why do we need a custom calendar?

First of all, why do we need a custom calendar? The answer is that we need a custom calendar that can show weekly views and not monthly views. second, we want to customize just part of the component from the calendar. for example, part of the background color, part of the text color, adding an image to the calendar to build streaks or adding data and events.

Duolingo Streaks Calendar (https://preview.redd.it/what-do-the-colors-mean-on-the-streak-calendar-v0-0iynzx8lp3pa1.png?width=337&format=png&auto=webp&s=b529e874b8610975f63c820b36665dcd434af4fe)

native calendars that are available natively in the SwiftUI can’t afford to do that. hence, we are in dire need of a custom calendar that accommodates all of it.

Luckily, we have a great repository for this custom calendar in iOS development projects. it is called FSCalendar (https://github.com/WenchaoD/FSCalendar). it is a truly great project that accommodates our needs to build a custom calendar with images, custom text color, custom data, and events.

Custom calendar implementation using FSCalendar (https://cloud.githubusercontent.com/assets/5186464/10262249/4fabae40-69f2-11e5-97ab-afbacd0a3da2.jpg)

How to import it?

now, how do we import the package? first of all, we need to open our Xcode projects. Next, add package dependencies to it.

and then input the repository URL (github.com/WenchaoD/FSCalendar) to the field “search or enter package URL”.

it would look like this

and then click Add Package. wait until the fetching is finished, and we are ready to go!

How do you customize the element in it?

Creating ContentView

below here is the full code of contentView the home of our calendar:



//
//  ContentView.swift
//  Calendar
//
//  Created by Muhammad Rasyad Caesarardhi on 14/07/24.
//

import SwiftUI

struct ContentView: View {
    @State private var dictionaryOfDateWithImage: [Date: ImageResource] = [
        getYesterdayDate(): .emoAnxiety,
        getTodayDate(): .emoHappy,
        getDateBySubstracting(substractor: -6): .emoFreeze
    ]
    @State private var selectedDate: Date = .init()

    var body: some View {
        ScrollView {
            VStack {
                FSCalendarView(selectedDate: $selectedDate, dictionaryOfDateWithImage: $dictionaryOfDateWithImage)
                    .frame(height: 300)
            }.onChange(of: [selectedDate]) {
                print(formatDateToUTC7(date: selectedDate))
            }
        }
        .padding()
    }

    func formatDateToUTC7(date: Date) -> String {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
        formatter.timeZone = TimeZone(secondsFromGMT: 7 * 3600)
        return formatter.string(from: date)
    }
}

// Helper Function for Date
func getYesterdayDate() -> Date {
    return getDateBySubstracting(substractor: -1)
}

func getDateBySubstracting(substractor: Int) -> Date {
    return Calendar.current.date(byAdding: .day, value: substractor, to: Date()) ?? Date()
}

func getTodayDate() -> Date {
    return Date()
}

#Preview {
    ContentView()
}

on the above code, we do some things:

we initialized State or mock Published from viewModel for the data used in the Calendar. The data type we use is a dictionary because it can be read quickly with indexing. more on this in the Calendar code.
we initialized the State for the selected date
we bind each state to the Calendar using $selectedDate and $dictionaryOfDateWithImage
we also created a helper function to get today's date, yesterday's date, and any date by subtracting it from today's date (+1 is tomorrow, -1 is yesterday)

Creating FSCalendarView (this is the main part of the calendar)

Step 1: Adding UIViewRepresentable

Since FSCalendarView is built on top of UIKit, we need UIViewRepresentable protocol to make it works with SwiftUI



    struct FSCalendarView: UIViewRepresentable {

Step 2: Add State Binding

Add Binding to the dictionary and selectedDate from ContentView. Dictionary of Date with image will be used to defined each date have what image to show.



    @Binding var selectedDate: Date
    @Binding var dictionaryOfDateWithImage: [Date: ImageResource]

Step 3: Initialize coordinator and appearence

here, we pass the dictionary of date with image associate with the date to the Coordinator, which handle re-render and how to show the calendar to the view.



    // FSCalendarView
    @Binding var selectedDate: Date
    @Binding var dictionaryOfDateWithImage: [Date: ImageResource]

    func makeCoordinator() -> Coordinator {
      Coordinator(self, dateWithImageResourceDict: dictionaryOfDateWithImage)
    }

    func makeUIView(context: Context) -> FSCalendar {
      let calendar = FSCalendar()
      calendar.delegate = context.coordinator
      calendar.dataSource = context.coordinator
      calendar.appearance.selectionColor = .systemPurple
      // Remove today circle
      calendar.today = nil
      return calendar
    }

Step 4: Coordinator



    // Coordinator
    class Coordinator: NSObject, FSCalendarDataSource, FSCalendarDelegate, FSCalendarDelegateAppearance {
            var parent: FSCalendarView

            var dateWithImageResourceDict: [Date: ImageResource]

            init(_ calender: FSCalendarView, dateWithImageResourceDict: [Date: ImageResource]) {
                self.parent = calender
                self.dateWithImageResourceDict = dateWithImageResourceDict
            }

Step 5: Adding image to the calendar

to add image to the calendar, we need to use imageFor helper in the FSCalendar. the way it works is, FSCalendar will always loop through each date in the year (because it’s just the way it works) → O(n), and when it hits on the same day with some date in the dictionary, the dictionary will return the value immediately → O(1). and it would be so fast! thats why we use dictionary here.



    // this function didSelect is used to set the selectedDate data state
    func calendar(_ calendar: FSCalendar, didSelect date: Date, at monthPosition: FSCalendarMonthPosition) {
      calendar.reloadData() // Refresh the calendar to apply the changes
      parent.selectedDate = date
    }

    // this function imageFor is used to set the image for the date
    func calendar(_ calendar: FSCalendar, imageFor date: Date) -> UIImage? {
      let targetSize = CGSize(width: 50, height: 50)
      if date == parent.selectedDate {
          return nil
      }

      if let stat = dateWithImageResourceDict.first(where: { Calendar.current.isDate($0.key, inSameDayAs: date) })?.value {
          return UIImage(resource: stat).resized(to: targetSize)
      }

      return nil
    }

    // If the user move the month, then the calendar works appropriately
    // Need reload to have fill colors display correctly after calendar page changes
    func calendarCurrentPageDidChange(_ calendar: FSCalendar) {
      calendar.reloadData()
    }

Step 6: Adding re-render using `didSet` and `updateUIView`

now you notice, when the state dictionary data has changed over the course of the app, the calendar didn’t change! why? turns out when using UIKit in SwiftUI, we need to use didSet to ask for re-render of the view! wow!



    // Coordinator
    var parent: FSCalendarView

    var dateWithImageResourceDict: [Date: ImageResource] {
      didSet {
        print("rerender")
      }
    }

    init(_ calender: FSCalendarView, dateWithImageResourceDict: [Date: ImageResource]) {
      self.parent = calender
      self.dateWithImageResourceDict = dateWithImageResourceDict
    }

we also need to ask updateUIView to do something first before re-render and to call the didSet in Coordinator. here we replace the dateDictionary with a new dictionary which was Bind to the state in ContentView and ask the calendar to reload the data to properly show it!



    // FSCalendarView
    func updateUIView(_ uiView: FSCalendar, context: Context) {
        // update the calendar view if necessary
        context.coordinator.dateWithImageResourceDict = dictionaryOfDateWithImage
        uiView.reloadData()
    }

Step 7: Full code!



//
//  FSCalendarView.swift
//  Calendar
//
//  Created by Muhammad Rasyad Caesarardhi on 14/07/24.
//

import FSCalendar
import SwiftUI
import UIKit

struct FSCalendarView: UIViewRepresentable {
    @Binding var selectedDate: Date
    @Binding var dictionaryOfDateWithImage: [Date: ImageResource]

    func makeCoordinator() -> Coordinator {
        Coordinator(self, dateWithImageResourceDict: dictionaryOfDateWithImage)
    }

    func makeUIView(context: Context) -> FSCalendar {
        let calendar = FSCalendar()
        calendar.delegate = context.coordinator
        calendar.dataSource = context.coordinator
        calendar.appearance.selectionColor = .systemPurple
        // Remove today circle
        calendar.today = nil
        return calendar
    }

    func updateUIView(_ uiView: FSCalendar, context: Context) {
        // update the calendar view if necessary
        context.coordinator.dateWithImageResourceDict = dictionaryOfDateWithImage
        uiView.reloadData()
    }

    // MARK: - Coordinator

    class Coordinator: NSObject, FSCalendarDataSource, FSCalendarDelegate, FSCalendarDelegateAppearance {
        var parent: FSCalendarView

        var dateWithImageResourceDict: [Date: ImageResource] {
            didSet {
                print("rerender")
            }
        }

        init(_ calender: FSCalendarView, dateWithImageResourceDict: [Date: ImageResource]) {
            self.parent = calender
            self.dateWithImageResourceDict = dateWithImageResourceDict
        }

        func calendar(_ calendar: FSCalendar, didSelect date: Date, at monthPosition: FSCalendarMonthPosition) {
            calendar.reloadData() // Refresh the calendar to apply the changes
            parent.selectedDate = date
        }

        func calendar(_ calendar: FSCalendar, imageFor date: Date) -> UIImage? {
            let targetSize = CGSize(width: 50, height: 50)
            if date == parent.selectedDate {
                return nil
            }

            if let stat = dateWithImageResourceDict.first(where: { Calendar.current.isDate($0.key, inSameDayAs: date) })?.value {
                return UIImage(resource: stat).resized(to: targetSize)
            }

            return nil
        }

        // Need reload to have fill colors display correctly after calendar page changes
        func calendarCurrentPageDidChange(_ calendar: FSCalendar) {
            calendar.reloadData()
        }
    }
}

extension UIImage {
    func resized(to size: CGSize) -> UIImage? {
        let renderer = UIGraphicsImageRenderer(size: size)
        return renderer.image { _ in
            self.draw(in: CGRect(origin: .zero, size: size))
        }
    }
}

youtube.com

Another Approach to Screen Routing in SwiftUI

Muhammad Rasyad Caesarardhi — Wed, 03 Jul 2024 00:18:02 +0000

First of all, why custom routing? there are several answers and reasons for implementing custom routing in Swift. from the technical side, implementing custom routing will significantly reduce boilerplate code that tends to be nasty to implement another view from other files. the approach is similar to when we use routing from web frameworks like ExpressJS, Laravel PHP, and others. Since it was similar to web frameworks, the amount of time needed to learn the pattern could be reduced. Thus, increased productivity when working with several developers because it was much easier to implement routing for different types of views in SwiftUI. this easiness would be very beneficial with lots and lots (and different types) of screens and Views by collaborating and delegating tasks of different views within the development team.

okay, enough talk. So how would we implement a web approach to routing in SwiftUI projects? first, we need to create 2 files of type swift. one file would store our Routing data and path that was chosen by the user or we could simply be called it a Router model.

// Model/Router.swift
import SwiftUI

class Router: ObservableObject {
    @Published var path: [Destination] = []

    enum Destination: String, Hashable {
        case SplashScreen, Home, Story, SecondStory
    }

    static let shared: Router = .init()
}

okay, let's talk about it some more, we see that SwiftUI was imported. this is because we need the ObservableObject protocol on our class for the Router model. we specifically need the @Published to make sure our path can be looked at by the Views later. we store our user routing and movement between screens/views activity within the path variable. the path variable is defined as an array of Destination enum. we use the enum Destination as a way to force the type of page that the user can visit. this enforces the code to look for the Destination in the enum first and helps bug checking even before the app is built into production. a singleton pattern is also used by using a shared variable and initializing the class itself inside its class to be shared with other files and views.

// Routes/RouteView.swift
import SwiftUI

struct RouteView: View {
    @StateObject private var navPath = Router.shared

    var body: some View {
        NavigationStack(path: $navPath.path) {
                // This is the root page view (you can use anything)
                // It does not have to be SplashScreenView
            SplashScreenView()
            // end of the root page view
                .toolbar(.hidden)
                .navigationDestination(for: Router.Destination.self) { destination in
                    switch destination {
                    case .Story:
                        StoryFirstView()
                    case .SecondStory:
                        StorySecondView()
                    case .Home:
                        HomeView()
                    case .SplashScreen:
                        SplashScreenView()
                    }
                }
        }
    }
}

Secondly, the RouteView. this is where we define the routes for our SwiftUI projects. the @StateObject variable of navPath is used to detect changes in the @Published variable in the Router model beforehand. thus it would render specifically based on the current new state of the array path in $navPath.path which is a binding. we also need to define every case of the Destination enum in the Router model or it would fail because the switch statement needs to be exhaustive of the Destination enum.

Lastly, you can call this RouteView in any place and it would have this nice web-like routing that would be beneficial for the development team.

cheers!

Leveraging Multicore Processors (M1 & M2) for Delay Sensitive Audio Application Development in MacOS

Muhammad Rasyad Caesarardhi — Fri, 31 May 2024 03:59:39 +0000

Hi, in this article i will tell you a story about how i make a delay sensitive application such as music tools apps. in this scenario, i build DrumCentral, a natively built virtual drum application on macOS.

It was built under two weeks and i learned a ton from this. Apple Tech such as Dispatch Queue, AV Foundation, SwiftUI, and Figma was used in this project.

Why Build a New Drum App?

I love playing drums! it sparks my joy and creativity with beats and music. In my spare time, I could casually listen to a song and find out that the beats are so nice that I want to make my version of the beat itself. I’m more enjoy playing the beat more on my Mac using Virtual Drumming (https://www.virtualdrumming.com) a web version app of Real Drum on Mobile Devices and iPad. but it was frustrating when I didn’t have an internet connection and I couldn’t wait for the webpage to load because I had other tasks to do (I play the drum for stress relief lol). So I decided to build my implementation of virtual drum natively on macOS using Swift and SwiftUI. Why Swift? well, Apple Tech surely sparks my interest in building something on top of their devices. So off we went and built the app, gathered all the assets, and sound, and coded it in less than 10 days.

How to detect a key being pressed?

the first challenge is to detect whether a key in a keyboard is being pressed. and how did we change the state of the app and re-render when a key is being pressed? I spent a lot of time trying to make it work, I tried pooling rate and registering CGKeyCode manually to a KeyboardManager and it works (unfortunately for Space Key only). so I tried again and found that SwiftUI has a native UseKeyPress Event that automatically detects key presses and handles re-render without implementing meticulous code and it was easy to read code. love it!

Text("").focusable()
  .focused($isFocused)
  .onAppear {
    isFocused = true
  }
  .onKeyPress(
    phases: .down,
    action: { keyPress in
      switch keyPress.characters {
      case "c":
        playSnare()
      case "x":
        playHiHat()
      default:
        print("default")
      }
      return .handled
    })

The trick is to make an empty Text Element that is focusable (if the element is not focused, the key press won’t update the UI). then, add the .onKeyPress function. when using .onKeyPress we can detect the key being pressed by using the parameters for action arguments like keyPress.characters.

How to play sound using AVFoundation

the next challenge is how do we play a sound inside a macOS? I gathered information and researched through the Apple documentation for developers and found out about AVFoundation. it was simple enough to play a sound using AVFoundation like the code below.

if let soundURL = Bundle.main.url(forResource: "hihat", withExtension: "wav") {
  do {
    audioPlayer = try AVAudioPlayer(contentsOf: soundURL)
    audioPlayer.prepareToPlay()
    audioPlayer.play()
  } catch {
    print("Error: Could not initialize AVAudioPlayer - \(error.localizedDescription)")
  }
} else {
  print("Error: Sound file not found")
}

to use the asset sound we need to copy the files or just drag and drop it to Xcode and use the settings below. it will make the sound copied to the project and visible to others if we want to collaborate on Git.

What happen??! the sound is not responsive to the user's keyboard press

okay, now we found that the sound is not too responsive to my keyboard press. when I press “B” 3 times, only 1 sound of Kick Drum comes out. so now the challenge is how do we make it super responsive for the app to output sound when a key is pressed? first, I tried to modify the class of AVFoundation but there was no result, so I needed to change my approach. rather than modifying the class of AVFoundation, why don’t we wrap each AVFoundation instance into a new Threads? Eureka! That is the answer! now, we need to learn about how we do multithreading that utilizes all cores and threads on the Apple M1 and M2 processors. After thorough research, I found that we can utilize multithreading using a feature called DispatchQueue. Below is the code on how multithreading with DispatchQueue looks like.

DispatchQueue.global().async {
  //do something
  playSound()
}

when this code is run by the processor, the program will create a new thread for the playSound function and remove it appropriately. Since there will be no passing data between each thread, this threading is called non-data sharing multithreading.

Bonus: Readable and Clean Code using AudioManager and Factory

last one, the app is now fully functional but at a cost. the cost is the code looks terrible right now. how do we make it better? ———give your best answer here in the comment———

Hint: I found that we could extract our audio-playing AVFoundation library into a brand new AudioManager. each of the AudioManager instances would have unique sounds so the music will be a new argument when instantiating AudioManager. Since the drum set will have a lot of kits like HiHat (open), HiHat (closed), Ride, Cymbals, Snare, High Tom, Low Tom, Floor Tom, and Kick we could instantiate all of the kits using Factory enum.

// AudioManager.swift

import AVFoundation

final class AudioManager {
  private var audioFileName: String
  private var audioFileType: String
  private var audioPlayer: AVAudioPlayer

  init?(audioFileName: String, fileType: String) {
    self.audioFileName = audioFileName
    self.audioFileType = fileType
    self.audioPlayer = AVAudioPlayer()
  }

  func playSound() {
    DispatchQueue.global().async {
      self._playSound(soundFileName: self.audioFileName, fileType: self.audioFileType)
    }

  }

  func _playSound(soundFileName: String, fileType: String) {
    if let soundURL = Bundle.main.url(forResource: soundFileName, withExtension: fileType) {
      do {
        audioPlayer = try AVAudioPlayer(contentsOf: soundURL)
        audioPlayer.prepareToPlay()
        audioPlayer.play()
      } catch {
        print("Error: Could not initialize AVAudioPlayer - \(error.localizedDescription)")
      }
    } else {
      print("Error: Sound file not found")
    }
  }
}

below is the code for using SoundFactory

// SoundFactory.swift

enum SoundFactory {
  static let CRASH = AudioManager(audioFileName: "crash", fileType: "wav")
  static let FLOORTOM = AudioManager(audioFileName: "floortom", fileType: "wav")
  static let HIHAT = AudioManager(audioFileName: "hihat", fileType: "wav")
  static let KICK = AudioManager(audioFileName: "kick", fileType: "wav")
  static let HIHATOPEN = AudioManager(audioFileName: "hihatopen", fileType: "wav")
  static let RIDE = AudioManager(audioFileName: "ride", fileType: "wav")
  static let SNARE = AudioManager(audioFileName: "Snare_12_649", fileType: "wav")
  static let TOMHIGH = AudioManager(audioFileName: "tomhigh", fileType: "wav")
  static let TOMLOW = AudioManager(audioFileName: "tomlow", fileType: "wav")
  static let OPENING = AudioManager(audioFileName: "opening", fileType: "wav")
}

to play the drum sound we could use as simple as the code below

SoundInitializer.SNARE?.playSound()

and that's all!

Muhammad Rasyad Caesarardhi

Apple Developer Academy - BINUS Cohort 7

notes:

*big thanks to my partner Alifiyah Ariandri (a.k.a. al) for making the drum assets. the name “al” is the inspiration for BeatCentral