@rosetears/aili-pi 0.1.0

package/skills/ios-application-dev/references/system-integration.md

@@ -0,0 +1,401 @@
+# System Integration
+
+iOS system integration guide covering permissions, location, sharing, app lifecycle, and haptic feedback.
+
+## Permission Requests
+
+Request permissions contextually, not at launch:
+
+```swift
+import AVFoundation
+
+@objc func openCamera() {
+    AVCaptureDevice.requestAccess(for: .video) { [weak self] granted in
+        DispatchQueue.main.async {
+            if granted {
+                self?.showCameraInterface()
+            } else {
+                self?.showPermissionDeniedAlert()
+            }
+        }
+    }
+}
+```
+
+### Photo Library
+
+```swift
+import Photos
+
+func requestPhotoAccess() {
+    PHPhotoLibrary.requestAuthorization(for: .readWrite) { status in
+        DispatchQueue.main.async {
+            switch status {
+            case .authorized, .limited:
+                self.showPhotoPicker()
+            case .denied, .restricted:
+                self.showSettingsAlert()
+            default:
+                break
+            }
+        }
+    }
+}
+```
+
+### Microphone
+
+```swift
+func requestMicrophoneAccess() {
+    AVAudioSession.sharedInstance().requestRecordPermission { granted in
+        DispatchQueue.main.async {
+            if granted {
+                self.startRecording()
+            }
+        }
+    }
+}
+```
+
+### Notifications
+
+```swift
+import UserNotifications
+
+func requestNotificationPermission() {
+    UNUserNotificationCenter.current().requestAuthorization(
+        options: [.alert, .badge, .sound]
+    ) { granted, error in
+        DispatchQueue.main.async {
+            if granted {
+                self.registerForRemoteNotifications()
+            }
+        }
+    }
+}
+```
+
+## Location Button
+
+For one-time location access without persistent permission:
+
+```swift
+import CoreLocationUI
+
+class StoreFinderVC: UIViewController {
+    override func viewDidLoad() {
+        super.viewDidLoad()
+
+        let locationBtn = CLLocationButton()
+        locationBtn.icon = .arrowFilled
+        locationBtn.label = .currentLocation
+        locationBtn.cornerRadius = 20
+        locationBtn.addTarget(self, action: #selector(findNearby), for: .touchUpInside)
+
+        view.addSubview(locationBtn)
+        locationBtn.snp.makeConstraints { make in
+            make.centerX.equalToSuperview()
+            make.bottom.equalTo(view.safeAreaLayoutGuide).offset(-24)
+        }
+    }
+}
+```
+
+### Core Location
+
+```swift
+import CoreLocation
+
+class LocationManager: NSObject, CLLocationManagerDelegate {
+    private let manager = CLLocationManager()
+
+    func requestLocation() {
+        manager.delegate = self
+        manager.desiredAccuracy = kCLLocationAccuracyBest
+        manager.requestWhenInUseAuthorization()
+    }
+
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        switch manager.authorizationStatus {
+        case .authorizedWhenInUse, .authorizedAlways:
+            manager.requestLocation()
+        case .denied:
+            showLocationDeniedAlert()
+        default:
+            break
+        }
+    }
+
+    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        guard let location = locations.last else { return }
+        handleLocation(location)
+    }
+}
+```
+
+## Share Sheet
+
+```swift
+@objc func shareContent() {
+    let items: [Any] = [contentURL, contentImage].compactMap { $0 }
+    let activityVC = UIActivityViewController(activityItems: items, applicationActivities: nil)
+
+    if let popover = activityVC.popoverPresentationController {
+        popover.sourceView = shareButton
+        popover.sourceRect = shareButton.bounds
+    }
+
+    present(activityVC, animated: true)
+}
+```
+
+### Custom Share Items
+
+```swift
+class ShareItem: NSObject, UIActivityItemSource {
+    let title: String
+    let url: URL
+
+    init(title: String, url: URL) {
+        self.title = title
+        self.url = url
+    }
+
+    func activityViewControllerPlaceholderItem(_ activityViewController: UIActivityViewController) -> Any {
+        return url
+    }
+
+    func activityViewController(_ activityViewController: UIActivityViewController, itemForActivityType activityType: UIActivity.ActivityType?) -> Any? {
+        return url
+    }
+
+    func activityViewController(_ activityViewController: UIActivityViewController, subjectForActivityType activityType: UIActivity.ActivityType?) -> String {
+        return title
+    }
+}
+```
+
+### Excluding Activities
+
+```swift
+let activityVC = UIActivityViewController(activityItems: items, applicationActivities: nil)
+activityVC.excludedActivityTypes = [
+    .addToReadingList,
+    .assignToContact,
+    .print
+]
+```
+
+## App Lifecycle
+
+```swift
+class PlayerViewController: UIViewController {
+    override func viewDidLoad() {
+        super.viewDidLoad()
+
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(onBackground),
+            name: UIApplication.didEnterBackgroundNotification, object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(onForeground),
+            name: UIApplication.willEnterForegroundNotification, object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(onTerminate),
+            name: UIApplication.willTerminateNotification, object: nil
+        )
+    }
+
+    @objc private func onBackground() {
+        saveState()
+        pausePlayback()
+    }
+
+    @objc private func onForeground() {
+        restoreState()
+        resumePlayback()
+    }
+
+    @objc private func onTerminate() {
+        saveState()
+    }
+}
+```
+
+### Scene Lifecycle (iOS 13+)
+
+```swift
+class SceneDelegate: UIResponder, UIWindowSceneDelegate {
+    func sceneDidBecomeActive(_ scene: UIScene) {
+        // Resume tasks
+    }
+
+    func sceneWillResignActive(_ scene: UIScene) {
+        // Pause tasks
+    }
+
+    func sceneDidEnterBackground(_ scene: UIScene) {
+        // Save state
+    }
+
+    func sceneWillEnterForeground(_ scene: UIScene) {
+        // Prepare UI
+    }
+}
+```
+
+### State Preservation
+
+```swift
+class ViewController: UIViewController {
+    override func encodeRestorableState(with coder: NSCoder) {
+        super.encodeRestorableState(with: coder)
+        coder.encode(currentItemID, forKey: "currentItemID")
+    }
+
+    override func decodeRestorableState(with coder: NSCoder) {
+        super.decodeRestorableState(with: coder)
+        if let itemID = coder.decodeObject(forKey: "currentItemID") as? String {
+            loadItem(itemID)
+        }
+    }
+}
+```
+
+## Haptic Feedback
+
+```swift
+func onTaskComplete() {
+    UINotificationFeedbackGenerator().notificationOccurred(.success)
+}
+
+func onError() {
+    UINotificationFeedbackGenerator().notificationOccurred(.error)
+}
+
+func onWarning() {
+    UINotificationFeedbackGenerator().notificationOccurred(.warning)
+}
+
+func onSelection() {
+    UISelectionFeedbackGenerator().selectionChanged()
+}
+
+func onImpact() {
+    UIImpactFeedbackGenerator(style: .medium).impactOccurred()
+}
+```
+
+### Impact Styles
+
+| Style | Usage |
+|-------|-------|
+| `.light` | Subtle feedback, small UI changes |
+| `.medium` | Standard feedback, button presses |
+| `.heavy` | Strong feedback, significant actions |
+| `.soft` | Gentle feedback, background changes |
+| `.rigid` | Sharp feedback, collisions |
+
+### Prepared Feedback
+
+For time-critical haptics, prepare the generator in advance:
+
+```swift
+class DraggableView: UIView {
+    private let impactGenerator = UIImpactFeedbackGenerator(style: .medium)
+
+    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
+        super.touchesBegan(touches, with: event)
+        impactGenerator.prepare()
+    }
+
+    func didSnapToPosition() {
+        impactGenerator.impactOccurred()
+    }
+}
+```
+
+## Deep Linking
+
+### URL Schemes
+
+```swift
+// In AppDelegate or SceneDelegate
+func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
+    guard let components = URLComponents(url: url, resolvingAgainstBaseURL: true) else {
+        return false
+    }
+
+    switch components.host {
+    case "item":
+        if let itemID = components.queryItems?.first(where: { $0.name == "id" })?.value {
+            navigateToItem(itemID)
+            return true
+        }
+    default:
+        break
+    }
+
+    return false
+}
+```
+
+### Universal Links
+
+```swift
+func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
+    guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
+          let url = userActivity.webpageURL else {
+        return false
+    }
+
+    return handleUniversalLink(url)
+}
+```
+
+## Background Tasks
+
+```swift
+import BackgroundTasks
+
+func registerBackgroundTasks() {
+    BGTaskScheduler.shared.register(
+        forTaskWithIdentifier: "com.app.refresh",
+        using: nil
+    ) { task in
+        self.handleAppRefresh(task: task as! BGAppRefreshTask)
+    }
+}
+
+func scheduleAppRefresh() {
+    let request = BGAppRefreshTaskRequest(identifier: "com.app.refresh")
+    request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
+
+    do {
+        try BGTaskScheduler.shared.submit(request)
+    } catch {
+        print("Could not schedule app refresh: \(error)")
+    }
+}
+
+func handleAppRefresh(task: BGAppRefreshTask) {
+    scheduleAppRefresh()
+
+    let operation = RefreshOperation()
+
+    task.expirationHandler = {
+        operation.cancel()
+    }
+
+    operation.completionBlock = {
+        task.setTaskCompleted(success: !operation.isCancelled)
+    }
+
+    OperationQueue.main.addOperation(operation)
+}
+```
+
+---
+
+*UIKit, Core Location, and Apple are trademarks of Apple Inc.*

package/skills/ios-application-dev/references/uikit-components.md

@@ -0,0 +1,297 @@
+# UIKit Components
+
+Common UIKit components guide covering UIStackView, buttons, alerts, search, and context menus.
+
+## UIStackView
+
+Stack views simplify auto layout for linear arrangements:
+
+```swift
+class FormViewController: UIViewController {
+    private let mainStack = UIStackView()
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+
+        mainStack.axis = .vertical
+        mainStack.spacing = 16
+        mainStack.alignment = .fill
+        mainStack.distribution = .fill
+
+        view.addSubview(mainStack)
+        mainStack.snp.makeConstraints { make in
+            make.top.equalTo(view.safeAreaLayoutGuide).offset(20)
+            make.leading.trailing.equalToSuperview().inset(16)
+        }
+
+        let headerStack = UIStackView()
+        headerStack.axis = .horizontal
+        headerStack.spacing = 12
+        headerStack.alignment = .center
+
+        let avatarView = UIImageView()
+        avatarView.snp.makeConstraints { make in
+            make.size.equalTo(48)
+        }
+
+        let labelStack = UIStackView()
+        labelStack.axis = .vertical
+        labelStack.spacing = 4
+        labelStack.addArrangedSubview(titleLabel)
+        labelStack.addArrangedSubview(subtitleLabel)
+
+        headerStack.addArrangedSubview(avatarView)
+        headerStack.addArrangedSubview(labelStack)
+
+        mainStack.addArrangedSubview(headerStack)
+        mainStack.addArrangedSubview(contentView)
+        mainStack.addArrangedSubview(actionButton)
+
+        mainStack.setCustomSpacing(24, after: headerStack)
+    }
+}
+```
+
+### StackView Properties
+
+| Property | Options | Usage |
+|----------|---------|-------|
+| `axis` | `.horizontal`, `.vertical` | Layout direction |
+| `distribution` | `.fill`, `.fillEqually`, `.fillProportionally`, `.equalSpacing`, `.equalCentering` | Space distribution |
+| `alignment` | `.fill`, `.leading`, `.center`, `.trailing` | Cross-axis alignment |
+| `spacing` | CGFloat | Uniform spacing |
+| `setCustomSpacing(_:after:)` | - | Variable spacing |
+
+## UIButton.Configuration (iOS 15+)
+
+```swift
+let primaryButton = UIButton(type: .system)
+primaryButton.configuration = .filled()
+primaryButton.setTitle("Continue", for: .normal)
+
+let secondaryButton = UIButton(type: .system)
+secondaryButton.configuration = .tinted()
+secondaryButton.setTitle("Save for Later", for: .normal)
+
+let destructiveButton = UIButton(type: .system)
+destructiveButton.configuration = .plain()
+destructiveButton.setTitle("Remove", for: .normal)
+destructiveButton.tintColor = .systemRed
+```
+
+### Custom Button Configuration
+
+```swift
+var config = UIButton.Configuration.filled()
+config.title = "Add to Cart"
+config.image = UIImage(systemName: "cart.badge.plus")
+config.imagePadding = 8
+config.cornerStyle = .capsule
+config.baseBackgroundColor = .systemBlue
+config.baseForegroundColor = .white
+let cartButton = UIButton(configuration: config)
+```
+
+### Button State Handling
+
+```swift
+var config = UIButton.Configuration.filled()
+config.titleTextAttributesTransformer = UIConfigurationTextAttributesTransformer { incoming in
+    var outgoing = incoming
+    outgoing.font = .boldSystemFont(ofSize: 16)
+    return outgoing
+}
+
+config.configurationUpdateHandler = { button in
+    var config = button.configuration
+    config?.showsActivityIndicator = button.isSelected
+    button.configuration = config
+}
+```
+
+## UIAlertController
+
+### Alert
+
+```swift
+func confirmDeletion() {
+    let alert = UIAlertController(
+        title: "Remove Item?",
+        message: "This cannot be undone.",
+        preferredStyle: .alert
+    )
+    alert.addAction(UIAlertAction(title: "Remove", style: .destructive) { _ in
+        self.performDeletion()
+    })
+    alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
+    present(alert, animated: true)
+}
+```
+
+### Action Sheet
+
+```swift
+func showOptions() {
+    let sheet = UIAlertController(title: nil, message: nil, preferredStyle: .actionSheet)
+    sheet.addAction(UIAlertAction(title: "Share", style: .default) { _ in })
+    sheet.addAction(UIAlertAction(title: "Edit", style: .default) { _ in })
+    sheet.addAction(UIAlertAction(title: "Delete", style: .destructive) { _ in })
+    sheet.addAction(UIAlertAction(title: "Cancel", style: .cancel))
+
+    if let popover = sheet.popoverPresentationController {
+        popover.sourceView = optionsButton
+        popover.sourceRect = optionsButton.bounds
+    }
+
+    present(sheet, animated: true)
+}
+```
+
+### Alert with Text Field
+
+```swift
+func showInputAlert() {
+    let alert = UIAlertController(
+        title: "Rename",
+        message: "Enter a new name",
+        preferredStyle: .alert
+    )
+
+    alert.addTextField { textField in
+        textField.placeholder = "Name"
+        textField.autocapitalizationType = .words
+    }
+
+    alert.addAction(UIAlertAction(title: "Save", style: .default) { _ in
+        if let name = alert.textFields?.first?.text {
+            self.rename(to: name)
+        }
+    })
+    alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
+
+    present(alert, animated: true)
+}
+```
+
+## UISearchController
+
+```swift
+class SearchableListVC: UIViewController, UISearchResultsUpdating {
+    private let searchController = UISearchController(searchResultsController: nil)
+    private var allItems: [Item] = []
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        setupSearch()
+    }
+
+    private func setupSearch() {
+        searchController.searchResultsUpdater = self
+        searchController.obscuresBackgroundDuringPresentation = false
+        searchController.searchBar.placeholder = "Search"
+        navigationItem.searchController = searchController
+        definesPresentationContext = true
+    }
+
+    func updateSearchResults(for searchController: UISearchController) {
+        let query = searchController.searchBar.text ?? ""
+        let filtered = query.isEmpty ? allItems : allItems.filter {
+            $0.title.localizedCaseInsensitiveContains(query)
+        }
+        updateItems(filtered)
+    }
+}
+```
+
+### Search Bar Configuration
+
+```swift
+searchController.searchBar.scopeButtonTitles = ["All", "Recent", "Favorites"]
+searchController.searchBar.showsScopeBar = true
+searchController.searchBar.delegate = self
+
+extension SearchableListVC: UISearchBarDelegate {
+    func searchBar(_ searchBar: UISearchBar, selectedScopeButtonIndexDidChange selectedScope: Int) {
+        filterContent(scope: selectedScope)
+    }
+}
+```
+
+## UIContextMenuInteraction
+
+```swift
+extension PhotoCell: UIContextMenuInteractionDelegate {
+    func contextMenuInteraction(
+        _ interaction: UIContextMenuInteraction,
+        configurationForMenuAtLocation location: CGPoint
+    ) -> UIContextMenuConfiguration? {
+        UIContextMenuConfiguration(identifier: nil, previewProvider: nil) { _ in
+            let share = UIAction(
+                title: "Share",
+                image: UIImage(systemName: "square.and.arrow.up")
+            ) { _ in }
+
+            let favorite = UIAction(
+                title: "Favorite",
+                image: UIImage(systemName: "heart")
+            ) { _ in }
+
+            let delete = UIAction(
+                title: "Delete",
+                image: UIImage(systemName: "trash"),
+                attributes: .destructive
+            ) { _ in }
+
+            return UIMenu(children: [share, favorite, delete])
+        }
+    }
+}
+```
+
+### Context Menu with Preview
+
+```swift
+func contextMenuInteraction(
+    _ interaction: UIContextMenuInteraction,
+    configurationForMenuAtLocation location: CGPoint
+) -> UIContextMenuConfiguration? {
+    UIContextMenuConfiguration(
+        identifier: itemID as NSCopying,
+        previewProvider: { [weak self] in
+            return self?.makePreviewController()
+        },
+        actionProvider: { _ in
+            return self.makeMenu()
+        }
+    )
+}
+
+func contextMenuInteraction(
+    _ interaction: UIContextMenuInteraction,
+    willPerformPreviewActionForMenuWith configuration: UIContextMenuConfiguration,
+    animator: UIContextMenuInteractionCommitAnimating
+) {
+    animator.addCompletion {
+        self.showDetail()
+    }
+}
+```
+
+### CollectionView Context Menu
+
+```swift
+func collectionView(
+    _ collectionView: UICollectionView,
+    contextMenuConfigurationForItemAt indexPath: IndexPath,
+    point: CGPoint
+) -> UIContextMenuConfiguration? {
+    let item = dataSource.itemIdentifier(for: indexPath)
+    return UIContextMenuConfiguration(identifier: indexPath as NSCopying, previewProvider: nil) { _ in
+        return self.makeMenu(for: item)
+    }
+}
+```
+
+---
+
+*UIKit and Apple are trademarks of Apple Inc.*