How to Build ExtraLarge Widgets on iOS 27 and Use the New Clipboard Shortcut

<key>WidgetSupportedFamilies</key>
<array>
    <string>systemSmall</string>
    <string>systemMedium</string>
    <string>systemLarge</string>
    <string>extraLarge</string>
</array>

import WidgetKit
import SwiftUI

struct MyWidgetEntryView : View {
    @Environment(\.widgetFamily) var family
    var entry: MyWidgetEntry

    var body: some View {
        switch family {
        case .systemSmall:
            SmallWidgetContent(entry: entry)
        case .systemMedium:
            MediumWidgetContent(entry: entry)
        case .systemLarge:
            LargeWidgetContent(entry: entry)
        case .extraLarge:
            ExtraLargeWidgetContent(entry: entry)   // <-- your custom layout
        default:
            LargeWidgetContent(entry: entry)       // fallback for future families
        }
    }
}

class ImageCache {
    static let shared = NSCache<NSURL, UIImage>()

    static func preload(urls: [URL]) {
        let queue = DispatchQueue(label: "com.myapp.image-preload", qos: .utility)
        queue.async {
            for url in urls {
                if shared.object(forKey: url as NSURL) == nil {
                    if let data = try? Data(contentsOf: url),
                       let image = UIImage(data: data) {
                        shared.setObject(image, forKey: url as NSURL)
                    }
                }
            }
        }
    }
}

let group = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: "group.com.mycompany.myapp")!
let jsonURL = group.appendingPathComponent("widgetData.json")

func writeWidgetData(_ data: MyWidgetModel) {
    let encoder = JSONEncoder()
    if let json = try? encoder.encode(data) {
        try? json.write(to: jsonURL)
    }
}

import Foundation

// MARK: - Model

struct WeatherEntry: TimelineEntry {
    let date: Date
    let temperature: String
    let conditionIcon: UIImage   // Cached image
    let forecast: [String]        // Short text for next 3 hours
}

// MARK: - Provider

struct WeatherProvider: TimelineProvider {
    func placeholder(in context: Context) -> WeatherEntry {
        WeatherEntry(date: Date(),
                     temperature: "--°",
                     conditionIcon: UIImage(systemName: "cloud")!,
                     forecast: ["--", "--", "--"])
    }

    func getSnapshot(in context: Context,
                     completion: @escaping (WeatherEntry) -> Void) {
        let entry = WeatherEntry(date: Date(),
                                 temperature: "72°",
                                 conditionIcon: UIImage(systemName: "sun.max")!,
                                 forecast: ["73°", "71°", "70°"])
        completion(entry)
    }

    func getTimeline(in context: Context,
                     completion: @escaping (Timeline<WeatherEntry>) -> Void) {
        // 1️⃣ Load cached JSON (fast, < 2 ms)
        let group = FileManager.default.containerURL(
            forSecurityApplicationGroupIdentifier: "group.com.mycompany.myapp")!
        let jsonURL = group.appendingPathComponent("weatherCache.json")
        guard let data = try? Data(contentsOf: jsonURL),
              let model = try? JSONDecoder().decode(WeatherModel.self, from: data) else {
            // Fallback – schedule a retry in 15 min
            let retry = Calendar.current.date(byAdding: .minute, value: 15, to: Date())!
            let entry = placeholder(in: context)
            completion(Timeline(entries: [entry], policy: .after(retry)))
            return
        }

        // 2️⃣ Pull cached icon from NSCache
        let icon = ImageCache.shared.object(forKey: model.iconURL as NSURL) ??
                   UIImage(systemName: "cloud")!

        // 3️⃣ Build timeline entries (hourly for the next 6 h)
        var entries: [WeatherEntry] = []
        let now = Date()
        for offset in 0..<6 {
            let entryDate = Calendar.current.date(byAdding: .hour,
                                                  value: offset,
                                                  to: now)!
            let entry = WeatherEntry(date: entryDate,
                                     temperature: model.hourlyTemps[offset],
                                     conditionIcon: icon,
                                     forecast: Array(model.hourlyTemps.prefix(3)))
            entries.append(entry)
        }

        // 4️⃣ Tell iOS to refresh after the last entry
        let refreshDate = Calendar.current.date(byAdding: .hour, value: 6, to: now)!
        completion(Timeline(entries: entries, policy: .after(refreshDate)))
    }
}

// MARK: - View

struct WeatherWidgetEntryView: View {
    var entry: WeatherEntry

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            HStack {
                Image(uiImage: entry.conditionIcon)
                    .resizable()
                    .scaledToFit()
                    .frame(width: 60, height: 60)
                Text(entry.temperature)
                    .font(.system(size: 48, weight: .bold, design: .rounded))
            }
            Divider()
            HStack(spacing: 12) {
                ForEach(entry.forecast, id: \.self) { temp in
                    Text(temp)
                        .font(.system(size: 20, weight: .medium))
                }
            }
        }
        .padding()
    }
}

// MARK: - Widget Declaration

@main
struct WeatherWidget: Widget {
    let kind: String = "WeatherWidget"

    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind,
                            provider: WeatherProvider()) { entry in
            WeatherWidgetEntryView(entry: entry)
        }
        .configurationDisplayName("MyWeather")
        .description("Shows the current temperature and a short‑term forecast.")
        .supportedFamilies([.systemSmall, .systemMedium, .systemLarge, .extraLarge])
    }
}

import MusicKit

struct MusicProvider: TimelineProvider {
    func placeholder(in context: Context) -> MusicEntry {
        MusicEntry(date: Date(), title: "Placeholder", artist: "Artist")
    }

    func getSnapshot(in context: Context,
                     completion: @escaping (MusicEntry) -> Void) {
        completion(MusicEntry(date: Date(),
                              title: "Snapshot Song",
                              artist: "Sample Artist"))
    }

    func getTimeline(in context: Context,
                     completion: @escaping (Timeline<MusicEntry>) -> Void) {
        // Turn on the AutoMix flag before we request any track info
        MusicKit.shared.autoMixTransitionsEnabled = true

        Task {
            let nowPlaying = try? await MusicKit.shared.nowPlaying()
            let entry = MusicEntry(date: Date(),
                                   title: nowPlaying?.song.title ?? "No Song",
                                   artist: nowPlaying?.song.artistName ?? "")

            // Refresh every 5 minutes – enough for most songs
            let refresh = Calendar.current.date(byAdding: .minute, value: 5, to: Date())!
            completion(Timeline(entries: [entry], policy: .after(refresh)))
        }
    }
}

struct MusicVisualizer: View {
    @State private var phase: CGFloat = 0

    Canvas { context, size in
        let path = Path { p in
            let amplitude: CGFloat = size.height / 4
            let frequency: CGFloat = 2
            for x in stride(from: 0, through: size.width, by: 2) {
                let relativeX = x / size.width
                let y = amplitude * sin((relativeX + phase) * .pi * frequency) + size.height / 2
                if x == 0 { p.move(to: CGPoint(x: x, y: y)) }
                else { p.addLine(to: CGPoint(x: x, y: y)) }
            }
        }
        context.stroke(path, with: .color(.white.opacity(0.8)), lineWidth: 2)
    }
    .onAppear {
        // Simple animation that updates the phase every 0.05 s
        Timer.scheduledTimer(withTimeInterval: 0.05, repeats: true) { _ in
            phase += 0.02
            if phase > 1 { phase -= 1 }
        }
    }
}

import Photos

PHPhotoLibrary.requestAuthorization { status in
    guard status == .authorized else {
        // Show an alert that the user must enable access in Settings
        return
    }
    // Continue with album creation
}

func createSharedAlbum(named title: String,
                       completion: @escaping (PHAssetCollection?) -> Void) {
    PHPhotoLibrary.shared().performChanges({
        let request = PHAssetCollectionCreationRequest.forAssetCollection(
            withTitle: title,
            assetCollectionType: .album,
            assetCollectionSubtype: .albumCloudShared)

        // Attach sharing options
        let sharingOptions = PHSharingOptions()
        sharingOptions.fullResolution = true
        request.sharingOptions = sharingOptions
    }, completionHandler: { success, error in
        if success {
            // Fetch the newly created collection
            let fetch = PHAssetCollection.fetchAssetCollections(
                with: .album, subtype: .albumCloudShared, options: nil)
            completion(fetch.firstObject)
        } else {
            print("Album creation failed: \(error?.localizedDescription ?? "unknown")")
            completion(nil)
        }
    })
}

func addAssets(_ assets: [PHAsset],
               to album: PHAssetCollection,
               completion: @escaping (Bool) -> Void) {
    PHPhotoLibrary.shared().performChanges({
        let request = PHAssetCollectionChangeRequest(for: album)
        request?.addAssets(assets as NSArray)
    }, completionHandler: { success, error in
        if let err = error {
            print("Failed to add assets: \(err.localizedDescription)")
        }
        completion(success)
    })
}

if let scene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
   scene.isClockOverlayEnabled {
    // The clock will appear on top of the lock‑screen widget.
}

struct ClockOverlayBanner: View {
    Color.black.opacity(0.2)
        .frame(height: 30) // Approximate height of the clock bar
        .ignoresSafeArea(edges: .top)
}

struct CountdownWidgetView: View {
    var entry: CountdownEntry

    var body: some View {
        ZStack(alignment: .top) {
            if entry.showClockOverlay {
                ClockOverlayBanner()
            }
            VStack {
                Text(entry.title)
                    .font(.headline)
                Text(entry.timeRemaining)
                    .font(.system(size: 48, weight: .bold, design: .monospaced))
            }
        }
    }
}

struct LockScreenTimerWidget: Widget, LockScreenWidget {
    var body: some WidgetConfiguration {
        StaticConfiguration(kind: "LockScreenTimer",
                            provider: TimerProvider()) { entry in
            CountdownWidgetView(entry: entry)
        }
        .supportedFamilies([.extraLarge]) // Lock‑screen widgets only support extra‑large
        .description("Shows a countdown timer on the lock screen.")
    }
}

import UIKit

class UrlField: UITextField {
    override init(frame: CGRect) {
        super.init(frame: frame)
        // Accept only URL strings (public.url)
        pasteConfiguration = UIPasteConfiguration(
            acceptableTypeIdentifiers: ["public.url"])
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    // Optional: Provide a custom preview when the user long‑presses the field
    override func canPerformAction(_ action: Selector, withSender sender: Any?) -> Bool {
        if action == #selector(paste(_:)) {
            // Only enable paste if the clipboard actually contains a URL
            return UIPasteboard.general.hasURLs
        }
        return super.canPerformAction(action, withSender: sender)
    }
}

override func paste(_ sender: Any?) {
    guard let item = UIPasteboard.general.itemProviders.first else { return }
    item.loadObject(ofClass: URL.self) { (url, error) in
        DispatchQueue.main.async {
            if let cleanURL = url?.removingQueryParameters() {
                self.text = cleanURL.absoluteString
            }
        }
    }
}

extension URL {
    /// Returns a copy of the URL without query parameters.
    func removingQueryParameters() -> URL? {
        var components = URLComponents(url: self, resolvingAgainstBaseURL: false)
        components?.query = nil
        return components?.url
    }
}

<key>UIRequiresFullScreen</key>
<false/>

class RootViewController: UIViewController {
    override func viewWillTransition(to size: CGSize,
                                     with coordinator: UIViewControllerTransitionCoordinator) {
        super.viewWillTransition(to: size, with: coordinator)
        coordinator.animate(alongsideTransition: { _ in
            // Update constraints or layout here
            self.updateLayout(for: size)
        })
    }

    private func updateLayout(for size: CGSize) {
        if size.width > size.height {
            // Landscape – show a side‑by‑side view
            self.sidePanel.isHidden = false
        } else {
            // Portrait – hide side panel
            self.sidePanel.isHidden = true
        }
    }
}

struct AdaptiveRootView: View {
    @Environment(\.horizontalSizeClass) var hSize
    @Environment(\.verticalSizeClass) var vSize

    var body: some View {
        if hSize == .regular && vSize == .compact {
            // Landscape on a docked iPhone
            Sidebar()
            MainContent()
        } else {
            // Default portrait layout
            MainContent()
        }
    }
}

import PassKit

class CheckoutViewController: UIViewController {
    private lazy var payButton: PKPaymentButton = {
        let button = PKPaymentButton(paymentButtonType: .plain,
                                     paymentButtonStyle: .cardSwitch)
        button.addTarget(self,
                         action: #selector(startPayment),
                         for: .touchUpInside)
        button.translatesAutoresizingMaskIntoConstraints = false
        return button
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        view.addSubview(payButton)
        NSLayoutConstraint.activate([
            payButton.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            payButton.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor,
                                               constant: -20),
            payButton.widthAnchor.constraint(equalToConstant: 200),
            payButton.heightAnchor.constraint(equalToConstant: 44)
        ])
    }

    @objc private func startPayment() {
        let request = PKPaymentRequest()
        request.merchantIdentifier = "merchant.com.mycompany"
        request.countryCode = "US"
        request.currencyCode = "USD"
        request.supportedNetworks = [.visa, .masterCard, .amex]
        request.merchantCapabilities = .capability3DS

        let controller = PKPaymentAuthorizationViewController(paymentRequest: request)!
        controller.delegate = self
        present(controller, animated: true, completion: nil)
    }
}