bleam 0.0.8 → 0.0.10

package/templates/native/ios/Bleam/AppDelegate.swift

@@ -0,0 +1,482 @@
+internal import Expo
+import React
+import ReactAppDependencyProvider
+import UIKit
+import CryptoKit
+import Darwin
+import Security
+
+func launchArgument(_ name: String) -> String? {
+  let arguments = ProcessInfo.processInfo.arguments
+  guard let flagIndex = arguments.firstIndex(of: name) else {
+    return nil
+  }
+
+  let valueIndex = arguments.index(after: flagIndex)
+  guard arguments.indices.contains(valueIndex) else {
+    return nil
+  }
+
+  return arguments[valueIndex]
+}
+
+@main
+class AppDelegate: ExpoAppDelegate {
+  public override func application(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
+  ) -> Bool {
+    let launched = super.application(application, didFinishLaunchingWithOptions: launchOptions)
+    if launched {
+      PlatformHelperInstaller.refreshIfInstalledApp()
+    }
+    return launched
+  }
+
+  public func application(
+    _ application: UIApplication,
+    configurationForConnecting connectingSceneSession: UISceneSession,
+    options: UIScene.ConnectionOptions
+  ) -> UISceneConfiguration {
+    let configuration = UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
+    configuration.delegateClass = SceneDelegate.self
+    return configuration
+  }
+
+  // Linking API
+  public override func application(
+    _ app: UIApplication,
+    open url: URL,
+    options: [UIApplication.OpenURLOptionsKey: Any] = [:]
+  ) -> Bool {
+    return super.application(app, open: url, options: options) || RCTLinkingManager.application(app, open: url, options: options)
+  }
+
+  // Universal Links
+  public override func application(
+    _ application: UIApplication,
+    continue userActivity: NSUserActivity,
+    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
+  ) -> Bool {
+    let result = RCTLinkingManager.application(application, continue: userActivity, restorationHandler: restorationHandler)
+    return super.application(application, continue: userActivity, restorationHandler: restorationHandler) || result
+  }
+}
+
+private enum PlatformHelperInstaller {
+  static func refreshIfInstalledApp() {
+#if targetEnvironment(macCatalyst)
+    let homeDirectory = URL(fileURLWithPath: NSHomeDirectory(), isDirectory: true)
+    let homeApplications = homeDirectory
+      .appendingPathComponent("Applications", isDirectory: true)
+      .standardizedFileURL.path + "/"
+    guard Bundle.main.bundleURL.standardizedFileURL.path.hasPrefix(homeApplications) else {
+      return
+    }
+    guard let bundleIdentifier = Bundle.main.bundleIdentifier else { return }
+
+    let serviceName = "PlatformHelper"
+    let bundledHelper = Bundle.main.bundleURL
+      .appendingPathComponent("Contents/Helpers/\(serviceName)")
+    guard FileManager.default.isExecutableFile(atPath: bundledHelper.path) else {
+      NSLog("Bleam helper unavailable: bundled executable is missing")
+      return
+    }
+    guard
+      let teamIdentifier = Bundle.main.object(forInfoDictionaryKey: "BleamTeamIdentifier") as? String,
+      let platformVersion = Bundle.main.object(forInfoDictionaryKey: "BleamRuntimeVersion") as? String,
+      validSignature(at: bundledHelper, teamIdentifier: teamIdentifier)
+    else {
+      NSLog("Bleam helper unavailable: bundled executable has an invalid identity")
+      return
+    }
+
+    let label = "\(bundleIdentifier).PlatformHelper"
+    let domain = "gui/\(getuid())"
+    let helperRoot = homeDirectory
+      .appendingPathComponent("Library/Application Support/Bleam/Helpers", isDirectory: true)
+      .appendingPathComponent(bundleIdentifier, isDirectory: true)
+    let installedHelper = helperRoot.appendingPathComponent(serviceName)
+    let stagedHelper = helperRoot.appendingPathComponent(".\(serviceName).\(UUID().uuidString)")
+    let backupHelper = helperRoot.appendingPathComponent(".\(serviceName).previous.\(UUID().uuidString)")
+    let failedHelper = helperRoot.appendingPathComponent(".\(serviceName).failed.\(UUID().uuidString)")
+    let pendingApply = homeDirectory
+      .appendingPathComponent("Library/Application Support/Bleam/Updates", isDirectory: true)
+      .appendingPathComponent(bundleIdentifier, isDirectory: true)
+      .appendingPathComponent("platform-apply.pending")
+    let launchAgents = homeDirectory
+      .appendingPathComponent("Library/LaunchAgents", isDirectory: true)
+    let plistURL = launchAgents.appendingPathComponent("\(label).plist")
+    let propertyList: [String: Any] = [
+      "Label": label,
+      "ProgramArguments": [installedHelper.path],
+      "ProcessType": "Background",
+      "MachServices": [label: true],
+      "KeepAlive": [
+        "SuccessfulExit": false,
+        "PathState": [pendingApply.path: true],
+      ],
+      "EnvironmentVariables": [
+        "XPC_SERVICE_NAME": label,
+        "BLEAM_BUNDLE_IDENTIFIER": bundleIdentifier,
+        "BLEAM_TEAM_IDENTIFIER": teamIdentifier,
+        "BLEAM_HELPER_VERSION": platformVersion,
+        "BLEAM_PLATFORM_VERSION": platformVersion,
+      ],
+    ]
+
+    do {
+      defer { try? FileManager.default.removeItem(at: stagedHelper) }
+      try FileManager.default.createDirectory(
+        at: helperRoot,
+        withIntermediateDirectories: true
+      )
+      try FileManager.default.copyItem(at: bundledHelper, to: stagedHelper)
+      guard
+        FileManager.default.isExecutableFile(atPath: stagedHelper.path),
+        validSignature(at: stagedHelper, teamIdentifier: teamIdentifier)
+      else {
+        throw HelperInstallError.invalidSignature
+      }
+      try FileManager.default.createDirectory(
+        at: launchAgents,
+        withIntermediateDirectories: true
+      )
+      let data = try PropertyListSerialization.data(
+        fromPropertyList: propertyList,
+        format: .xml,
+        options: 0
+      )
+      let previousPlist = try? Data(contentsOf: plistURL)
+      let wasRegistered = runLaunchctl(["print", "\(domain)/\(label)"]) == 0
+      if wasRegistered, runLaunchctl(["bootout", "\(domain)/\(label)"]) != 0 {
+        throw HelperInstallError.registrationFailed
+      }
+
+      do {
+        if FileManager.default.fileExists(atPath: installedHelper.path),
+          rename(installedHelper.path, backupHelper.path) != 0
+        {
+          throw HelperInstallError.replacementFailed
+        }
+        guard rename(stagedHelper.path, installedHelper.path) == 0 else {
+          throw HelperInstallError.replacementFailed
+        }
+        try data.write(to: plistURL, options: .atomic)
+        let bootstrapStatus = runLaunchctl(["bootstrap", domain, plistURL.path])
+        guard
+          bootstrapStatus == 0 || runLaunchctl(["print", "\(domain)/\(label)"]) == 0
+        else {
+          throw HelperInstallError.registrationFailed
+        }
+        try? FileManager.default.removeItem(at: backupHelper)
+        try? FileManager.default.removeItem(
+          at: helperRoot.appendingPathComponent("PlatformHelper.xpc", isDirectory: true)
+        )
+      } catch let installError {
+        do {
+          let newJobRegistered = runLaunchctl(["print", "\(domain)/\(label)"]) == 0
+          if newJobRegistered,
+            runLaunchctl(["bootout", "\(domain)/\(label)"]) != 0
+          {
+            throw HelperInstallError.rollbackFailed
+          }
+          if FileManager.default.fileExists(atPath: installedHelper.path),
+            rename(installedHelper.path, failedHelper.path) != 0
+          {
+            throw HelperInstallError.rollbackFailed
+          }
+          if FileManager.default.fileExists(atPath: backupHelper.path),
+            rename(backupHelper.path, installedHelper.path) != 0
+          {
+            throw HelperInstallError.rollbackFailed
+          }
+          if let previousPlist {
+            try previousPlist.write(to: plistURL, options: .atomic)
+            if wasRegistered,
+              runLaunchctl(["bootstrap", domain, plistURL.path]) != 0
+            {
+              throw HelperInstallError.rollbackFailed
+            }
+          } else {
+            try? FileManager.default.removeItem(at: plistURL)
+          }
+          try? FileManager.default.removeItem(at: failedHelper)
+        } catch {
+          NSLog("Bleam helper rollback failed: %@", error.localizedDescription)
+          throw error
+        }
+        throw installError
+      }
+    } catch {
+      NSLog("Bleam helper install failed: %@", error.localizedDescription)
+      return
+    }
+#endif
+  }
+
+  private static func validSignature(at url: URL, teamIdentifier: String) -> Bool {
+    var staticCode: SecStaticCode?
+    guard
+      SecStaticCodeCreateWithPath(url as CFURL, [], &staticCode) == errSecSuccess,
+      let staticCode,
+      SecStaticCodeCheckValidity(
+        staticCode,
+        SecCSFlags(rawValue: kSecCSStrictValidate),
+        nil
+      ) == errSecSuccess
+    else { return false }
+
+    var signingInfo: CFDictionary?
+    guard
+      SecCodeCopySigningInformation(
+        staticCode,
+        SecCSFlags(rawValue: kSecCSSigningInformation),
+        &signingInfo
+      ) == errSecSuccess
+    else { return false }
+    return (signingInfo as? [String: Any])?[kSecCodeInfoTeamIdentifier as String] as? String == teamIdentifier
+  }
+
+  private static func runLaunchctl(_ arguments: [String]) -> Int32 {
+    let values = ["launchctl"] + arguments
+    var argv = values.map { strdup($0) }
+    argv.append(nil)
+    defer { argv.compactMap { $0 }.forEach { free($0) } }
+
+    var pid: pid_t = 0
+    let result = posix_spawn(&pid, "/bin/launchctl", nil, nil, &argv, environ)
+    guard result == 0 else { return Int32(result) }
+    var status: Int32 = 0
+    guard waitpid(pid, &status, 0) == pid else { return -1 }
+    return status
+  }
+}
+
+private enum HelperInstallError: Error {
+  case invalidSignature, registrationFailed, replacementFailed, rollbackFailed
+}
+
+class ReactNativeDelegate: ExpoReactNativeFactoryDelegate {
+  private let bundleOverrideURL: URL?
+
+  init(bundleURL: URL? = nil) {
+    bundleOverrideURL = bundleURL
+    super.init()
+  }
+
+  // Extension point for config-plugins
+
+  override func sourceURL(for bridge: RCTBridge) -> URL? {
+    // needed to return the correct URL for expo-dev-client.
+    bridge.bundleURL ?? bundleURL()
+  }
+
+  override func customize(_ rootView: UIView) {
+    super.customize(rootView)
+    applyRootAppearance(to: rootView)
+  }
+
+  override func bundleURL() -> URL? {
+    if let bundleOverrideURL {
+      return bundleOverrideURL
+    }
+
+    if let bundleURL = launchArgument("--bleam-bundle-url") {
+      return URL(string: bundleURL)
+    }
+
+#if DEBUG
+    return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: ".expo/.virtual-metro-entry")
+#else
+    return OTAUpdateManager.shared.launchBundleURL()
+#endif
+  }
+}
+
+private struct OTAArtifact: Decodable {
+  let url: URL
+  let sizeBytes: Int
+  let sha256: String
+}
+
+private struct OTARelease: Decodable {
+  let schemaVersion: Int
+  let kind: String
+  let releaseId: String
+  let bundleIdentifier: String
+  let teamIdentifier: String
+  let runtimeVersion: String
+  let artifact: OTAArtifact
+}
+
+final class OTAUpdateManager {
+  static let shared = OTAUpdateManager()
+
+  private let fileManager = FileManager.default
+  private let defaults = UserDefaults.standard
+  private let activeKey = "BleamOTAActiveRelease"
+  private let attemptedKey = "BleamOTAAttemptedRelease"
+  private let rejectedKey = "BleamOTARejectedRelease"
+  private var launchingRelease: String?
+
+  private var cacheRoot: URL {
+    let caches = fileManager.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+    let bundleIdentifier = Bundle.main.bundleIdentifier ?? "app"
+    return caches.appendingPathComponent("Bleam/OTA/\(bundleIdentifier)", isDirectory: true)
+  }
+
+  private init() {
+    for name in ["RCTJavaScriptDidLoadNotification", "RCTContentDidAppearNotification"] {
+      NotificationCenter.default.addObserver(
+        forName: NSNotification.Name(rawValue: name),
+        object: nil,
+        queue: .main
+      ) { [weak self] _ in
+        self?.markLaunchSuccessful()
+      }
+    }
+  }
+
+  func launchBundleURL() -> URL? {
+    guard let releaseId = defaults.string(forKey: activeKey) else {
+      return embeddedBundleURL()
+    }
+
+    if defaults.string(forKey: attemptedKey) == releaseId {
+      defaults.set(releaseId, forKey: rejectedKey)
+      defaults.removeObject(forKey: activeKey)
+      defaults.removeObject(forKey: attemptedKey)
+      return embeddedBundleURL()
+    }
+
+    let bundle = cacheRoot
+      .appendingPathComponent(releaseId, isDirectory: true)
+      .appendingPathComponent("bundle/bundle.js")
+    guard fileManager.fileExists(atPath: bundle.path) else {
+      defaults.removeObject(forKey: activeKey)
+      return embeddedBundleURL()
+    }
+
+    launchingRelease = releaseId
+    defaults.set(releaseId, forKey: attemptedKey)
+    return bundle
+  }
+
+  func checkForUpdate() {
+    guard
+      let baseUrlString = Bundle.main.object(forInfoDictionaryKey: "BleamUpdateServiceURL") as? String,
+      let baseUrl = URL(string: baseUrlString),
+      let bundleIdentifier = Bundle.main.bundleIdentifier,
+      let runtimeVersion = Bundle.main.object(forInfoDictionaryKey: "BleamRuntimeVersion") as? String
+    else {
+      NSLog("Bleam OTA disabled: missing update URL, bundle identifier, or runtime version")
+      return
+    }
+
+    let path = "/v1/apps/\(bundleIdentifier)/ota/\(runtimeVersion)"
+    guard let url = URL(string: path, relativeTo: baseUrl)?.absoluteURL else {
+      NSLog("Bleam OTA disabled: invalid resolver URL")
+      return
+    }
+
+    NSLog("Bleam OTA checking %@", url.absoluteString)
+    URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
+      if let error {
+        NSLog("Bleam OTA resolver failed: %@", error.localizedDescription)
+      }
+      guard
+        let self,
+        let response = response as? HTTPURLResponse,
+        response.statusCode == 200,
+        let data,
+        let release = try? JSONDecoder().decode(OTARelease.self, from: data)
+      else {
+        let status = (response as? HTTPURLResponse)?.statusCode ?? 0
+        NSLog("Bleam OTA resolver returned an unusable response: %d", status)
+        return
+      }
+      self.download(release)
+    }.resume()
+  }
+
+  private func download(_ release: OTARelease) {
+    guard
+      release.schemaVersion == 1,
+      release.kind == "ota",
+      release.bundleIdentifier == Bundle.main.bundleIdentifier,
+      release.runtimeVersion == Bundle.main.object(forInfoDictionaryKey: "BleamRuntimeVersion") as? String,
+      release.teamIdentifier == Bundle.main.object(forInfoDictionaryKey: "BleamTeamIdentifier") as? String,
+      release.releaseId != defaults.string(forKey: activeKey),
+      release.releaseId != defaults.string(forKey: rejectedKey)
+    else {
+      NSLog("Bleam OTA rejected release %@", release.releaseId)
+      return
+    }
+
+    NSLog("Bleam OTA downloading %@", release.releaseId)
+    URLSession.shared.downloadTask(with: release.artifact.url) { [weak self] temporaryUrl, _, error in
+      if let error {
+        NSLog("Bleam OTA download failed: %@", error.localizedDescription)
+      }
+      guard let self, let temporaryUrl else { return }
+      guard
+        let attributes = try? self.fileManager.attributesOfItem(atPath: temporaryUrl.path),
+        attributes[.size] as? Int == release.artifact.sizeBytes,
+        let data = try? Data(contentsOf: temporaryUrl),
+        SHA256.hash(data: data).map({ String(format: "%02x", $0) }).joined() == release.artifact.sha256
+      else {
+        NSLog("Bleam OTA artifact verification failed for %@", release.releaseId)
+        return
+      }
+
+      let destination = self.cacheRoot.appendingPathComponent(release.releaseId, isDirectory: true)
+      try? self.fileManager.removeItem(at: destination)
+      do {
+        try self.fileManager.createDirectory(at: destination, withIntermediateDirectories: true)
+        try self.extract(temporaryUrl, to: destination)
+        guard self.fileManager.fileExists(
+          atPath: destination.appendingPathComponent("bundle/bundle.js").path
+        ) else {
+          try? self.fileManager.removeItem(at: destination)
+          return
+        }
+        self.defaults.removeObject(forKey: self.attemptedKey)
+        self.defaults.set(release.releaseId, forKey: self.activeKey)
+        NSLog("Bleam OTA staged %@ for next launch", release.releaseId)
+      } catch {
+        NSLog("Bleam OTA extraction failed: %@", error.localizedDescription)
+        try? self.fileManager.removeItem(at: destination)
+      }
+    }.resume()
+  }
+
+  private func extract(_ archive: URL, to destination: URL) throws {
+    let arguments = ["ditto", "-x", "-k", archive.path, destination.path]
+    var argv = arguments.map { strdup($0) }
+    argv.append(nil)
+    defer { argv.compactMap { $0 }.forEach { free($0) } }
+
+    var pid: pid_t = 0
+    let spawnResult = posix_spawn(&pid, "/usr/bin/ditto", nil, nil, &argv, environ)
+    guard spawnResult == 0 else {
+      throw NSError(domain: NSPOSIXErrorDomain, code: Int(spawnResult))
+    }
+    var status: Int32 = 0
+    guard waitpid(pid, &status, 0) == pid, status == 0 else {
+      throw NSError(domain: NSPOSIXErrorDomain, code: Int(status))
+    }
+  }
+
+  private func markLaunchSuccessful() {
+    guard let releaseId = launchingRelease else { return }
+    defaults.removeObject(forKey: attemptedKey)
+    launchingRelease = nil
+    let releaseRoot = cacheRoot.appendingPathComponent(releaseId, isDirectory: true)
+    try? fileManager.createDirectory(at: releaseRoot, withIntermediateDirectories: true)
+  }
+
+  private func embeddedBundleURL() -> URL? {
+    Bundle.main.url(forResource: "main", withExtension: "jsbundle")
+  }
+}

package/templates/native/ios/Bleam/Appearance.swift

@@ -0,0 +1,62 @@
+import UIKit
+
+struct Appearance {
+  let windowBackgroundColor: UIColor?
+  let userInterfaceStyle: UIUserInterfaceStyle
+
+  static let `default` = Appearance(
+    windowBackgroundColor: nil,
+    userInterfaceStyle: .unspecified
+  )
+}
+
+func parseColor(from hex: String?) -> UIColor? {
+  guard let hex else {
+    return nil
+  }
+
+  let value = hex.trimmingCharacters(in: .whitespacesAndNewlines).replacingOccurrences(of: "#", with: "")
+  guard value.count == 6, let number = Int(value, radix: 16) else {
+    return nil
+  }
+
+  return UIColor(
+    red: CGFloat((number >> 16) & 0xff) / 255,
+    green: CGFloat((number >> 8) & 0xff) / 255,
+    blue: CGFloat(number & 0xff) / 255,
+    alpha: 1
+  )
+}
+
+func parseAppearance(from value: Any?) -> Appearance {
+  guard let object = value as? [String: Any] else {
+    return .default
+  }
+
+  let window = object["window"] as? [String: Any]
+  let style = object["userInterfaceStyle"] as? String
+
+  return Appearance(
+    windowBackgroundColor: parseColor(from: window?["backgroundColor"] as? String),
+    userInterfaceStyle: style == "light" ? .light : style == "dark" ? .dark : .unspecified
+  )
+}
+
+func projectAppearance() -> Appearance {
+  guard let configPath = launchArgument("--bleam-project-config") else {
+    return .default
+  }
+
+  do {
+    let data = try Data(contentsOf: URL(fileURLWithPath: configPath))
+    let value = try JSONSerialization.jsonObject(with: data) as? [String: Any]
+    return parseAppearance(from: value?["appearance"])
+  } catch {
+    return .default
+  }
+}
+
+func applyRootAppearance(to rootView: UIView) {
+  rootView.backgroundColor = .clear
+  rootView.isOpaque = false
+}

package/templates/native/ios/Bleam/Bridging-Header.h

@@ -0,0 +1,3 @@
+//
+// Use this file to import your target's public headers that you would like to expose to Swift.
+//

package/templates/native/ios/Bleam/Images.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,13 @@
+{
+  "images" : [
+    {
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "expo"
+  }
+}

package/templates/native/ios/Bleam/Images.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "version" : 1,
+    "author" : "expo"
+  }
+}

package/templates/native/ios/Bleam/Info.plist

@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CADisableMinimumFrameDurationOnPhone</key>
+	<true/>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundleDisplayName</key>
+	<string>Bleam</string>
+	<key>CFBundlePackageType</key>
+	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>AppGroupIdentifier</key>
+	<string>group.dev.bleam.app</string>
+	<key>LSMinimumSystemVersion</key>
+	<string>12.0</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>NSAppTransportSecurity</key>
+	<dict>
+		<key>NSAllowsArbitraryLoads</key>
+		<false/>
+		<key>NSAllowsLocalNetworking</key>
+		<true/>
+	</dict>
+	<key>RCTNewArchEnabled</key>
+	<true/>
+	<key>UILaunchStoryboardName</key>
+	<string>SplashScreen</string>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>arm64</string>
+	</array>
+	<key>UIStatusBarStyle</key>
+	<string>UIStatusBarStyleDefault</string>
+	<key>UIApplicationSceneManifest</key>
+	<dict>
+		<key>UIApplicationSupportsMultipleScenes</key>
+		<false/>
+		<key>UISceneConfigurations</key>
+		<dict>
+			<key>UIWindowSceneSessionRoleApplication</key>
+			<array>
+				<dict>
+					<key>UISceneConfigurationName</key>
+					<string>Default Configuration</string>
+					<key>UISceneDelegateClassName</key>
+					<string>$(PRODUCT_MODULE_NAME).SceneDelegate</string>
+				</dict>
+			</array>
+		</dict>
+	</dict>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UIViewControllerBasedStatusBarAppearance</key>
+	<false/>
+</dict>
+</plist>

package/templates/native/ios/Bleam/PrivacyInfo.xcprivacy

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSPrivacyAccessedAPITypes</key>
+	<array>
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategoryUserDefaults</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>CA92.1</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategoryFileTimestamp</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>0A2A.1</string>
+				<string>3B52.1</string>
+				<string>C617.1</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategoryDiskSpace</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>E174.1</string>
+				<string>85F4.1</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategorySystemBootTime</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>35F9.1</string>
+			</array>
+		</dict>
+	</array>
+	<key>NSPrivacyCollectedDataTypes</key>
+	<array/>
+	<key>NSPrivacyTracking</key>
+	<false/>
+</dict>
+</plist>