It all started with a simple idea: "What if we could turn any phone into a professional lighting studio?" Little did we know this would evolve into something much bigger.
# Core Light Features Identified:
1. Preset Effects
β Girlish warm pink - Soft temperament
β Skin-smoothing purple - Perfect skin
β Cold white/blue - Transparent texture
β Pure white - Natural uniform
2. Professional Controls
β Split-screen capability
β Brightness adjustment
β Anti-flicker technology
β Custom color support
Chosen for clean separation of UI and business logic, perfect for SwiftUI
ZStack {
LightBackgroundLayer() // Color effects
CameraPreviewLayer() // Optional camera
ControlPanelLayer() // UI controls
}
π± Main Screen Layout:
ββββββββββββββββββββ
β Light Panel β
ββββββββββββββββββββ€
β Camera Preview β β Draggable
β βοΈ β
ββββββββββββββββββββ€
β Control Panel β β Collapsible
ββββββββββββββββββββ
FillLight/
βββ App/
β βββ FillLightApp.swift
β βββ Info.plist
βββ Views/
β βββ ContentView.swift # Main container view
β βββ CameraView.swift # Camera preview
β βββ ControlPanelView.swift # Settings panel
β βββ RecordingTimerView.swift # Recording UI
β βββ Components/
β βββ RecordButton.swift # Custom camera button
β βββ ColorPresetButton.swift # Color preset selector
βββ Controls/
β βββ Camera/
β β βββ CameraService.swift # Camera handling
β β βββ CameraAccessManager.swift
β βββ Light/
β β βββ LightEffectService.swift
β β βββ LightViewModel.swift
β βββ Utils/
β βββ HapticManager.swift # Haptic feedback
β βββ WindowInteractionManager.swift
βββ Models/
β βββ LightEffect.swift
β βββ ColorPreset.swift
βββ Resources/
β βββ Localizable.xcstrings # Localization
β βββ Assets.xcassets
βββ Extensions/
βββ View+Extensions.swift # SwiftUI extensions
// Before: Everything in ContentView π±
struct ContentView: View {
@State private var brightness: Double = 0.5
@State private var currentColor: Color = .white
@State private var cameraActive = false
// ... 300+ lines of mixed concerns
}
// After: Clean separation of concerns β¨
struct ContentView: View {
@StateObject private var viewModel = LightViewModel()
@StateObject private var cameraService = CameraService.shared
var body: some View {
MainLayout(viewModel: viewModel)
}
}
// The singleton pattern for core services
class CameraService: ObservableObject {
static let shared = CameraService()
private init() { } // Ensure single instance
// Camera-specific logic only
}
class LightEffectService: ObservableObject {
static let shared = LightEffectService()
private init() { }
// Light effect logic only
}
// Reusable gesture handling
struct DraggableModifier: ViewModifier {
@Binding var position: CGPoint
func body(content: Content) -> some View {
content.gesture(
DragGesture()
.onChanged { value in
position = value.location
}
)
}
}
// Usage
CameraPreview()
.modifier(DraggableModifier(position: $cameraPosition))
Each component should have one clear purpose - made debugging much easier!
Using ObservableObject for services and @Published for reactive updates was a game-changer
Breaking down complex views into smaller, reusable components improved maintainability
Singletons for services ensured consistent state across the app
Working with Cursor AI and Claude-3.5-sonnet transformed our development process:
Our journey had three major breakthroughs:
// Day 1: Just a color picker
Rectangle()
.fill(currentColor)
.ignoresSafeArea()
// Today: Professional lighting system
ZStack {
LightEffectLayer(effect: currentEffect)
CameraPreviewLayer()
ControlPanel()
}
The game-changer moment came at 2 AM while debugging. Camera startup: 9 seconds β 1 second!
Added professional effects that creators love:
Started with a simple fill light concept. First challenge: UI layout for both iPad and iPhone.
// First attempt at adaptive layout
struct ContentView: View {
var body: some View {
ZStack {
Rectangle().fill(currentColor)
ColorPicker() // Simple but effective
}
}
}
Added camera integration - everything broke. Camera preview upside down, app freezing.
Camera initialization taking 9 seconds. Multiple backup restores as we tried different approaches.
π Finally fixed: Camera startup reduced to 1 second!
Major UI overhaul - another "zip backup" moment. Added draggable camera preview and effect controls.
Implementing split-screen mode seemed simple... until it wasn't.
// The solution that finally worked
enum SplitStyle: CaseIterable {
case horizontal
case vertical
case diagonal
var iconName: String {
switch self {
case .horizontal: return "rectangle.split.2x1"
case .vertical: return "rectangle.split.1x2"
case .diagonal: return "rectangle.split.diagonal"
}
}
}
Front camera worked perfectly. Back camera? Upside down!
Solution: Proper video orientation handling for each camera position
if currentPosition == .back {
connection.videoOrientation = .landscapeRight
connection.isVideoMirrored = false
} else {
connection.videoOrientation = .landscapeLeft
connection.isVideoMirrored = true
}
Adding dynamic light effects was like choreographing a light show.
How to create smooth, professional-looking effects without draining the battery?
Camera performance was inconsistent across devices. Time to get serious about logging.
// First attempt at logging
print("Camera started")
print("Error: \(error)")
// Enhanced logging system
func log(_ category: String, _ message: String, file: String = #file, line: Int = #line) {
let timestamp = Date().formatted()
print("π± [\(category)] [\(timestamp)] \(message) - \(file):\(line)")
}
// Usage
log("CAMERA", "Session configuration started")
log("CAMERA", "Input count: \(session.inputs.count)")
log("CAMERA", "Output count: \(session.outputs.count)")
Everything looked perfect on iPhone. Then we tested on iPad...
struct ContentView: View {
@Environment(\.horizontalSizeClass) var horizontalSizeClass
var body: some View {
Group {
if horizontalSizeClass == .regular {
iPadLayout()
} else {
iPhoneLayout()
}
}
}
}
// Debug helper for layout issues
extension View {
func debugLayout() -> some View {
self.overlay(
GeometryReader { geometry in
Color.clear.onAppear {
print("π View size: \(geometry.size)")
print("π± Safe area: \(geometry.safeAreaInsets)")
}
}
)
}
}
The app started crashing after extended camera use. Time for some memory debugging.
// Added memory tracking
class CameraService {
func logMemoryUsage() {
var info = mach_task_basic_info()
var count = mach_msg_type_number_t(MemoryLayout.size)/4
let kerr: kern_return_t = withUnsafeMutablePointer(to: &info) {
$0.withMemoryRebound(to: integer_t.self, capacity: 1) {
task_info(mach_task_self_,
task_flavor_t(MACH_TASK_BASIC_INFO),
$0,
&count)
}
}
if kerr == KERN_SUCCESS {
log("MEMORY", "Used: \(info.resident_size/1024/1024) MB")
}
}
}
π Memory leak fixed! Usage now stable at ~100MB
First submission rejected! Issues with:
Users reported random camera freezes when switching effects. Time for some serious debugging!
// Added comprehensive state logging
func switchEffect(_ effect: LightEffect) {
log("EFFECT", "β‘οΈ Switching to effect: \(effect)")
log("STATE", "π± Current state:")
log("STATE", " - Camera running: \(session.isRunning)")
log("STATE", " - Active effect: \(currentEffect)")
log("STATE", " - UI responding: \(isUIEnabled)")
log("STATE", " - Memory usage: \(currentMemoryUsage)MB")
}