Merge branch 'main' of https://github.com/duraidabdul/LocalConsole into main

Code maintenance, fix for grabber long press bug.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Duraid Abdul
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -3,8 +3,8 @@
 Welcome to LocalConsole! This Swift Package makes on-device debugging easy with a convenient PiP-style console that can display items in the same way ```print()``` will in Xcode. This tool can also dynamically display view frames and restart SpringBoard right from your live app.
 
 <div>
-  <img src="https://github.com/duraidabdul/LocalConsole/blob/main/Additional%20Files/Demo_Pan.gif?raw=true" width="320">
-  <img src="https://github.com/duraidabdul/LocalConsole/blob/main/Additional%20Files/Demo_Resize.gif?raw=true" width="320">
+  <img src="https://github.com/duraidabdul/Demos/blob/main/Demo_Pan.gif?raw=true" width="320">
+  <img src="https://github.com/duraidabdul/Demos/blob/main/Demo_Resize.gif?raw=true" width="320">
 </div>
 
 ## **Setup**
@@ -17,7 +17,7 @@ Welcome to LocalConsole! This Swift Package makes on-device debugging easy with
 ```swift
 import LocalConsole
 
-let localConsoleManager = LCManager.shared
+let consoleManager = LCManager.shared
 ```
 
 ## **Usage**
@@ -25,30 +25,24 @@ Once prepared, the localConsole can be used throughout your project.
 ```swift
 
 // Show the console view.
-localConsoleManager.isVisible = true
+consoleManager.isVisible = true
 
 // Hide the console view.
-localConsoleManager.isVisible = false
+consoleManager.isVisible = false
 ```
 
 ```swift
 // Print items to the console view.
-localConsoleManager.print("Hello, world!")
+consoleManager.print("Hello, world!")
 
 // Clear console text.
-localConsoleManager.clear()
+consoleManager.clear()
 
 // Copy console text.
-localConsoleManager.copy()
+consoleManager.copy()
 ```
 
 ```swift
 // Change the console view font size.
-localConsoleManager.fontSize = 5
+consoleManager.fontSize = 5
 ```
-
-
-## **To-Do**
-* Support for iOS 13
-* Screen edge console hiding
-* Make console view reactive to landscape/portrait switch

Sources/LocalConsole/Extensions.swift

@@ -22,6 +22,7 @@ extension UIScreen {
     static var hasRoundedCorners = UIScreen.main.value(forKey: "_" + "display" + "Corner" + "Radius") as! CGFloat > 0
 }
 
+@available(iOSApplicationExtension, unavailable)
 extension UIApplication {
     var statusBarHeight: CGFloat {
         if let window = UIApplication.shared.windows.first {

Sources/LocalConsole/LCManager.swift

@@ -8,10 +8,11 @@
 //#if canImport(UIKit)
 
 import UIKit
+import SwiftUI
 
-var GLOBAL_DEBUG_BORDERS = false
 var GLOBAL_BORDER_TRACKERS: [BorderManager] = []
 
+@available(iOSApplicationExtension, unavailable)
 public class LCManager: NSObject, UIGestureRecognizerDelegate {
     
     public static let shared = LCManager()
@@ -26,17 +27,80 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
         }
     }
     
-    let defaultConsoleSize = CGSize(width: 212, height: 124)
+    var isConsoleConfigured = false
+    
+    /// A high performance text tracker that only updates the view's text if the view is visible. This allows the app to run print to the console with virtually no performance implications when the console isn't visible.
+    var currentText: String = "" {
+        didSet {
+            if isVisible {
+                
+                // Ensure we are performing UI updates on the main thread.
+                DispatchQueue.main.async {
+                    
+                    // Ensure the console doesn't get caught into any external animation blocks.
+                    UIView.performWithoutAnimation {
+                        self.commitTextChanges(requestMenuUpdate: oldValue == "" || (oldValue != "" && self.currentText == ""))
+                    }
+                }
+            }
+        }
+    }
+    
+    let defaultConsoleSize = CGSize(width: 228, height: 142)
+    
+    lazy var borderView = UIView()
+    
+    var lumaWidthAnchor: NSLayoutConstraint!
+    var lumaHeightAnchor: NSLayoutConstraint!
+    
+    lazy var lumaView: LumaView = {
+        let lumaView = LumaView()
+        lumaView.foregroundView.backgroundColor = .black
+        lumaView.layer.cornerRadius = consoleView.layer.cornerRadius
+        
+        consoleView.addSubview(lumaView)
+        
+        lumaView.translatesAutoresizingMaskIntoConstraints = false
+        
+        lumaHeightAnchor = lumaView.heightAnchor.constraint(equalToConstant: consoleView.frame.size.height)
+        
+        NSLayoutConstraint.activate([
+            lumaView.widthAnchor.constraint(equalTo: consoleView.widthAnchor),
+            lumaHeightAnchor,
+            lumaView.centerXAnchor.constraint(equalTo: consoleView.centerXAnchor),
+            lumaView.centerYAnchor.constraint(equalTo: consoleView.centerYAnchor)
+        ])
+        
+        return lumaView
+    }()
     
     /// The fixed size of the console view.
     lazy var consoleSize = defaultConsoleSize {
         didSet {
             consoleView.frame.size = consoleSize
+            
+            // Update text view width.
             if consoleView.frame.size.width > ResizeController.kMaxConsoleWidth {
-                consoleTextView.frame.size.width = ResizeController.kMaxConsoleWidth
+                consoleTextView.frame.size.width = ResizeController.kMaxConsoleWidth - 4
+            } else if consoleView.frame.size.width < ResizeController.kMinConsoleWidth {
+                consoleTextView.frame.size.width = ResizeController.kMinConsoleWidth - 4
             } else {
-                consoleTextView.frame.size.width = consoleSize.width
+                consoleTextView.frame.size.width = consoleSize.width - 4
             }
+            
+            // Update text view height.
+            if consoleView.frame.size.height > ResizeController.kMaxConsoleHeight {
+                consoleTextView.frame.size.height = ResizeController.kMaxConsoleHeight - 4
+                + (consoleView.frame.size.height - ResizeController.kMaxConsoleHeight) * 2 / 3
+            } else if consoleView.frame.size.height < ResizeController.kMinConsoleHeight {
+                consoleTextView.frame.size.height = ResizeController.kMinConsoleHeight - 4
+                + (consoleView.frame.size.height - ResizeController.kMinConsoleHeight) * 2 / 3
+            } else {
+                consoleTextView.frame.size.height = consoleSize.height - 4
+            }
+            
+            consoleTextView.contentOffset.y = consoleTextView.contentSize.height - consoleTextView.bounds.size.height
+            
             // TODO: Snap to nearest position.
             
             UserDefaults.standard.set(consoleSize.width, forKey: "LocalConsole_Width")
@@ -48,11 +112,11 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
     var consoleWindow: ConsoleWindow?
     
     // The console needs a parent view controller in order to display context menus.
-    let viewController = UIViewController()
+    lazy var viewController = UIViewController()
     lazy var consoleView = viewController.view!
     
     /// Text view that displays printed items.
-    let consoleTextView = UITextView()
+    lazy var consoleTextView = InvertedTextView()
     
     /// Button that reveals menu.
     lazy var menuButton = UIButton()
@@ -61,52 +125,118 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
     var scrollLocked = true
     
     /// Feedback generator for the long press action.
-    let feedbackGenerator = UISelectionFeedbackGenerator()
+    lazy var feedbackGenerator = UISelectionFeedbackGenerator()
     
     lazy var panRecognizer = UIPanGestureRecognizer(target: self, action: #selector(consolePiPPanner(recognizer:)))
     lazy var longPressRecognizer = UILongPressGestureRecognizer(target: self, action: #selector(longPressAction(recognizer:)))
     
     /// Gesture endpoints. Each point represents a corner of the screen. TODO: Handle screen rotation.
     var possibleEndpoints: [CGPoint] {
+        
         if consoleSize.width < UIScreen.portraitSize.width - 112 {
-            return [CGPoint(x: consoleSize.width / 2 + 12,
-                            y: (UIScreen.hasRoundedCorners ? 44 : 16) + consoleSize.height / 2 + 12),
-                    CGPoint(x: UIScreen.portraitSize.width - consoleSize.width / 2 - 12,
-                            y: (UIScreen.hasRoundedCorners ? 44 : 16) + consoleSize.height / 2 + 12),
-                    CGPoint(x: consoleSize.width / 2 + 12,
-                            y: UIScreen.portraitSize.height - consoleSize.height / 2 - (consoleWindow?.safeAreaInsets.bottom ?? 0) - 12),
-                    CGPoint(x: UIScreen.portraitSize.width - consoleSize.width / 2 - 12,
-                            y: UIScreen.portraitSize.height - consoleSize.height / 2 - (consoleWindow?.safeAreaInsets.bottom ?? 0) - 12)]
+            
+            // Four endpoints, one for each corner.
+            var endpoints = [
+                
+                // Top endpoints.
+                CGPoint(x: consoleSize.width / 2 + 12,
+                        y: (UIScreen.hasRoundedCorners ? 44 : 16) + consoleSize.height / 2 + 12),
+                CGPoint(x: UIScreen.portraitSize.width - consoleSize.width / 2 - 12,
+                        y: (UIScreen.hasRoundedCorners ? 44 : 16) + consoleSize.height / 2 + 12),
+                
+                // Bottom endpoints.
+                CGPoint(x: consoleSize.width / 2 + 12,
+                        y: UIScreen.portraitSize.height - consoleSize.height / 2 - (keyboardHeight ?? consoleWindow?.safeAreaInsets.bottom ?? 0) - 12),
+                CGPoint(x: UIScreen.portraitSize.width - consoleSize.width / 2 - 12,
+                        y: UIScreen.portraitSize.height - consoleSize.height / 2 - (keyboardHeight ?? consoleWindow?.safeAreaInsets.bottom ?? 0) - 12)]
+            
+            if consoleView.frame.minX <= 0 {
+                
+                // Left edge endpoints.
+                endpoints = [endpoints[0], endpoints[2]]
+                
+                // Left edge hiding endpoints.
+                if consoleView.center.y < (UIScreen.portraitSize.height - (temporaryKeyboardHeightValueTracker ?? 0)) / 2 {
+                    endpoints.append(CGPoint(x: -consoleSize.width / 2 + 10,
+                                             y: endpoints[0].y))
+                } else {
+                    endpoints.append(CGPoint(x: -consoleSize.width / 2 + 10,
+                                             y: endpoints[1].y))
+                }
+            } else if consoleView.frame.maxX >= UIScreen.portraitSize.width {
+                
+                // Right edge endpoints.
+                endpoints = [endpoints[1], endpoints[3]]
+                
+                // Right edge hiding endpoints.
+                if consoleView.center.y < (UIScreen.portraitSize.height - (temporaryKeyboardHeightValueTracker ?? 0)) / 2 {
+                    endpoints.append(CGPoint(x: UIScreen.portraitSize.width + consoleSize.width / 2 - 10,
+                                             y: endpoints[0].y))
+                } else {
+                    endpoints.append(CGPoint(x: UIScreen.portraitSize.width + consoleSize.width / 2 - 10,
+                                             y: endpoints[1].y))
+                }
+            }
+            
+            return endpoints
+            
         } else {
-            return [CGPoint(x: UIScreen.portraitSize.width / 2,
-                            y: (UIScreen.hasRoundedCorners ? 44 : 16) + consoleSize.height / 2 + 12),
-                    CGPoint(x: UIScreen.portraitSize.width / 2,
-                            y: UIScreen.portraitSize.height - consoleSize.height / 2 - (consoleWindow?.safeAreaInsets.bottom ?? 0) - 12)]
+            
+            // Two endpoints, one for the top, one for the bottom..
+            var endpoints = [CGPoint(x: UIScreen.portraitSize.width / 2,
+                                     y: (UIScreen.hasRoundedCorners ? 44 : 16) + consoleSize.height / 2 + 12),
+                             CGPoint(x: UIScreen.portraitSize.width / 2,
+                                     y: UIScreen.portraitSize.height - consoleSize.height / 2 - (keyboardHeight ?? consoleWindow?.safeAreaInsets.bottom ?? 0) - 12)]
+            
+            if consoleView.frame.minX <= 0 {
+                
+                // Left edge hiding endpoints.
+                if consoleView.center.y < (UIScreen.portraitSize.height - (temporaryKeyboardHeightValueTracker ?? 0)) / 2 {
+                    endpoints.append(CGPoint(x: -consoleSize.width / 2 + 10,
+                                             y: endpoints[0].y))
+                } else {
+                    endpoints.append(CGPoint(x: -consoleSize.width / 2 + 10,
+                                             y: endpoints[1].y))
+                }
+            } else if consoleView.frame.maxX >= UIScreen.portraitSize.width {
+                
+                // Right edge hiding endpoints.
+                if consoleView.center.y < (UIScreen.portraitSize.height - (temporaryKeyboardHeightValueTracker ?? 0)) / 2 {
+                    endpoints.append(CGPoint(x: UIScreen.portraitSize.width + consoleSize.width / 2 - 10,
+                                             y: endpoints[0].y))
+                } else {
+                    endpoints.append(CGPoint(x: UIScreen.portraitSize.width + consoleSize.width / 2 - 10,
+                                             y: endpoints[1].y))
+                }
+            }
+            
+            return endpoints
         }
     }
     
     lazy var initialViewLocation: CGPoint = .zero
     
-    override init() {
-        super.init()
-        
-        configureWindow()
-        
+    func configureConsole() {
         consoleSize = CGSize(width: UserDefaults.standard.object(forKey: "LocalConsole_Width") as? CGFloat ?? consoleSize.width,
                              height: UserDefaults.standard.object(forKey: "LocalConsole_Height") as? CGFloat ?? consoleSize.height)
-        
-        consoleView.backgroundColor = .black
+
         
         consoleView.layer.shadowRadius = 16
         consoleView.layer.shadowOpacity = 0.5
         consoleView.layer.shadowOffset = CGSize(width: 0, height: 2)
-        consoleView.center = possibleEndpoints.first!
+        
+        let cachedConsolePosition = CGPoint(x: UserDefaults.standard.object(forKey: "LocalConsole_X") as? CGFloat ?? possibleEndpoints.first!.x,
+                                            y: UserDefaults.standard.object(forKey: "LocalConsole_Y") as? CGFloat ?? possibleEndpoints.first!.y)
+        
+        consoleView.center = nearestTargetTo(cachedConsolePosition, possibleTargets: possibleEndpoints)
+        
         consoleView.alpha = 0
         
-        consoleView.layer.cornerRadius = 20
+        consoleView.layer.cornerRadius = 22
         consoleView.layer.cornerCurve = .continuous
         
-        let borderView = UIView()
+        let _ = lumaView
+        
         borderView.frame = CGRect(x: -1, y: -1,
                                    width: consoleSize.width + 2,
                                    height: consoleSize.height + 2)
@@ -118,17 +248,19 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
         consoleView.addSubview(borderView)
         
         // Configure text view.
-        consoleTextView.frame = CGRect(x: 0, y: 2, width: consoleSize.width, height: consoleSize.height - 4)
+        consoleTextView.frame = CGRect(x: 2, y: 2, width: consoleSize.width - 4, height: consoleSize.height - 4)
         consoleTextView.isEditable = false
         consoleTextView.backgroundColor = .clear
-        consoleTextView.textContainerInset = UIEdgeInsets(top: 8, left: 10, bottom: 8, right: 10)
+        consoleTextView.textContainerInset = UIEdgeInsets(top: 10, left: 8, bottom: 10, right: 8)
         
         consoleTextView.isSelectable = false
         consoleTextView.showsVerticalScrollIndicator = false
         consoleTextView.contentInsetAdjustmentBehavior = .never
-        consoleTextView.autoresizingMask = [.flexibleHeight]
         consoleView.addSubview(consoleTextView)
         
+        consoleTextView.layer.cornerRadius = consoleView.layer.cornerRadius - 2
+        consoleTextView.layer.cornerCurve = .continuous
+        
         // Configure gesture recognizers.
         panRecognizer.maximumNumberOfTouches = 1
         panRecognizer.delegate = self
@@ -143,7 +275,7 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
         consoleView.addGestureRecognizer(longPressRecognizer)
         
         // Prepare menu button.
-        let diameter = CGFloat(26)
+        let diameter = CGFloat(28)
         
         // This tuned button frame is used to adjust where the menu appears.
         menuButton = UIButton(frame: CGRect(x: consoleView.bounds.width - 44,
@@ -163,7 +295,8 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
         circle.isUserInteractionEnabled = false
         menuButton.addSubview(circle)
         
-        let ellipsisImage = UIImageView(image: UIImage(systemName: "ellipsis", withConfiguration: UIImage.SymbolConfiguration(pointSize: 16)))
+        let ellipsisImage = UIImageView(image: UIImage(systemName: "ellipsis",
+                                                       withConfiguration: UIImage.SymbolConfiguration(pointSize: 17, weight: .medium)))
         ellipsisImage.frame.size = circle.bounds.size
         ellipsisImage.contentMode = .center
         circle.addSubview(ellipsisImage)
@@ -173,7 +306,13 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
         menuButton.showsMenuAsPrimaryAction = true
         consoleView.addSubview(menuButton)
         
-        UIView.swizzleDebugBehaviour
+        if consoleView.center.x < 0 || consoleView.center.x > UIScreen.portraitSize.width {
+            grabberMode = true
+            scrollLocked = !grabberMode
+        }
+        
+        NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide), name: UIResponder.keyboardWillHideNotification, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow), name: UIResponder.keyboardWillShowNotification, object: nil)
     }
     
     /// Adds a LocalConsole window to the app's main scene.
@@ -226,49 +365,112 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
     // MARK: - Public
     
     public var isVisible = false {
-        
         didSet {
             guard oldValue != isVisible else { return }
             
             if isVisible {
+                
+                if !isConsoleConfigured {
+                    configureWindow()
+                    configureConsole()
+                    isConsoleConfigured = true
+                }
+                
+                commitTextChanges(requestMenuUpdate: true)
+                
                 consoleView.transform = .init(scaleX: 0.9, y: 0.9)
                 UIViewPropertyAnimator(duration: 0.5, dampingRatio: 0.6) { [self] in
                     consoleView.transform = .init(scaleX: 1, y: 1)
                 }.startAnimation()
-                UIViewPropertyAnimator(duration: 0.3, dampingRatio: 1) { [self] in
+                UIViewPropertyAnimator(duration: 0.4, dampingRatio: 1) { [self] in
                     consoleView.alpha = 1
                 }.startAnimation()
+                
+                let animation = CABasicAnimation(keyPath: "shadowOpacity")
+                animation.fromValue = 0
+                animation.toValue = 0.5
+                animation.duration = 0.6
+                consoleView.layer.add(animation, forKey: animation.keyPath)
+                consoleView.layer.shadowOpacity = 0.5
+                
             } else {
-                UIViewPropertyAnimator(duration: 0.25, dampingRatio: 1) { [self] in
+                UIViewPropertyAnimator(duration: 0.4, dampingRatio: 1) { [self] in
                     consoleView.transform = .init(scaleX: 0.9, y: 0.9)
+                }.startAnimation()
+                
+                UIViewPropertyAnimator(duration: 0.3, dampingRatio: 1) { [self] in
                     consoleView.alpha = 0
                 }.startAnimation()
             }
         }
     }
     
+    var grabberMode: Bool = false {
+        
+        didSet {
+            guard oldValue != grabberMode else { return }
+            
+            if grabberMode {
+                
+                if oldValue == false {
+                    lumaView.layer.cornerRadius = consoleView.layer.cornerRadius
+                    lumaHeightAnchor.constant = consoleView.frame.size.height
+                    consoleView.layoutIfNeeded()
+                }
+                
+                UIViewPropertyAnimator(duration: 0.3, dampingRatio: 1) { [self] in
+                    consoleTextView.alpha = 0
+                    menuButton.alpha = 0
+                    borderView.alpha = 0
+                }.startAnimation()
+                
+                UIViewPropertyAnimator(duration: 0.5, dampingRatio: 1) { [self] in
+                    lumaView.foregroundView.alpha = 0
+                    
+                }.startAnimation()
+                
+                lumaHeightAnchor.constant = 96
+                UIViewPropertyAnimator(duration: 0.4, dampingRatio: 1) { [self] in
+                    lumaView.layer.cornerRadius = 8
+                    consoleView.layoutIfNeeded()
+                }.startAnimation(afterDelay: 0.06)
+                
+                consoleTextView.isUserInteractionEnabled = false
+                
+            } else {
+                lumaHeightAnchor.constant = consoleView.frame.size.height
+                UIViewPropertyAnimator(duration: 0.4, dampingRatio: 1) { [self] in
+                    consoleView.layoutIfNeeded()
+                    lumaView.layer.cornerRadius = consoleView.layer.cornerRadius
+                }.startAnimation()
+                
+                UIViewPropertyAnimator(duration: 0.3, dampingRatio: 1) { [self] in
+                    consoleTextView.alpha = 1
+                    menuButton.alpha = 1
+                    borderView.alpha = 1
+                }.startAnimation(afterDelay: 0.2)
+                
+                UIViewPropertyAnimator(duration: 0.65, dampingRatio: 1) { [self] in
+                    lumaView.foregroundView.alpha = 1
+                }.startAnimation()
+                
+                consoleTextView.isUserInteractionEnabled = true
+            }
+        }
+    }
+    
     /// Print items to the console view.
     public func print(_ items: Any) {
-        let string: String = {
-            if consoleTextView.text == "" {
-                return "\(items)"
-            } else {
-                return "\(items)\n" + consoleTextView.text
-            }
-        }()
-        
-        setAttributedText(string)
-        
-        // Update the context menu to show the clipboard/clear actions.
-        menuButton.menu = makeMenu()
+        if currentText == "" {
+            currentText = "\(items)"
+        } else {
+            currentText = currentText + "\n\(items)"
+        }
     }
     
     /// Clear text in the console view.
     public func clear() {
-        consoleTextView.text = ""
-        
-        // Update the context menu to hide the clipboard/clear actions.
-        menuButton.menu = makeMenu()
+        currentText = ""
     }
     
     /// Copy the console view text to the device's clipboard.
@@ -278,9 +480,44 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
     
     // MARK: - Private
     
+    var temporaryKeyboardHeightValueTracker: CGFloat?
+    
+    // MARK: Handle keyboard show/hide.
+    private var keyboardHeight: CGFloat? = nil {
+        didSet {
+            
+            temporaryKeyboardHeightValueTracker = oldValue
+            
+            if consoleView.center != possibleEndpoints[0] && consoleView.center != possibleEndpoints[1] {
+                let nearestTargetPosition = nearestTargetTo(consoleView.center, possibleTargets: possibleEndpoints.suffix(2))
+                
+                Swift.print(possibleEndpoints.suffix(2))
+                
+                UIViewPropertyAnimator(duration: 0.55, dampingRatio: 1) {
+                    self.consoleView.center = nearestTargetPosition
+                }.startAnimation()
+            }
+            
+            temporaryKeyboardHeightValueTracker = keyboardHeight
+        }
+    }
+    
+    @objc func keyboardWillShow(_ notification: Notification) {
+        if let keyboardFrame: NSValue = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue {
+            let keyboardRectangle = keyboardFrame.cgRectValue
+            self.keyboardHeight = keyboardRectangle.height
+        }
+    }
+    
+    @objc func keyboardWillHide() {
+        keyboardHeight = nil
+    }
+    
     private var debugBordersEnabled = false {
         didSet {
-            GLOBAL_DEBUG_BORDERS = debugBordersEnabled
+            
+            UIView.swizzleDebugBehaviour_UNTRACKABLE_TOGGLE()
+            
             guard debugBordersEnabled else {
                 GLOBAL_BORDER_TRACKERS.forEach {
                     $0.deactivate()
@@ -306,51 +543,97 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
         }
     }
     
+    var dynamicReportTimer: Timer? {
+        willSet { dynamicReportTimer?.invalidate() }
+    }
+    
     func systemReport() {
         DispatchQueue.main.async { [self] in
-            print("Screen Scale:       \(UIScreen.main.scale)\n")
-            print("Screen Radius:      \(UIScreen.main.value(forKey: "_displayCornerRadius") as! CGFloat)")
-            print("Screen Size:        \(UIScreen.main.bounds.size)")
-            print("Max Frame Rate:     \(UIScreen.main.maximumFramesPerSecond) Hz")
-            print("Low Power Mode:     \(ProcessInfo.processInfo.isLowPowerModeEnabled)")
-            print("System Uptime:      \(Int(ProcessInfo.processInfo.systemUptime))s")
-            print("Thermal State:      \(SystemReport.shared.thermalState)")
-            print("Processor Cores:    \(Int(ProcessInfo.processInfo.processorCount))")
-            print("Memory:             \(round(100 * Double(ProcessInfo.processInfo.physicalMemory) * pow(10, -9)) / 100) GB")
-            print("OS Compile Date:    \(SystemReport.shared.compileDate)")
-            print("System Version:     \(SystemReport.shared.versionString)")
-            print("Kernel Version:     \(SystemReport.shared.kernel) \(SystemReport.shared.kernelVersion)")
-            print("Firmware:           \(SystemReport.shared.gestaltFirmwareVersion)")
-            print("Architecture:       \(SystemReport.shared.gestaltArchitecture)")
-            print("Model Identifier:   \(SystemReport.shared.gestaltModelIdentifier)")
-            print("Marketing Name:     \(SystemReport.shared.gestaltMarketingName)")
+            
+            if currentText != "" { print("\n") }
+            
+            dynamicReportTimer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { timer in
+                var _currentText = currentText
+                
+                // To optimize performance, only scan the last 2500 characters of text for system report changes.
+                let range: NSRange = {
+                    if _currentText.count <= 2500 {
+                        return NSMakeRange(0, _currentText.count)
+                    }
+                    return NSMakeRange(_currentText.count - 2500, 2500)
+                }()
+                
+                let regex0 = try! NSRegularExpression(pattern: "Thermal State:      .*", options: NSRegularExpression.Options.caseInsensitive)
+                _currentText = regex0.stringByReplacingMatches(in: _currentText, options: [], range: range, withTemplate: "Thermal State:      \(SystemReport.shared.thermalState)")
+                
+                let regex1 = try! NSRegularExpression(pattern: "System Uptime:      .*", options: NSRegularExpression.Options.caseInsensitive)
+                _currentText = regex1.stringByReplacingMatches(in: _currentText, options: [], range: range, withTemplate: "System Uptime:      \(ProcessInfo.processInfo.systemUptime.formattedString!)")
+                
+                let regex2 = try! NSRegularExpression(pattern: "Low Power Mode:     .*", options: NSRegularExpression.Options.caseInsensitive)
+                _currentText = regex2.stringByReplacingMatches(in: _currentText, options: [], range: range, withTemplate: "Low Power Mode:     \(ProcessInfo.processInfo.isLowPowerModeEnabled)")
+                
+                if currentText != _currentText {
+                    currentText = _currentText
+                } else {
+                    
+                    // Invalidate the timer if there is no longer anything to update.
+                    timer.invalidate()
+                }
+            }
+            
+            print(
+                  """
+                  Model Name:         \(SystemReport.shared.gestaltMarketingName)
+                  Model Identifier:   \(SystemReport.shared.gestaltModelIdentifier)
+                  Architecture:       \(SystemReport.shared.gestaltArchitecture)
+                  Firmware:           \(SystemReport.shared.gestaltFirmwareVersion)
+                  Kernel Version:     \(SystemReport.shared.kernel) \(SystemReport.shared.kernelVersion)
+                  System Version:     \(SystemReport.shared.versionString)
+                  OS Compile Date:    \(SystemReport.shared.compileDate)
+                  Memory:             \(round(100 * Double(ProcessInfo.processInfo.physicalMemory) * pow(10, -9)) / 100) GB
+                  Processor Cores:    \(Int(ProcessInfo.processInfo.processorCount))
+                  Thermal State:      \(SystemReport.shared.thermalState)
+                  System Uptime:      \(ProcessInfo.processInfo.systemUptime.formattedString!)
+                  Low Power Mode:     \(ProcessInfo.processInfo.isLowPowerModeEnabled)
+                  """
+            )
         }
     }
     
-    
-    @objc func toggleLock() {
-        scrollLocked.toggle()
+    func displayReport() {
+        DispatchQueue.main.async { [self] in
+            
+            if currentText != "" { print("\n") }
+            
+            print(
+                  """
+                  Screen Size:            \(UIScreen.main.bounds.size)
+                  Screen Corner Radius:   \(UIScreen.main.value(forKey: "_displ" + "ayCorn" + "erRa" + "dius") as! CGFloat)
+                  Screen Scale:           \(UIScreen.main.scale)
+                  Max Frame Rate:         \(UIScreen.main.maximumFramesPerSecond) Hz
+                  Brightness:             \(String(format: "%.2f", UIScreen.main.brightness))
+                  """
+            )
+        }
     }
     
-    func toggleVisibility() {
-        if isVisible {
-            UIViewPropertyAnimator(duration: 0.25, dampingRatio: 1) { [self] in
-                consoleView.transform = .init(scaleX: 0.9, y: 0.9)
-                consoleView.alpha = 0
-            }.startAnimation()
+    func commitTextChanges(requestMenuUpdate menuUpdateRequested: Bool) {
+        
+        if consoleTextView.contentOffset.y > consoleTextView.contentSize.height - consoleTextView.bounds.size.height - 20 {
             
-            isVisible = false
-        } else {
-            UIViewPropertyAnimator(duration: 0.4, dampingRatio: 1) { [self] in
-                consoleView.transform = .init(scaleX: 1, y: 1)
-                consoleView.alpha = 1
-            }.startAnimation()
+            // Weird, weird fix that makes the scroll view bottom pinning system work.
+            consoleTextView.isScrollEnabled.toggle()
+            consoleTextView.isScrollEnabled.toggle()
             
-            isVisible = true
+            consoleTextView.pendingOffsetChange = true
         }
         
-        // Renders color properly (for dark appearance).
-        consoleView.backgroundColor = .black
+        setAttributedText(currentText)
+        
+        if menuUpdateRequested {
+            // Update the context menu to show the clipboard/clear actions.
+            menuButton.menu = makeMenu()
+        }
     }
     
     func setAttributedText(_ string: String) {
@@ -388,22 +671,54 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
         
         let consoleActions = UIMenu(title: "", options: .displayInline, children: [clear, resize])
         
+        var frameSymbol = "rectangle.3.offgrid"
+        if #available(iOS 15, *) {
+            frameSymbol = "square.inset.filled"
+        }
+        
         let viewFrames = UIAction(title: debugBordersEnabled ? "Hide View Frames" : "Show View Frames",
-                                  image: UIImage(systemName: "rectangle.3.offgrid"), handler: { _ in
+                                  image: UIImage(systemName: frameSymbol), handler: { _ in
                                     self.debugBordersEnabled.toggle()
                                     self.menuButton.menu = self.makeMenu()
                                   })
         
         let systemReport = UIAction(title: "System Report",
-                                  image: UIImage(systemName: "doc.badge.gearshape"), handler: { _ in
+                                  image: UIImage(systemName: "cpu"), handler: { _ in
                                     self.systemReport()
                                   })
         
-        let respring = UIAction(title: "Restart SpringBoard",
+        // Show the right glyph for the current device being used.
+        let deviceSymbol: String = {
+            
+            let hasHomeButton = UIScreen.main.value(forKey: "_displ" + "ayCorn" + "erRa" + "dius") as! CGFloat == 0
+            
+            if UIDevice.current.userInterfaceIdiom == .pad {
+                if hasHomeButton {
+                    return "ipad.homebutton"
+                } else {
+                    return "ipad"
+                }
+            } else if UIDevice.current.userInterfaceIdiom == .phone {
+                if hasHomeButton {
+                    return "iphone.homebutton"
+                } else {
+                    return "iphone"
+                }
+            } else {
+                return "rectangle"
+            }
+        }()
+        
+        let displayReport = UIAction(title: "Display Report",
+                                  image: UIImage(systemName: deviceSymbol), handler: { _ in
+                                    self.displayReport()
+                                  })
+        
+        let respring = UIAction(title: "Restart Spring" + "Board",
                                 image: UIImage(systemName: "apps.iphone"), handler: { _ in
                                     guard let window = UIApplication.shared.windows.first else { return }
                                     
-                                    window.layer.cornerRadius = UIScreen.main.value(forKey: "_displayCornerRadius") as! CGFloat
+                                    window.layer.cornerRadius = UIScreen.main.value(forKey: "_displ" + "ayCorn" + "erRa" + "dius") as! CGFloat
                                     window.layer.masksToBounds = true
                                     
                                     let animator = UIViewPropertyAnimator(duration: 0.5, dampingRatio: 1) {
@@ -417,7 +732,9 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
                                     }
                                     animator.startAnimation()
                                 })
-        let debugActions = UIMenu(title: "", options: .displayInline, children: [viewFrames, systemReport, respring])
+        let debugActions = UIMenu(title: "", options: .displayInline,
+                                  children: [UIMenu(title: "Debug", image: UIImage(systemName: "ant"),
+                                                    children: [viewFrames, systemReport, displayReport, respring])])
         
         var menuContent: [UIMenuElement] = []
         
@@ -434,6 +751,9 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
     @objc func longPressAction(recognizer: UILongPressGestureRecognizer) {
         switch recognizer.state {
         case .began:
+            
+            guard !grabberMode else { return }
+            
             feedbackGenerator.selectionChanged()
             
             scrollLocked = false
@@ -441,17 +761,21 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
             UIViewPropertyAnimator(duration: 0.4, dampingRatio: 1) { [self] in
                 consoleView.transform = .init(scaleX: 1.04, y: 1.04)
                 consoleTextView.alpha = 0.5
+                menuButton.alpha = 0.5
             }.startAnimation()
         case .cancelled, .ended:
             
-            scrollLocked = true
+            if !grabberMode { scrollLocked = true }
             
             UIViewPropertyAnimator(duration: 0.8, dampingRatio: 0.5) { [self] in
                 consoleView.transform = .init(scaleX: 1, y: 1)
             }.startAnimation()
             
             UIViewPropertyAnimator(duration: 0.4, dampingRatio: 1) { [self] in
-                consoleTextView.alpha = 1
+                if !grabberMode {
+                    consoleTextView.alpha = 1
+                    menuButton.alpha = 1
+                }
             }.startAnimation()
         default: break
         }
@@ -474,6 +798,16 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
             consoleView.center.x = initialViewLocation.x + translation.x
             consoleView.center.y = initialViewLocation.y + translation.y
             
+            if consoleView.frame.maxX > 30 && consoleView.frame.minX < UIScreen.portraitSize.width - 30 {
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
+                    self.grabberMode = false
+                }
+            } else {
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
+                    self.grabberMode = true
+                }
+            }
+            
         case .ended, .cancelled:
             
             // After the PiP is thrown, determine the best corner and re-target it there.
@@ -491,27 +825,31 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
                 dy: relativeVelocity(forVelocity: velocity.y, from: consoleView.center.y, to: nearestTargetPosition.y)
             )
             
-            let timingParameters = UISpringTimingParameters(damping: 1, response: 0.4, initialVelocity: relativeInitialVelocity)
+            let timingParameters = UISpringTimingParameters(damping: 0.85, response: 0.45, initialVelocity: relativeInitialVelocity)
             let positionAnimator = UIViewPropertyAnimator(duration: 0, timingParameters: timingParameters)
             positionAnimator.addAnimations { [self] in
                 consoleView.center = nearestTargetPosition
             }
             positionAnimator.startAnimation()
             
+            UserDefaults.standard.set(nearestTargetPosition.x, forKey: "LocalConsole_X")
+            UserDefaults.standard.set(nearestTargetPosition.y, forKey: "LocalConsole_Y")
+            
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
+                self.grabberMode = nearestTargetPosition.x < 0 || nearestTargetPosition.x > UIScreen.portraitSize.width
+                self.scrollLocked = !self.grabberMode
+            }
+            
         default: break
         }
     }
     
     // Animate touch down.
     func consolePiPTouchDown() {
-        UIViewPropertyAnimator(duration: 1, dampingRatio: 0.5) { [self] in
-            consoleView.transform = .init(scaleX: 0.96, y: 0.96)
-        }.startAnimation()
+        guard !grabberMode else { return }
         
-        UIViewPropertyAnimator(duration: 0.4, dampingRatio: 1) { [self] in
-            if !scrollLocked {
-                consoleView.backgroundColor = #colorLiteral(red: 0.1331297589, green: 0.1331297589, blue: 0.1331297589, alpha: 1)
-            }
+        UIViewPropertyAnimator(duration: 1.25, dampingRatio: 0.5) { [self] in
+            consoleView.transform = .init(scaleX: 0.95, y: 0.95)
         }.startAnimation()
     }
     
@@ -522,11 +860,10 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
         }.startAnimation()
         
         UIViewPropertyAnimator(duration: 0.4, dampingRatio: 1) { [self] in
-            consoleTextView.alpha = 1
-        }.startAnimation()
-        
-        UIViewPropertyAnimator(duration: 0.75, dampingRatio: 1) { [self] in
-            consoleView.backgroundColor = .black
+            if !grabberMode {
+                consoleTextView.alpha = 1
+                menuButton.alpha = 1
+            }
         }.startAnimation()
     }
     
@@ -539,15 +876,9 @@ public class LCManager: NSObject, UIGestureRecognizerDelegate {
         switch recognizer.state {
         case .began:
             consolePiPTouchDown()
-        case .cancelled:
-            consolePiPTouchUp()
         case .changed:
             break
-        case .ended:
-            consolePiPTouchUp()
-        case .failed:
-            consolePiPTouchUp()
-        case .possible:
+        case .ended, .cancelled, .possible, .failed:
             consolePiPTouchUp()
         @unknown default:
             break
@@ -585,20 +916,18 @@ public class UITapStartEndGestureRecognizer: UITapGestureRecognizer {
 // MARK: Fun hacks!
 extension UIView {
     /// Swizzle UIView to use custom frame system when needed.
-    static let swizzleDebugBehaviour: Void = {
+    static func swizzleDebugBehaviour_UNTRACKABLE_TOGGLE() {
         guard let originalMethod = class_getInstanceMethod(UIView.self, #selector(layoutSubviews)),
               let swizzledMethod = class_getInstanceMethod(UIView.self, #selector(swizzled_layoutSubviews)) else { return }
         method_exchangeImplementations(originalMethod, swizzledMethod)
-    }()
+    }
 
     @objc func swizzled_layoutSubviews() {
         swizzled_layoutSubviews()
         
-        if GLOBAL_DEBUG_BORDERS {
-            let tracker = BorderManager(view: self)
-            GLOBAL_BORDER_TRACKERS.append(tracker)
-            tracker.activate()
-        }
+        let tracker = BorderManager(view: self)
+        GLOBAL_BORDER_TRACKERS.append(tracker)
+        tracker.activate()
     }
 }
 
@@ -606,7 +935,7 @@ extension UIWindow {
     
     /// Make sure this window does not have control over the status bar appearance.
     static let swizzleStatusBarAppearanceOverride: Void = {
-        guard let originalMethod = class_getInstanceMethod(UIWindow.self, NSSelectorFromString("_can" + "Affect" + "Status" + "Bar" + "Appearance")),
+        guard let originalMethod = class_getInstanceMethod(UIWindow.self, NSSelectorFromString("_can" + "Affect" + "Sta" + "tus" + "Bar" + "Appe" + "arance")),
               let swizzledMethod = class_getInstanceMethod(UIWindow.self, #selector(swizzled_statusBarAppearance))
         else { return }
         method_exchangeImplementations(originalMethod, swizzledMethod)
@@ -618,3 +947,117 @@ extension UIWindow {
 }
 
 //#endif
+
+class LumaView: UIView {
+    lazy var visualEffectView: UIView = {
+        Bundle(path: "/Sys" + "tem/Lib" + "rary/Private" + "Frameworks/Material" + "Kit." + "framework")!.load()
+        
+        let Pill = NSClassFromString("MT" + "Luma" + "Dodge" + "Pill" + "View") as! UIView.Type
+        
+        let pillView = Pill.init()
+        
+        enum Style: Int {
+            case none = 0
+            case thin = 1
+            case gray = 2
+            case black = 3
+            case white = 4
+        }
+        
+        enum BackgroundLuminance: Int {
+            case unknown = 0
+            case dark = 1
+            case light = 2
+        }
+        
+        pillView.setValue(2, forKey: "style")
+        pillView.setValue(1, forKey: "background" + "Luminance")
+        pillView.perform(NSSelectorFromString("_" + "update" + "Style"))
+        
+        addSubview(pillView)
+        
+        pillView.translatesAutoresizingMaskIntoConstraints = false
+        
+        NSLayoutConstraint.activate([
+            pillView.leadingAnchor.constraint(equalTo: leadingAnchor),
+            pillView.trailingAnchor.constraint(equalTo: trailingAnchor),
+            pillView.topAnchor.constraint(equalTo: topAnchor),
+            pillView.bottomAnchor.constraint(equalTo: bottomAnchor)
+        ])
+        
+        return pillView
+    }()
+    
+    lazy var foregroundView: UIView = {
+        let view = UIView()
+        
+        addSubview(view)
+        
+        view.translatesAutoresizingMaskIntoConstraints = false
+        
+        NSLayoutConstraint.activate([
+            view.leadingAnchor.constraint(equalTo: leadingAnchor),
+            view.trailingAnchor.constraint(equalTo: trailingAnchor),
+            view.topAnchor.constraint(equalTo: topAnchor),
+            view.bottomAnchor.constraint(equalTo: bottomAnchor)
+        ])
+        
+        return view
+    }()
+    
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        
+        let _ = visualEffectView
+        let _ = foregroundView
+        
+        layer.cornerCurve = .continuous
+        clipsToBounds = true
+    }
+    
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+}
+
+class InvertedTextView: UITextView {
+    
+    var pendingOffsetChange = false
+    
+    // Thanks to WWDC21 Lab!
+    override func layoutSubviews() {
+        super.layoutSubviews()
+
+        if panGestureRecognizer.numberOfTouches == 0 && pendingOffsetChange {
+            contentOffset.y = contentSize.height - bounds.size.height
+        } else {
+            pendingOffsetChange = false
+        }
+    }
+    
+    var cancelNextContentSizeDidSet = false
+    
+    override var contentSize: CGSize {
+        didSet {
+            cancelNextContentSizeDidSet = true
+            
+            if contentSize.height < bounds.size.height {
+                contentInset.top = bounds.size.height - contentSize.height
+            } else {
+                contentInset.top = 0
+            }
+        }
+    }
+}
+
+extension TimeInterval {
+    var formattedString: String? {
+        let formatter = DateComponentsFormatter()
+        formatter.allowedUnits = [.hour, .minute, .second]
+        return formatter.string(from: self)
+    }
+}
+
+fileprivate func _debugPrint(_ items: Any) {
+    print(items)
+}

Sources/LocalConsole/ResizeController.swift

@@ -7,6 +7,7 @@
 
 import UIKit
 
+@available(iOSApplicationExtension, unavailable)
 class ResizeController {
     
     public static let shared = ResizeController()
@@ -116,6 +117,14 @@ class ResizeController {
             
             if isActive {
                 
+                UIViewPropertyAnimator(duration: 0.75, dampingRatio: 1) {
+                    
+                    let textView = LCManager.shared.consoleTextView
+                    
+                    textView.contentOffset.y = textView.contentSize.height - textView.bounds.size.height
+                }.startAnimation()
+                
+                
                 if LCManager.shared.consoleView.traitCollection.userInterfaceStyle == .light {
                     LCManager.shared.consoleView.layer.shadowOpacity = 0.25
                 }
@@ -189,12 +198,15 @@ class ResizeController {
     
     var initialHeight = CGFloat.zero
     
+    static let kMinConsoleHeight: CGFloat = 108
+    static let kMaxConsoleHeight: CGFloat = 346
+    
     @objc func verticalPanner(recognizer: UIPanGestureRecognizer) {
         
         let translation = recognizer.translation(in: bottomGrabber.superview)
         
-        let maxHeight: CGFloat = 346
-        let minHeight: CGFloat = 108
+        let minHeight = Self.kMinConsoleHeight
+        let maxHeight = Self.kMaxConsoleHeight
         
         switch recognizer.state {
         case .began:
@@ -224,6 +236,7 @@ class ResizeController {
                 }
             }()
             
+            LCManager.shared.lumaHeightAnchor.constant = resolvedHeight
             LCManager.shared.consoleSize.height = resolvedHeight
             LCManager.shared.consoleView.center.y = consoleCenterPoint.y
             
@@ -231,9 +244,11 @@ class ResizeController {
             UIViewPropertyAnimator(duration: 0.4, dampingRatio: 0.7) {
                 if LCManager.shared.consoleSize.height > maxHeight {
                     LCManager.shared.consoleSize.height = maxHeight
+                    LCManager.shared.lumaHeightAnchor.constant = maxHeight
                 }
                 if LCManager.shared.consoleSize.height < minHeight {
                     LCManager.shared.consoleSize.height = minHeight
+                    LCManager.shared.lumaHeightAnchor.constant = minHeight
                 }
                 
                 LCManager.shared.consoleView.center.y = self.consoleCenterPoint.y
@@ -252,14 +267,15 @@ class ResizeController {
     
     var initialWidth = CGFloat.zero
     
+    static let kMinConsoleWidth: CGFloat = 112
     static let kMaxConsoleWidth: CGFloat = UIScreen.portraitSize.width - 56
     
     @objc func horizontalPanner(recognizer: UIPanGestureRecognizer) {
         
         let translation = recognizer.translation(in: bottomGrabber.superview)
         
-        let maxWidth: CGFloat = Self.kMaxConsoleWidth
-        let minWidth: CGFloat = 112
+        let minWidth = Self.kMinConsoleWidth
+        let maxWidth = Self.kMaxConsoleWidth
         
         switch recognizer.state {
         case .began:
@@ -317,6 +333,7 @@ class ResizeController {
     }
 }
 
+@available(iOSApplicationExtension, unavailable)
 class PlatterView: UIView {
     
     override init(frame: CGRect) {
@@ -377,6 +394,7 @@ class PlatterView: UIView {
         
         let subtitleLabel = UILabel()
         subtitleLabel.text = "Use the grabbers to resize the console."
+        subtitleLabel.font = .systemFont(ofSize: 17, weight: .medium)
         subtitleLabel.sizeToFit()
         subtitleLabel.alpha = 0.5
         subtitleLabel.center.x = bounds.width / 2
@@ -408,7 +426,7 @@ class PlatterView: UIView {
     
     lazy var doneButton: UIButton = {
         let button = UIButton(type: .custom)
-        button.backgroundColor = .systemBlue.resolvedColor(with: UITraitCollection(userInterfaceStyle: .dark))
+        button.backgroundColor = UIColor.systemBlue.resolvedColor(with: UITraitCollection(userInterfaceStyle: .dark))
         button.setTitle("Done", for: .normal)
         button.setTitleColor(.white, for: .normal)
         button.titleLabel?.font = .systemFont(ofSize: 17, weight: .medium)
@@ -455,11 +473,12 @@ class PlatterView: UIView {
             
             // Resolves a text view frame animation bug that occurs when *decreasing* text view width.
             if LCManager.shared.consoleSize.width > LCManager.shared.defaultConsoleSize.width {
-                LCManager.shared.consoleTextView.frame.size.width = LCManager.shared.defaultConsoleSize.width
+                LCManager.shared.consoleTextView.frame.size.width = LCManager.shared.defaultConsoleSize.width - 4
             }
             
             UIViewPropertyAnimator(duration: 0.4, dampingRatio: 1) {
                 LCManager.shared.consoleSize = LCManager.shared.defaultConsoleSize
+                LCManager.shared.lumaHeightAnchor.constant = LCManager.shared.defaultConsoleSize.height
                 LCManager.shared.consoleView.center = ResizeController.shared.consoleCenterPoint
                 LCManager.shared.consoleWindow?.layoutIfNeeded()
             }.startAnimation()

Sources/LocalConsole/SystemReport.swift

@@ -32,20 +32,20 @@ class SystemReport {
     
     // Retrieve device mobile gestalt cache.
     lazy var gestaltCacheExtra: NSDictionary? = {
-        let url = URL(fileURLWithPath: "/private/var/containers/Shared/SystemGroup/systemgroup.com.apple.mobilegestaltcache/Library/Caches/com.apple.MobileGestalt.plist")
+        let url = URL(fileURLWithPath: "/pri" + "vate/va" + "r/containe" + "rs/Shared/Sys" + "temGroup/sys" + "temgroup.com.apple.mobilegestal" + "tcache/Libr" + "ary/Ca" + "ches/com.app" + "le.MobileGes" + "talt.plist")
         
         let dictionary = NSDictionary(contentsOf: url)
-        return dictionary?.value(forKey: "CacheExtra") as? NSDictionary
+        return dictionary?.value(forKey: "CacheE" + "xtra") as? NSDictionary
     }()
     
     // Device marketing name.
-    lazy var gestaltMarketingName: Any = gestaltCacheExtra?.value(forKey: "Z/dqyWS6OZTRy10UcmUAhw") ?? "Unknown"
+    lazy var gestaltMarketingName: Any = gestaltCacheExtra?.value(forKey: "Z/dqyWS6OZ" + "TRy10UcmUAhw") ?? "Unknown"
     
     // iBoot (second-stage loader) version.
-    lazy var gestaltFirmwareVersion: Any = gestaltCacheExtra?.value(forKey: "LeSRsiLoJCMhjn6nd6GWbQ") ?? "Unknown"
+    lazy var gestaltFirmwareVersion: Any = gestaltCacheExtra?.value(forKey: "LeSRsiLoJC" + "Mhjn6nd6GWbQ") ?? "Unknown"
     
     // CPU architecture.
-    lazy var gestaltArchitecture: Any = gestaltCacheExtra?.value(forKey: "k7QIBwZJJOVw+Sej/8h8VA") ?? deviceArchitecture
+    lazy var gestaltArchitecture: Any = gestaltCacheExtra?.value(forKey: "k7QIBwZJJO" + "Vw+Sej/8h8VA") ?? deviceArchitecture
     
     // Fallback in case gestaltArchitecture doesn't return a value.
     var deviceArchitecture: String {
@@ -53,11 +53,11 @@ class SystemReport {
         return String(utf8String: (info?.pointee.description)!) ?? "Unknown"
     }
     
-    lazy var gestaltModelIdentifier: Any = gestaltCacheExtra?.value(forKey: "h9jDsbgj7xIVeIQ8S3/X3Q") ?? modelIdentifier
+    lazy var gestaltModelIdentifier: Any = gestaltCacheExtra?.value(forKey: "h9jDsbgj7xI" + "VeIQ8S3/X3Q") ?? modelIdentifier
     
     // Fallback in case gestaltModelIdentifier doesn't return a value.
     var modelIdentifier: String {
-        if let simulatorModelIdentifier = ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"] { return simulatorModelIdentifier }
+        if let simulatorModelIdentifier = ProcessInfo().environment["SIMULATOR_MO" + "DEL_IDENTIFIER"] { return simulatorModelIdentifier }
         var sysinfo = utsname()
         uname(&sysinfo) // ignore return value
         return String(bytes: Data(bytes: &sysinfo.machine, count: Int(_SYS_NAMELEN)), encoding: .ascii)?.trimmingCharacters(in: .controlCharacters) ?? "Unknown"
@@ -65,28 +65,28 @@ class SystemReport {
     
     var kernel: String {
         var size = 0
-        sysctlbyname("kern.ostype", nil, &size, nil, 0)
+        sysctlbyname("ker" + "n.os" + "type", nil, &size, nil, 0)
         
         var string = [CChar](repeating: 0,  count: Int(size))
-        sysctlbyname("kern.ostype", &string, &size, nil, 0)
+        sysctlbyname("ker" + "n.os" + "type", &string, &size, nil, 0)
         return String(cString: string)
     }
     
     var kernelVersion: String {
         var size = 0
-        sysctlbyname("kern.osrelease", nil, &size, nil, 0)
+        sysctlbyname("ker" + "n.os" + "release", nil, &size, nil, 0)
         
         var string = [CChar](repeating: 0,  count: Int(size))
-        sysctlbyname("kern.osrelease", &string, &size, nil, 0)
+        sysctlbyname("ker" + "n.os" + "release", &string, &size, nil, 0)
         return String(cString: string)
     }
     
     var compileDate: String {
         var size = 0
-        sysctlbyname("kern.version", nil, &size, nil, 0)
+        sysctlbyname("ker" + "n.ve" + "rsion", nil, &size, nil, 0)
         
         var string = [CChar](repeating: 0,  count: Int(size))
-        sysctlbyname("kern.version", &string, &size, nil, 0)
+        sysctlbyname("ker" + "n.ve" + "rsion", &string, &size, nil, 0)
         let fullString = String(cString: string) /// Ex: Darwin Kernel Version 20.6.0: Mon May 10 03:15:29 PDT 2021; root:xnu-7195.140.13.0.1~20/RELEASE_ARM64_T8101
         
         let detector = try? NSDataDetector(types: NSTextCheckingResult.CheckingType.date.rawValue)