From ad0c0ba8a6012e258ee571348af0c469d259e2c4 Mon Sep 17 00:00:00 2001 From: jared Date: Sat, 31 Jan 2026 10:21:12 -0500 Subject: [PATCH] init --- .claude/settings.local.json | 7 + WordMark.xcodeproj/project.pbxproj | 395 ++++++++++++++++++ .../UserInterfaceState.xcuserstate | Bin 0 -> 20371 bytes .../xcschemes/xcschememanagement.plist | 19 + .../AccentColor.colorset/Contents.json | 11 + .../AppIcon.appiconset/Contents.json | 13 + WordMark/Assets.xcassets/Contents.json | 6 + WordMark/ContentView.swift | 25 ++ WordMark/Info.plist | 11 + WordMark/Services/CameraService.swift | 267 ++++++++++++ WordMark/ViewModels/CameraViewModel.swift | 101 +++++ .../ViewModels/PhotoReviewViewModel.swift | 17 + WordMark/Views/CameraView.swift | 146 +++++++ WordMark/Views/PhotoReviewView.swift | 392 +++++++++++++++++ WordMark/WordMarkApp.swift | 10 + junk | 34 ++ 16 files changed, 1454 insertions(+) create mode 100644 .claude/settings.local.json create mode 100644 WordMark.xcodeproj/project.pbxproj create mode 100644 WordMark.xcodeproj/project.xcworkspace/xcuserdata/jared.xcuserdatad/UserInterfaceState.xcuserstate create mode 100644 WordMark.xcodeproj/xcuserdata/jared.xcuserdatad/xcschemes/xcschememanagement.plist create mode 100644 WordMark/Assets.xcassets/AccentColor.colorset/Contents.json create mode 100644 WordMark/Assets.xcassets/AppIcon.appiconset/Contents.json create mode 100644 WordMark/Assets.xcassets/Contents.json create mode 100644 WordMark/ContentView.swift create mode 100644 WordMark/Info.plist create mode 100644 WordMark/Services/CameraService.swift create mode 100644 WordMark/ViewModels/CameraViewModel.swift create mode 100644 WordMark/ViewModels/PhotoReviewViewModel.swift create mode 100644 WordMark/Views/CameraView.swift create mode 100644 WordMark/Views/PhotoReviewView.swift create mode 100644 WordMark/WordMarkApp.swift create mode 100644 junk diff --git a/.claude/settings.local.json b/.claude/settings.local.json new file mode 100644 index 0000000..5cc8143 --- /dev/null +++ b/.claude/settings.local.json @@ -0,0 +1,7 @@ +{ + "permissions": { + "allow": [ + "Bash(xcodebuild:*)" + ] + } +} diff --git a/WordMark.xcodeproj/project.pbxproj b/WordMark.xcodeproj/project.pbxproj new file mode 100644 index 0000000..abe9ac6 --- /dev/null +++ b/WordMark.xcodeproj/project.pbxproj @@ -0,0 +1,395 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 56; + objects = { + +/* Begin PBXBuildFile section */ + 1A0000000000000000000001 /* WordMarkApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A0000000000000000000011 /* WordMarkApp.swift */; }; + 1A0000000000000000000002 /* ContentView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A0000000000000000000012 /* ContentView.swift */; }; + 1A0000000000000000000003 /* CameraService.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A0000000000000000000013 /* CameraService.swift */; }; + 1A0000000000000000000004 /* CameraViewModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A0000000000000000000014 /* CameraViewModel.swift */; }; + 1A0000000000000000000005 /* CameraView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A0000000000000000000015 /* CameraView.swift */; }; + 1A0000000000000000000006 /* PhotoReviewView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A0000000000000000000016 /* PhotoReviewView.swift */; }; + 1A0000000000000000000007 /* PhotoReviewViewModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A0000000000000000000017 /* PhotoReviewViewModel.swift */; }; + 1A0000000000000000000008 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 1A0000000000000000000018 /* Assets.xcassets */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 1A0000000000000000000010 /* WordMark.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = WordMark.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 1A0000000000000000000011 /* WordMarkApp.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = WordMarkApp.swift; sourceTree = ""; }; + 1A0000000000000000000012 /* ContentView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ContentView.swift; sourceTree = ""; }; + 1A0000000000000000000013 /* CameraService.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CameraService.swift; sourceTree = ""; }; + 1A0000000000000000000014 /* CameraViewModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CameraViewModel.swift; sourceTree = ""; }; + 1A0000000000000000000015 /* CameraView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CameraView.swift; sourceTree = ""; }; + 1A0000000000000000000016 /* PhotoReviewView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PhotoReviewView.swift; sourceTree = ""; }; + 1A0000000000000000000017 /* PhotoReviewViewModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PhotoReviewViewModel.swift; sourceTree = ""; }; + 1A0000000000000000000018 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; + 1A0000000000000000000019 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 1A000000000000000000000D /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 1A0000000000000000000020 = { + isa = PBXGroup; + children = ( + 1A0000000000000000000021 /* WordMark */, + 1A0000000000000000000030 /* Products */, + ); + sourceTree = ""; + }; + 1A0000000000000000000021 /* WordMark */ = { + isa = PBXGroup; + children = ( + 1A0000000000000000000011 /* WordMarkApp.swift */, + 1A0000000000000000000012 /* ContentView.swift */, + 1A0000000000000000000022 /* Services */, + 1A0000000000000000000023 /* ViewModels */, + 1A0000000000000000000024 /* Views */, + 1A0000000000000000000018 /* Assets.xcassets */, + 1A0000000000000000000019 /* Info.plist */, + ); + path = WordMark; + sourceTree = ""; + }; + 1A0000000000000000000022 /* Services */ = { + isa = PBXGroup; + children = ( + 1A0000000000000000000013 /* CameraService.swift */, + ); + path = Services; + sourceTree = ""; + }; + 1A0000000000000000000023 /* ViewModels */ = { + isa = PBXGroup; + children = ( + 1A0000000000000000000014 /* CameraViewModel.swift */, + 1A0000000000000000000017 /* PhotoReviewViewModel.swift */, + ); + path = ViewModels; + sourceTree = ""; + }; + 1A0000000000000000000024 /* Views */ = { + isa = PBXGroup; + children = ( + 1A0000000000000000000015 /* CameraView.swift */, + 1A0000000000000000000016 /* PhotoReviewView.swift */, + ); + path = Views; + sourceTree = ""; + }; + 1A0000000000000000000030 /* Products */ = { + isa = PBXGroup; + children = ( + 1A0000000000000000000010 /* WordMark.app */, + ); + name = Products; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 1A000000000000000000000F /* WordMark */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1A0000000000000000000040 /* Build configuration list for PBXNativeTarget "WordMark" */; + buildPhases = ( + 1A000000000000000000000C /* Sources */, + 1A000000000000000000000D /* Frameworks */, + 1A000000000000000000000E /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = WordMark; + productName = WordMark; + productReference = 1A0000000000000000000010 /* WordMark.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 1A0000000000000000000050 /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = 1; + LastSwiftUpdateCheck = 1500; + LastUpgradeCheck = 1500; + TargetAttributes = { + 1A000000000000000000000F = { + CreatedOnToolsVersion = 15.0; + }; + }; + }; + buildConfigurationList = 1A0000000000000000000051 /* Build configuration list for PBXProject "WordMark" */; + compatibilityVersion = "Xcode 14.0"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 1A0000000000000000000020; + productRefGroup = 1A0000000000000000000030 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 1A000000000000000000000F /* WordMark */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 1A000000000000000000000E /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 1A0000000000000000000008 /* Assets.xcassets in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 1A000000000000000000000C /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 1A0000000000000000000001 /* WordMarkApp.swift in Sources */, + 1A0000000000000000000002 /* ContentView.swift in Sources */, + 1A0000000000000000000003 /* CameraService.swift in Sources */, + 1A0000000000000000000004 /* CameraViewModel.swift in Sources */, + 1A0000000000000000000005 /* CameraView.swift in Sources */, + 1A0000000000000000000006 /* PhotoReviewView.swift in Sources */, + 1A0000000000000000000007 /* PhotoReviewViewModel.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1A0000000000000000000060 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++20"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_ENABLE_OBJC_WEAK = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + ENABLE_USER_SCRIPT_SANDBOXING = YES; + GCC_C_LANGUAGE_STANDARD = gnu17; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 17.0; + LOCALIZATION_PREFERS_STRING_CATALOGS = YES; + MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE; + MTL_FAST_MATH = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = iphoneos; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = "DEBUG $(inherited)"; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + }; + name = Debug; + }; + 1A0000000000000000000061 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++20"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_ENABLE_OBJC_WEAK = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = YES; + GCC_C_LANGUAGE_STANDARD = gnu17; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 17.0; + LOCALIZATION_PREFERS_STRING_CATALOGS = YES; + MTL_ENABLE_DEBUG_INFO = NO; + MTL_FAST_MATH = YES; + SDKROOT = iphoneos; + SWIFT_COMPILATION_MODE = wholemodule; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; + 1A0000000000000000000062 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + DEVELOPMENT_TEAM = 7X85543FQQ; + ENABLE_PREVIEWS = YES; + GENERATE_INFOPLIST_FILE = YES; + INFOPLIST_FILE = WordMark/Info.plist; + INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking"; + INFOPLIST_KEY_NSCameraUsageDescription = "WordMark needs access to your camera to capture photos from both front and rear cameras simultaneously."; + INFOPLIST_KEY_NSPhotoLibraryAddUsageDescription = "WordMark needs access to save your dual camera photos to your photo library."; + INFOPLIST_KEY_UIApplicationSceneManifest_Generation = YES; + INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES; + INFOPLIST_KEY_UISupportedInterfaceOrientations_iPad = "UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight"; + INFOPLIST_KEY_UISupportedInterfaceOrientations_iPhone = "UIInterfaceOrientationPortrait UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight"; + IPHONEOS_DEPLOYMENT_TARGET = 18.6; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.jaredlog.wordmark; + PRODUCT_NAME = "$(TARGET_NAME)"; + SUPPORTED_PLATFORMS = "iphoneos iphonesimulator"; + SUPPORTS_MACCATALYST = NO; + SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = NO; + SWIFT_EMIT_LOC_STRINGS = YES; + SWIFT_VERSION = 5.0; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Debug; + }; + 1A0000000000000000000063 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + DEVELOPMENT_TEAM = 7X85543FQQ; + ENABLE_PREVIEWS = YES; + GENERATE_INFOPLIST_FILE = YES; + INFOPLIST_FILE = WordMark/Info.plist; + INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking"; + INFOPLIST_KEY_NSCameraUsageDescription = "WordMark needs access to your camera to capture photos from both front and rear cameras simultaneously."; + INFOPLIST_KEY_NSPhotoLibraryAddUsageDescription = "WordMark needs access to save your dual camera photos to your photo library."; + INFOPLIST_KEY_UIApplicationSceneManifest_Generation = YES; + INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES; + INFOPLIST_KEY_UISupportedInterfaceOrientations_iPad = "UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight"; + INFOPLIST_KEY_UISupportedInterfaceOrientations_iPhone = "UIInterfaceOrientationPortrait UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight"; + IPHONEOS_DEPLOYMENT_TARGET = 18.6; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.jaredlog.wordmark; + PRODUCT_NAME = "$(TARGET_NAME)"; + SUPPORTED_PLATFORMS = "iphoneos iphonesimulator"; + SUPPORTS_MACCATALYST = NO; + SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = NO; + SWIFT_EMIT_LOC_STRINGS = YES; + SWIFT_VERSION = 5.0; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1A0000000000000000000040 /* Build configuration list for PBXNativeTarget "WordMark" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1A0000000000000000000062 /* Debug */, + 1A0000000000000000000063 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1A0000000000000000000051 /* Build configuration list for PBXProject "WordMark" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1A0000000000000000000060 /* Debug */, + 1A0000000000000000000061 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 1A0000000000000000000050 /* Project object */; +} diff --git a/WordMark.xcodeproj/project.xcworkspace/xcuserdata/jared.xcuserdatad/UserInterfaceState.xcuserstate b/WordMark.xcodeproj/project.xcworkspace/xcuserdata/jared.xcuserdatad/UserInterfaceState.xcuserstate new file mode 100644 index 0000000000000000000000000000000000000000..c951a2531f43592ac2cbddf05e1dbf3b18e70f3e GIT binary patch literal 20371 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 + + + + SchemeUserState + + WordMark.xcscheme_^#shared#^_ + + orderHint + 0 + + WorkMark.xcscheme_^#shared#^_ + + orderHint + 0 + + + + diff --git a/WordMark/Assets.xcassets/AccentColor.colorset/Contents.json b/WordMark/Assets.xcassets/AccentColor.colorset/Contents.json new file mode 100644 index 0000000..eb87897 --- /dev/null +++ b/WordMark/Assets.xcassets/AccentColor.colorset/Contents.json @@ -0,0 +1,11 @@ +{ + "colors" : [ + { + "idiom" : "universal" + } + ], + "info" : { + "author" : "xcode", + "version" : 1 + } +} diff --git a/WordMark/Assets.xcassets/AppIcon.appiconset/Contents.json b/WordMark/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 0000000..13613e3 --- /dev/null +++ b/WordMark/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,13 @@ +{ + "images" : [ + { + "idiom" : "universal", + "platform" : "ios", + "size" : "1024x1024" + } + ], + "info" : { + "author" : "xcode", + "version" : 1 + } +} diff --git a/WordMark/Assets.xcassets/Contents.json b/WordMark/Assets.xcassets/Contents.json new file mode 100644 index 0000000..73c0059 --- /dev/null +++ b/WordMark/Assets.xcassets/Contents.json @@ -0,0 +1,6 @@ +{ + "info" : { + "author" : "xcode", + "version" : 1 + } +} diff --git a/WordMark/ContentView.swift b/WordMark/ContentView.swift new file mode 100644 index 0000000..4b688b7 --- /dev/null +++ b/WordMark/ContentView.swift @@ -0,0 +1,25 @@ +import SwiftUI + +struct ContentView: View { + @StateObject private var cameraViewModel = CameraViewModel() + + var body: some View { + NavigationStack { + CameraView(viewModel: cameraViewModel) + .navigationBarHidden(true) + .navigationDestination(isPresented: $cameraViewModel.showReview) { + PhotoReviewView( + rearImage: cameraViewModel.rearImage, + frontImage: cameraViewModel.frontImage, + onRetake: { + cameraViewModel.resetCapture() + } + ) + } + } + } +} + +#Preview { + ContentView() +} diff --git a/WordMark/Info.plist b/WordMark/Info.plist new file mode 100644 index 0000000..be7558b --- /dev/null +++ b/WordMark/Info.plist @@ -0,0 +1,11 @@ + + + + + UILaunchScreen + + UIColorName + LaunchScreenBackground + + + diff --git a/WordMark/Services/CameraService.swift b/WordMark/Services/CameraService.swift new file mode 100644 index 0000000..75bb459 --- /dev/null +++ b/WordMark/Services/CameraService.swift @@ -0,0 +1,267 @@ +import AVFoundation +import UIKit + +protocol CameraServiceDelegate: AnyObject { + func cameraService(_ service: CameraService, didCaptureRearImage image: UIImage) + func cameraService(_ service: CameraService, didCaptureFrontImage image: UIImage) + func cameraService(_ service: CameraService, didFailWithError error: CameraError) +} + +enum CameraError: Error, LocalizedError { + case multiCamNotSupported + case cameraNotAvailable + case sessionConfigurationFailed + case captureError(String) + case permissionDenied + + var errorDescription: String? { + switch self { + case .multiCamNotSupported: + return "This device does not support simultaneous front and rear camera capture." + case .cameraNotAvailable: + return "Camera is not available on this device." + case .sessionConfigurationFailed: + return "Failed to configure the camera session." + case .captureError(let message): + return "Capture failed: \(message)" + case .permissionDenied: + return "Camera permission denied. Please enable in Settings." + } + } +} + +class CameraService: NSObject { + weak var delegate: CameraServiceDelegate? + + private var multiCamSession: AVCaptureMultiCamSession? + private var rearCameraInput: AVCaptureDeviceInput? + private var frontCameraInput: AVCaptureDeviceInput? + private var rearPhotoOutput: AVCapturePhotoOutput? + private var frontPhotoOutput: AVCapturePhotoOutput? + + private var rearPreviewLayer: AVCaptureVideoPreviewLayer? + private var frontPreviewLayer: AVCaptureVideoPreviewLayer? + + private var pendingRearImage: UIImage? + private var pendingFrontImage: UIImage? + private var isCapturingRear = false + private var isCapturingFront = false + + private let sessionQueue = DispatchQueue(label: "com.wordmark.sessionQueue") + + var isMultiCamSupported: Bool { + return AVCaptureMultiCamSession.isMultiCamSupported + } + + func checkPermissions(completion: @escaping (Bool) -> Void) { + switch AVCaptureDevice.authorizationStatus(for: .video) { + case .authorized: + completion(true) + case .notDetermined: + AVCaptureDevice.requestAccess(for: .video) { granted in + DispatchQueue.main.async { + completion(granted) + } + } + case .denied, .restricted: + completion(false) + @unknown default: + completion(false) + } + } + + func setupSession() { + sessionQueue.async { [weak self] in + self?.configureSession() + } + } + + private func configureSession() { + guard AVCaptureMultiCamSession.isMultiCamSupported else { + DispatchQueue.main.async { [weak self] in + guard let self = self else { return } + self.delegate?.cameraService(self, didFailWithError: .multiCamNotSupported) + } + return + } + + let session = AVCaptureMultiCamSession() + session.beginConfiguration() + + // Configure rear camera + guard let rearCamera = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back), + let rearInput = try? AVCaptureDeviceInput(device: rearCamera) else { + DispatchQueue.main.async { [weak self] in + guard let self = self else { return } + self.delegate?.cameraService(self, didFailWithError: .cameraNotAvailable) + } + return + } + + // Configure front camera + guard let frontCamera = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front), + let frontInput = try? AVCaptureDeviceInput(device: frontCamera) else { + DispatchQueue.main.async { [weak self] in + guard let self = self else { return } + self.delegate?.cameraService(self, didFailWithError: .cameraNotAvailable) + } + return + } + + // Add rear camera input + if session.canAddInput(rearInput) { + session.addInputWithNoConnections(rearInput) + self.rearCameraInput = rearInput + } + + // Add front camera input + if session.canAddInput(frontInput) { + session.addInputWithNoConnections(frontInput) + self.frontCameraInput = frontInput + } + + // Setup rear photo output + let rearPhotoOutput = AVCapturePhotoOutput() + if session.canAddOutput(rearPhotoOutput) { + session.addOutputWithNoConnections(rearPhotoOutput) + self.rearPhotoOutput = rearPhotoOutput + + // Connect rear camera to photo output + if let rearPort = rearInput.ports(for: .video, sourceDeviceType: .builtInWideAngleCamera, sourceDevicePosition: .back).first { + let connection = AVCaptureConnection(inputPorts: [rearPort], output: rearPhotoOutput) + if session.canAddConnection(connection) { + session.addConnection(connection) + } + } + } + + // Setup front photo output + let frontPhotoOutput = AVCapturePhotoOutput() + if session.canAddOutput(frontPhotoOutput) { + session.addOutputWithNoConnections(frontPhotoOutput) + self.frontPhotoOutput = frontPhotoOutput + + // Connect front camera to photo output + if let frontPort = frontInput.ports(for: .video, sourceDeviceType: .builtInWideAngleCamera, sourceDevicePosition: .front).first { + let connection = AVCaptureConnection(inputPorts: [frontPort], output: frontPhotoOutput) + connection.isVideoMirrored = true + if session.canAddConnection(connection) { + session.addConnection(connection) + } + } + } + + session.commitConfiguration() + self.multiCamSession = session + } + + func getPreviewLayer() -> AVCaptureVideoPreviewLayer? { + guard let session = multiCamSession else { return nil } + + if rearPreviewLayer == nil { + let previewLayer = AVCaptureVideoPreviewLayer(sessionWithNoConnection: session) + previewLayer.videoGravity = .resizeAspectFill + + // Connect to rear camera + if let rearInput = rearCameraInput, + let rearPort = rearInput.ports(for: .video, sourceDeviceType: .builtInWideAngleCamera, sourceDevicePosition: .back).first { + let connection = AVCaptureConnection(inputPort: rearPort, videoPreviewLayer: previewLayer) + if session.canAddConnection(connection) { + session.addConnection(connection) + } + } + + self.rearPreviewLayer = previewLayer + } + + return rearPreviewLayer + } + + func getFrontPreviewLayer() -> AVCaptureVideoPreviewLayer? { + guard let session = multiCamSession else { return nil } + + if frontPreviewLayer == nil { + let previewLayer = AVCaptureVideoPreviewLayer(sessionWithNoConnection: session) + previewLayer.videoGravity = .resizeAspectFill + + // Connect to front camera + if let frontInput = frontCameraInput, + let frontPort = frontInput.ports(for: .video, sourceDeviceType: .builtInWideAngleCamera, sourceDevicePosition: .front).first { + let connection = AVCaptureConnection(inputPort: frontPort, videoPreviewLayer: previewLayer) + connection.automaticallyAdjustsVideoMirroring = false + connection.isVideoMirrored = true + if session.canAddConnection(connection) { + session.addConnection(connection) + } + } + + self.frontPreviewLayer = previewLayer + } + + return frontPreviewLayer + } + + func startSession() { + sessionQueue.async { [weak self] in + self?.multiCamSession?.startRunning() + } + } + + func stopSession() { + sessionQueue.async { [weak self] in + self?.multiCamSession?.stopRunning() + } + } + + func capturePhotos() { + guard let rearOutput = rearPhotoOutput, + let frontOutput = frontPhotoOutput else { + delegate?.cameraService(self, didFailWithError: .captureError("Photo outputs not configured")) + return + } + + pendingRearImage = nil + pendingFrontImage = nil + isCapturingRear = true + isCapturingFront = true + + let rearSettings = AVCapturePhotoSettings() + let frontSettings = AVCapturePhotoSettings() + + sessionQueue.async { + rearOutput.capturePhoto(with: rearSettings, delegate: self) + frontOutput.capturePhoto(with: frontSettings, delegate: self) + } + } +} + +extension CameraService: AVCapturePhotoCaptureDelegate { + func photoOutput(_ output: AVCapturePhotoOutput, didFinishProcessingPhoto photo: AVCapturePhoto, error: Error?) { + if let error = error { + DispatchQueue.main.async { [weak self] in + guard let self = self else { return } + self.delegate?.cameraService(self, didFailWithError: .captureError(error.localizedDescription)) + } + return + } + + guard let imageData = photo.fileDataRepresentation(), + let image = UIImage(data: imageData) else { + return + } + + DispatchQueue.main.async { [weak self] in + guard let self = self else { return } + + if output == self.rearPhotoOutput { + self.pendingRearImage = image + self.isCapturingRear = false + self.delegate?.cameraService(self, didCaptureRearImage: image) + } else if output == self.frontPhotoOutput { + self.pendingFrontImage = image + self.isCapturingFront = false + self.delegate?.cameraService(self, didCaptureFrontImage: image) + } + } + } +} diff --git a/WordMark/ViewModels/CameraViewModel.swift b/WordMark/ViewModels/CameraViewModel.swift new file mode 100644 index 0000000..6a1d02a --- /dev/null +++ b/WordMark/ViewModels/CameraViewModel.swift @@ -0,0 +1,101 @@ +import SwiftUI +import AVFoundation + +@MainActor +class CameraViewModel: ObservableObject { + @Published var rearImage: UIImage? + @Published var frontImage: UIImage? + @Published var showReview = false + @Published var errorMessage: String? + @Published var showError = false + @Published var isSessionRunning = false + @Published var permissionGranted = false + + let cameraService = CameraService() + + init() { + cameraService.delegate = self + } + + func checkPermissions() { + cameraService.checkPermissions { [weak self] granted in + DispatchQueue.main.async { + self?.permissionGranted = granted + if granted { + self?.setupCamera() + } else { + self?.errorMessage = CameraError.permissionDenied.localizedDescription + self?.showError = true + } + } + } + } + + func setupCamera() { + guard cameraService.isMultiCamSupported else { + errorMessage = CameraError.multiCamNotSupported.localizedDescription + showError = true + return + } + cameraService.setupSession() + } + + func startSession() { + cameraService.startSession() + isSessionRunning = true + } + + func stopSession() { + cameraService.stopSession() + isSessionRunning = false + } + + func capturePhotos() { + cameraService.capturePhotos() + } + + func resetCapture() { + rearImage = nil + frontImage = nil + showReview = false + startSession() + } + + func getPreviewLayer() -> AVCaptureVideoPreviewLayer? { + return cameraService.getPreviewLayer() + } + + func getFrontPreviewLayer() -> AVCaptureVideoPreviewLayer? { + return cameraService.getFrontPreviewLayer() + } + + private func checkBothCaptured() { + if rearImage != nil && frontImage != nil { + stopSession() + showReview = true + } + } +} + +extension CameraViewModel: CameraServiceDelegate { + nonisolated func cameraService(_ service: CameraService, didCaptureRearImage image: UIImage) { + Task { @MainActor in + self.rearImage = image + self.checkBothCaptured() + } + } + + nonisolated func cameraService(_ service: CameraService, didCaptureFrontImage image: UIImage) { + Task { @MainActor in + self.frontImage = image + self.checkBothCaptured() + } + } + + nonisolated func cameraService(_ service: CameraService, didFailWithError error: CameraError) { + Task { @MainActor in + self.errorMessage = error.localizedDescription + self.showError = true + } + } +} diff --git a/WordMark/ViewModels/PhotoReviewViewModel.swift b/WordMark/ViewModels/PhotoReviewViewModel.swift new file mode 100644 index 0000000..58d119b --- /dev/null +++ b/WordMark/ViewModels/PhotoReviewViewModel.swift @@ -0,0 +1,17 @@ +import SwiftUI +import Photos + +@MainActor +class PhotoReviewViewModel: ObservableObject { + @Published var isSaving = false + @Published var saveSuccess = false + @Published var saveError: String? + + func requestPhotoLibraryPermission(completion: @escaping (Bool) -> Void) { + PHPhotoLibrary.requestAuthorization(for: .addOnly) { status in + DispatchQueue.main.async { + completion(status == .authorized || status == .limited) + } + } + } +} diff --git a/WordMark/Views/CameraView.swift b/WordMark/Views/CameraView.swift new file mode 100644 index 0000000..474dc7a --- /dev/null +++ b/WordMark/Views/CameraView.swift @@ -0,0 +1,146 @@ +import SwiftUI +import AVFoundation + +struct CameraView: View { + @ObservedObject var viewModel: CameraViewModel + + var body: some View { + ZStack { + Color.black.ignoresSafeArea() + + if viewModel.permissionGranted { + CameraPreviewView(viewModel: viewModel) + .ignoresSafeArea() + + VStack { + Spacer() + + HStack(spacing: 20) { + Spacer() + + Button(action: { + viewModel.capturePhotos() + }) { + ZStack { + Circle() + .stroke(Color.white, lineWidth: 4) + .frame(width: 80, height: 80) + + Circle() + .fill(Color.white) + .frame(width: 65, height: 65) + } + } + + FrontCameraPreviewView(viewModel: viewModel) + .frame(width: 80, height: 100) + .clipShape(RoundedRectangle(cornerRadius: 10)) + .overlay( + RoundedRectangle(cornerRadius: 10) + .stroke(Color.white, lineWidth: 2) + ) + } + .padding(.horizontal, 30) + .padding(.bottom, 40) + } + } else { + VStack(spacing: 20) { + Image(systemName: "camera.fill") + .font(.system(size: 60)) + .foregroundColor(.gray) + + Text("Camera Access Required") + .font(.title2) + .foregroundColor(.white) + + Text("Please enable camera access in Settings to use this app.") + .font(.body) + .foregroundColor(.gray) + .multilineTextAlignment(.center) + .padding(.horizontal, 40) + + Button("Open Settings") { + if let url = URL(string: UIApplication.openSettingsURLString) { + UIApplication.shared.open(url) + } + } + .padding() + .background(Color.blue) + .foregroundColor(.white) + .cornerRadius(10) + } + } + } + .onAppear { + viewModel.checkPermissions() + } + .onChange(of: viewModel.permissionGranted) { _, newValue in + if newValue { + DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { + viewModel.startSession() + } + } + } + .alert("Error", isPresented: $viewModel.showError) { + Button("OK", role: .cancel) { } + } message: { + Text(viewModel.errorMessage ?? "An unknown error occurred") + } + } +} + +struct CameraPreviewView: UIViewRepresentable { + @ObservedObject var viewModel: CameraViewModel + + func makeUIView(context: Context) -> UIView { + let view = UIView(frame: .zero) + view.backgroundColor = .black + + DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { + if let previewLayer = viewModel.getPreviewLayer() { + previewLayer.frame = view.bounds + view.layer.addSublayer(previewLayer) + } + } + + return view + } + + func updateUIView(_ uiView: UIView, context: Context) { + DispatchQueue.main.async { + if let previewLayer = uiView.layer.sublayers?.first as? AVCaptureVideoPreviewLayer { + previewLayer.frame = uiView.bounds + } + } + } +} + +struct FrontCameraPreviewView: UIViewRepresentable { + @ObservedObject var viewModel: CameraViewModel + + func makeUIView(context: Context) -> UIView { + let view = UIView(frame: .zero) + view.backgroundColor = .black + + DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { + if let previewLayer = viewModel.getFrontPreviewLayer() { + previewLayer.frame = view.bounds + view.layer.addSublayer(previewLayer) + } + } + + return view + } + + func updateUIView(_ uiView: UIView, context: Context) { + DispatchQueue.main.async { + if let previewLayer = uiView.layer.sublayers?.first as? AVCaptureVideoPreviewLayer { + previewLayer.frame = uiView.bounds + } + } + } +} + +#Preview { + CameraView(viewModel: CameraViewModel()) +} diff --git a/WordMark/Views/PhotoReviewView.swift b/WordMark/Views/PhotoReviewView.swift new file mode 100644 index 0000000..85df7f2 --- /dev/null +++ b/WordMark/Views/PhotoReviewView.swift @@ -0,0 +1,392 @@ +import SwiftUI +import Photos + +struct TextLabel: Identifiable { + let id = UUID() + var text: String + var position: CGPoint + var offset: CGSize = .zero + var dragOffset: CGSize = .zero + var scale: CGFloat = 1.0 + var currentScale: CGFloat = 1.0 + var rotation: Angle = .zero + var currentRotation: Angle = .zero +} + +struct PhotoReviewView: View { + let rearImage: UIImage? + let frontImage: UIImage? + let onRetake: () -> Void + + @StateObject private var viewModel = PhotoReviewViewModel() + @State private var frontImageOffset: CGSize = .zero + @State private var dragOffset: CGSize = .zero + @State private var frontImageScale: CGFloat = 1.0 + @State private var currentScale: CGFloat = 1.0 + @State private var showSaveSuccess = false + @State private var showSaveError = false + @State private var saveErrorMessage = "" + @State private var textLabels: [TextLabel] = [] + @State private var showTextInput = false + @State private var pendingTextPosition: CGPoint = .zero + @State private var newLabelText = "" + + @Environment(\.dismiss) private var dismiss + + private let frontImageSize: CGFloat = 120 + + var body: some View { + GeometryReader { geometry in + ZStack { + // Rear camera image as background with tap gesture + if let rearImage = rearImage { + Image(uiImage: rearImage) + .resizable() + .aspectRatio(contentMode: .fill) + .frame(width: geometry.size.width, height: geometry.size.height) + .clipped() + .onTapGesture { location in + // Check if tap is outside the front image area + if !isTapOnFrontImage(location: location, geometry: geometry) { + pendingTextPosition = location + newLabelText = "" + showTextInput = true + } + } + } + + // Front camera image as draggable and resizable overlay + if let frontImage = frontImage { + let scaledWidth = frontImageSize * frontImageScale * currentScale + let scaledHeight = frontImageSize * 1.33 * frontImageScale * currentScale + + Image(uiImage: frontImage) + .resizable() + .aspectRatio(contentMode: .fill) + .frame(width: scaledWidth, height: scaledHeight) + .clipShape(RoundedRectangle(cornerRadius: 12)) + .overlay( + RoundedRectangle(cornerRadius: 12) + .stroke(Color.white, lineWidth: 3) + ) + .shadow(color: .black.opacity(0.3), radius: 5, x: 0, y: 2) + .position( + x: initialFrontPosition(in: geometry).x + frontImageOffset.width + dragOffset.width, + y: initialFrontPosition(in: geometry).y + frontImageOffset.height + dragOffset.height + ) + .gesture( + DragGesture() + .onChanged { value in + dragOffset = value.translation + } + .onEnded { value in + frontImageOffset.width += value.translation.width + frontImageOffset.height += value.translation.height + dragOffset = .zero + } + ) + .simultaneousGesture( + MagnificationGesture() + .onChanged { value in + currentScale = value + } + .onEnded { value in + frontImageScale *= value + frontImageScale = min(max(frontImageScale, 0.5), 3.0) + currentScale = 1.0 + } + ) + } + + // Text labels + ForEach($textLabels) { $label in + Text(label.text) + .font(.system(size: 32, weight: .bold)) + .foregroundColor(.white) + .shadow(color: .black, radius: 2, x: 1, y: 1) + .padding(20) + .contentShape(Rectangle()) + .scaleEffect(label.scale * label.currentScale) + .rotationEffect(label.rotation + label.currentRotation) + .position( + x: label.position.x + label.offset.width + label.dragOffset.width, + y: label.position.y + label.offset.height + label.dragOffset.height + ) + .gesture( + SimultaneousGesture( + SimultaneousGesture( + DragGesture() + .onChanged { value in + label.dragOffset = value.translation + } + .onEnded { value in + label.offset.width += value.translation.width + label.offset.height += value.translation.height + label.dragOffset = .zero + }, + MagnificationGesture() + .onChanged { value in + label.currentScale = value + } + .onEnded { value in + label.scale *= value + label.scale = min(max(label.scale, 0.3), 5.0) + label.currentScale = 1.0 + } + ), + RotationGesture() + .onChanged { value in + label.currentRotation = value + } + .onEnded { value in + label.rotation += value + label.currentRotation = .zero + } + ) + ) + } + + // Controls overlay + VStack { + Spacer() + + HStack(spacing: 60) { + // Retake button + Button(action: { + dismiss() + onRetake() + }) { + VStack { + Image(systemName: "arrow.counterclockwise") + .font(.system(size: 24)) + Text("Retake") + .font(.caption) + } + .foregroundColor(.white) + .padding() + .background(Color.black.opacity(0.5)) + .cornerRadius(12) + } + + // Save button + Button(action: { + saveCompositeImage(geometry: geometry) + }) { + VStack { + Image(systemName: "square.and.arrow.down") + .font(.system(size: 24)) + Text("Save") + .font(.caption) + } + .foregroundColor(.white) + .padding() + .background(Color.blue) + .cornerRadius(12) + } + } + .padding(.bottom, 50) + } + } + .ignoresSafeArea() + } + .navigationBarHidden(true) + .alert("Saved!", isPresented: $showSaveSuccess) { + Button("OK", role: .cancel) { } + } message: { + Text("Photo saved to your library.") + } + .alert("Save Failed", isPresented: $showSaveError) { + Button("OK", role: .cancel) { } + } message: { + Text(saveErrorMessage) + } + .alert("Enter a word", isPresented: $showTextInput) { + TextField("Word", text: $newLabelText) + Button("Cancel", role: .cancel) { } + Button("Add") { + if !newLabelText.isEmpty { + let newLabel = TextLabel(text: newLabelText, position: pendingTextPosition) + textLabels.append(newLabel) + } + } + } + } + + private func initialFrontPosition(in geometry: GeometryProxy) -> CGPoint { + // Position in top-right corner with padding + let padding: CGFloat = 20 + let x = geometry.size.width - frontImageSize / 2 - padding + let y = frontImageSize * 1.33 / 2 + padding + geometry.safeAreaInsets.top + return CGPoint(x: x, y: y) + } + + private func isTapOnFrontImage(location: CGPoint, geometry: GeometryProxy) -> Bool { + let scaledWidth = frontImageSize * frontImageScale + let scaledHeight = frontImageSize * 1.33 * frontImageScale + let initialPos = initialFrontPosition(in: geometry) + let centerX = initialPos.x + frontImageOffset.width + let centerY = initialPos.y + frontImageOffset.height + + let minX = centerX - scaledWidth / 2 + let maxX = centerX + scaledWidth / 2 + let minY = centerY - scaledHeight / 2 + let maxY = centerY + scaledHeight / 2 + + return location.x >= minX && location.x <= maxX && location.y >= minY && location.y <= maxY + } + + private func saveCompositeImage(geometry: GeometryProxy) { + guard let rearImage = rearImage else { return } + + // Request photo library permission + PHPhotoLibrary.requestAuthorization(for: .addOnly) { status in + DispatchQueue.main.async { + switch status { + case .authorized, .limited: + let compositeImage = createCompositeImage( + rearImage: rearImage, + frontImage: frontImage, + geometry: geometry + ) + + if let composite = compositeImage { + UIImageWriteToSavedPhotosAlbum(composite, nil, nil, nil) + showSaveSuccess = true + } else { + saveErrorMessage = "Failed to create composite image." + showSaveError = true + } + + case .denied, .restricted: + saveErrorMessage = "Photo library access denied. Please enable in Settings." + showSaveError = true + + case .notDetermined: + break + + @unknown default: + break + } + } + } + } + + private func createCompositeImage(rearImage: UIImage, frontImage: UIImage?, geometry: GeometryProxy) -> UIImage? { + // Use full screen size including safe areas to match what user sees + let fullWidth = geometry.size.width + let fullHeight = geometry.size.height + geometry.safeAreaInsets.top + geometry.safeAreaInsets.bottom + let size = CGSize(width: fullWidth, height: fullHeight) + let renderer = UIGraphicsImageRenderer(size: size) + + return renderer.image { context in + // Draw rear image as background (fill) + let rearAspect = rearImage.size.width / rearImage.size.height + let viewAspect = size.width / size.height + + var rearDrawRect: CGRect + if rearAspect > viewAspect { + let height = size.height + let width = height * rearAspect + let x = (size.width - width) / 2 + rearDrawRect = CGRect(x: x, y: 0, width: width, height: height) + } else { + let width = size.width + let height = width / rearAspect + let y = (size.height - height) / 2 + rearDrawRect = CGRect(x: 0, y: y, width: width, height: height) + } + rearImage.draw(in: rearDrawRect) + + // Draw front image overlay + if let frontImage = frontImage { + let frontWidth = frontImageSize * frontImageScale + let frontHeight = frontImageSize * 1.33 * frontImageScale + + // Calculate center position (matches initialFrontPosition + offset) + let padding: CGFloat = 20 + let centerX = fullWidth - frontImageSize / 2 - padding + frontImageOffset.width + let centerY = frontImageSize * 1.33 / 2 + padding + geometry.safeAreaInsets.top + frontImageOffset.height + + // Convert center to rect origin (top-left corner) + let frontX = centerX - frontWidth / 2 + let frontY = centerY - frontHeight / 2 + + let frontRect = CGRect(x: frontX, y: frontY, width: frontWidth, height: frontHeight) + + // Draw rounded rect with border + let path = UIBezierPath(roundedRect: frontRect, cornerRadius: 12) + context.cgContext.saveGState() + path.addClip() + + // Calculate aspect-fill rect (same as .fill in SwiftUI) + let imageAspect = frontImage.size.width / frontImage.size.height + let frameAspect = frontWidth / frontHeight + var drawRect: CGRect + if imageAspect > frameAspect { + // Image is wider - fill height, overflow width + let drawHeight = frontHeight + let drawWidth = drawHeight * imageAspect + let drawX = frontX - (drawWidth - frontWidth) / 2 + drawRect = CGRect(x: drawX, y: frontY, width: drawWidth, height: drawHeight) + } else { + // Image is taller - fill width, overflow height + let drawWidth = frontWidth + let drawHeight = drawWidth / imageAspect + let drawY = frontY - (drawHeight - frontHeight) / 2 + drawRect = CGRect(x: frontX, y: drawY, width: drawWidth, height: drawHeight) + } + frontImage.draw(in: drawRect) + context.cgContext.restoreGState() + + // Draw border + UIColor.white.setStroke() + path.lineWidth = 3 + path.stroke() + } + + // Draw text labels + for label in textLabels { + let textX = label.position.x + label.offset.width + let textY = label.position.y + label.offset.height + + let scaledFontSize: CGFloat = 32 * label.scale + let attributes: [NSAttributedString.Key: Any] = [ + .font: UIFont.boldSystemFont(ofSize: scaledFontSize), + .foregroundColor: UIColor.white, + .strokeColor: UIColor.black, + .strokeWidth: -2.0 + ] + + let attributedString = NSAttributedString(string: label.text, attributes: attributes) + let textSize = attributedString.size() + + // Save graphics state before applying transforms + context.cgContext.saveGState() + + // Move to the text center position + context.cgContext.translateBy(x: textX, y: textY) + + // Apply rotation + let rotationRadians = CGFloat(label.rotation.radians) + context.cgContext.rotate(by: rotationRadians) + + // Draw text centered at origin (which is now at the text position) + let drawPoint = CGPoint(x: -textSize.width / 2, y: -textSize.height / 2) + attributedString.draw(at: drawPoint) + + // Restore graphics state + context.cgContext.restoreGState() + } + } + } +} + +struct PhotoReviewView_Previews: PreviewProvider { + static var previews: some View { + PhotoReviewView( + rearImage: UIImage(systemName: "photo"), + frontImage: UIImage(systemName: "person.fill"), + onRetake: {} + ) + } +} diff --git a/WordMark/WordMarkApp.swift b/WordMark/WordMarkApp.swift new file mode 100644 index 0000000..ad1cb91 --- /dev/null +++ b/WordMark/WordMarkApp.swift @@ -0,0 +1,10 @@ +import SwiftUI + +@main +struct WordMarkApp: App { + var body: some Scene { + WindowGroup { + ContentView() + } + } +} diff --git a/junk b/junk new file mode 100644 index 0000000..234bed5 --- /dev/null +++ b/junk @@ -0,0 +1,34 @@ +/ralph-loop:ralph-loop "Create an iOS app in Swift/SwiftUI that captures photos from both the front and rear cameras simultaneously. + + ## Requirements + + 1. **Dual Camera Capture** + - Use AVCaptureMultiCamSession to capture from front and rear cameras at the same time + - Single capture button triggers both cameras simultaneously + - Handle devices that don't support multi-cam gracefully (show error message) + + 2. **Photo Display Screen** + - After capture, navigate to a review screen + - Rear camera photo displays full-screen as background + - Front camera photo displays as a smaller overlay (roughly 25% size) + - Front photo positioned in top-right corner with rounded corners and subtle border + - User can tap front photo to drag/reposition it + + 3. **Basic Features** + - Save combined image to photo library + - Retake button to return to camera + - Request camera and photo library permissions properly + + 4. **Project Structure** + - Clean MVVM architecture + - Separate camera service class + - The app should build and run without errors + + ## Success Criteria + - App builds without errors or warnings + - Both cameras capture simultaneously on supported devices + - Photos display in correct layout (rear=background, front=overlay) + - Can save the composite image + + Output DUAL CAM APP COMPLETE when the app builds successfully and meets all requirements." --completion-promise "DUAL CAM APP COMPLETE" + --max-iterations 25