Check iOS Version

<?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>IDECodeSnippetCompletionPrefix</key>
	<string>snippetAlert</string>
	<key>IDECodeSnippetCompletionScopes</key>
	<array>
		<string>All</string>
	</array>
	<key>IDECodeSnippetContents</key>
	<string>let alertController = UIAlertController(title: &lt;#T##String?#&gt;, message: &lt;#T##String?#&gt;, preferredStyle: &lt;#T##UIAlertController.Style#&gt;)
let firstAction = UIAlertAction(title: &lt;#T##String?#&gt;, style: .default, handler: &lt;#T##((UIAlertAction) -&gt; Void)?##((UIAlertAction) -&gt; Void)?##(UIAlertAction) -&gt; Void#&gt;)
let cancelAction = UIAlertAction(title: &lt;#T##String?#&gt;, style: .cancel, handler: nil)

alertController.addAction(firstAction)
alertController.addAction(cancelAction)
present(alertController, animated: true)</string>
	<key>IDECodeSnippetIdentifier</key>
	<string>8C458AD7-C631-457B-85CC-D2501E425D59</string>
	<key>IDECodeSnippetLanguage</key>
	<string>Xcode.SourceCodeLanguage.Swift</string>
	<key>IDECodeSnippetSummary</key>
	<string></string>
	<key>IDECodeSnippetTitle</key>
	<string>UIAlertController</string>
	<key>IDECodeSnippetUserSnippet</key>
	<true/>
	<key>IDECodeSnippetVersion</key>
	<integer>2</integer>
</dict>
</plist>

@IBAction func doSomething()
@IBAction func doSomething(sender: UIButton)
@IBAction func doSomething(sender: UIButton, forEvent event: UIEvent)

import 'package:flutter/material.dart';

void main() {
  runApp(
    new MaterialApp(
      title: 'Hello World App',
      home: new myApp(),
    )
  );
}

class myApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return new Scaffold(
      appBar: new AppBar(
        title: new Text('Hello World App'),
      ),
      body: new Center(
        child: new Text(
          'Hello, world!'
        ),
      ),
    );
  }
}

[[NSProcessInfo processInfo] operatingSystemVersion]

override func viewDidLoad() {
    super.viewDidLoad()
    // Swift block syntax (iOS 10+)
    let timer = Timer(timeInterval: 0.4, repeats: true) { _ in print("Done!") }
    // Swift >=3 selector syntax
    let timer = Timer.scheduledTimer(timeInterval: 0.4, target: self, selector: #selector(self.update), userInfo: nil, repeats: true)
    // Swift 2.2 selector syntax
    let timer = NSTimer.scheduledTimerWithTimeInterval(0.4, target: self, selector: #selector(MyClass.update), userInfo: nil, repeats: true)
    // Swift <2.2 selector syntax
    let timer = NSTimer.scheduledTimerWithTimeInterval(0.4, target: self, selector: "update", userInfo: nil, repeats: true)
}

// must be internal or public. 
@objc func update() {
    // Something cool
}

@media (min-width: 980px){
 
    .hide-desktop{
    display: none !important;
    }
 
}
 
    @media (max-width: 980px){
    .hide-mobile{
    display: none !important;
    }
			
}
body .top_bar_right_part {
 justify-content: center !important;
}
body.rtl.rtl-demo .header_2_top_bar__inner .top_bar_right_part {
 justify-content: center !important;
}
@media (max-width: 624px) {
body .header_2 .stm_menu_toggler:before, body .header_2 .stm_menu_toggler:after {
font-size: 20px;
}}

.header_main_menu_wrapper .header-menu>li>ul.sub-menu>li>.sub-menu{
     left:unset !important;
     right:100%;
}

body .stm_lms_become_instructor.enterprise {
	display: none 
		!important;}

.stm_lms_certificate_checker__form {
 display: flex !important;
 flex-wrap: wrap;
}

.stm_lms_certificate_checker__input {
 width: 320px !important;
}

let value1 = try? data.toDictionary()
let value2 = try? data.to(type: [String: Any].self)
let value3 = try? data.to(type: [String: String].self)
let value4 = try? string.asJSONToDictionary()
let value5 = try? string.asJSON(to: [String: String].self)

import Foundation

// MARK: - CastingError

struct CastingError: Error {
    let fromType: Any.Type
    let toType: Any.Type
    init<FromType, ToType>(fromType: FromType.Type, toType: ToType.Type) {
        self.fromType = fromType
        self.toType = toType
    }
}

extension CastingError: LocalizedError {
    var localizedDescription: String { return "Can not cast from \(fromType) to \(toType)" }
}

extension CastingError: CustomStringConvertible { var description: String { return localizedDescription } }

// MARK: - Data cast extensions

extension Data {
    func toDictionary(options: JSONSerialization.ReadingOptions = []) throws -> [String: Any] {
        return try to(type: [String: Any].self, options: options)
    }

    func to<T>(type: T.Type, options: JSONSerialization.ReadingOptions = []) throws -> T {
        guard let result = try JSONSerialization.jsonObject(with: self, options: options) as? T else {
            throw CastingError(fromType: type, toType: T.self)
        }
        return result
    }
}

// MARK: - String cast extensions

extension String {
    func asJSON<T>(to type: T.Type, using encoding: String.Encoding = .utf8) throws -> T {
        guard let data = data(using: encoding) else { throw CastingError(fromType: type, toType: T.self) }
        return try data.to(type: T.self)
    }

    func asJSONToDictionary(using encoding: String.Encoding = .utf8) throws -> [String: Any] {
        return try asJSON(to: [String: Any].self, using: encoding)
    }
}

// MARK: - Dictionary cast extensions

extension Dictionary {
    func toData(options: JSONSerialization.WritingOptions = []) throws -> Data {
        return try JSONSerialization.data(withJSONObject: self, options: options)
    }
}

https://medium.com/swlh/how-to-create-a-custom-gradient-in-swift-with-cagradientlayer-ios-swift-guide-190941cb3db2

lazy var gradient: CAGradientLayer = {
        let gradient = CAGradientLayer()
        gradient.type = .axial
        gradient.colors = [
            
            hexStringToUIColor(hex: "468d01"),
            hexStringToUIColor(hex: "acdc08")
        ]
        
        gradient.locations = [0,0.95]
        return gradient
    }()


func views() {
              gradient.frame = logInView.bounds
            logInView.layer.addSublayer(gradient)
            
            let x = logInView.frame.origin.x
            let y = logInView.frame.origin.y
            
            print("x = ", x)
            print("y = ", y)
            
            gradient.startPoint = CGPoint(x: 0, y: y)
            gradient.endPoint = CGPoint(x: 1, y: y)

}


    func hexStringToUIColor (hex:String) -> CGColor {
        var cString:String = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

        if (cString.hasPrefix("#")) {
            cString.remove(at: cString.startIndex)
        }

        if ((cString.count) != 6) {
            return UIColor.gray.cgColor
        }

        var rgbValue:UInt64 = 0
        Scanner(string: cString).scanHexInt64(&rgbValue)

        return CGColor(
            red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
            green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
            blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
            alpha: CGFloat(1.0)
        )
    }

import Foundation
import SwiftUI

class AirConditionerViewModel: ObservableObject {
    
    enum AirConditionerMode: String, CaseIterable, Identifiable {
        case cool = "Cool"
        case heat = "Heat"
        var id: Self { self }
    }
    
    enum FanSpeed: String, CaseIterable, Identifiable {
        case low = "Low"
        case medium = "Medium"
        case high = "High"
        var id: Self { self }
    }
    
    let minTemperature = 60.0
    let maxTemperature = 100.0
    
    @Published var airConditionerIsOn = false
    @Published var airConditionerMode: AirConditionerMode = .cool
    @Published var currentTemperature = 75.0
    @Published var desiredTemperature = 80.0
    @Published var fanIsOn = false
    @Published var fanSpeed: FanSpeed = .low
    
}

import SwiftUI

struct AirConditionerView: View {
    
    @ObservedObject var viewModel: AirConditionerViewModel
    @FocusState var tempTextFieldIsFocused: Bool
    
    var body: some View {
        VStack(spacing: 15) {
            // MARK: - 1. Power Toggle
            Toggle("Power", isOn: $viewModel.airConditionerIsOn)
            
            // MARK: - 2. AC Mode picker
            HStack {
                Text("Mode")
                Picker("Mode", selection: $viewModel.airConditionerMode) {
                    ForEach(AirConditionerViewModel.AirConditionerMode.allCases) { mode in
                        Text(mode.rawValue)
                    }
                }.pickerStyle(.segmented)
            }.disabled(!viewModel.airConditionerIsOn)
            
            // MARK: - 3. Temperature text field
            HStack {
                Text("Temperature")
                TextField("", value: $viewModel.desiredTemperature, formatter: NumberFormatter())
                    .padding(.leading)
                    .border(.primary)
                    .focused($tempTextFieldIsFocused)
            }.disabled(!viewModel.airConditionerIsOn)
            
            // MARK: - 4. Temperature slider
            Slider(value: $viewModel.desiredTemperature,
                   in: viewModel.minTemperature...viewModel.maxTemperature,
                   onEditingChanged: { editing in
                if editing {
                    tempTextFieldIsFocused = false
                }
            }).disabled(!viewModel.airConditionerIsOn)
            
            // MARK: - 5. Fan power toggle
            Toggle("Fan", isOn: $viewModel.fanIsOn)
                .disabled(!viewModel.airConditionerIsOn)
            
            // MARK: - 6. Fan speed picker
            HStack {
                Text("Fan Speed")
                Spacer()
            }.disabled(!viewModel.airConditionerIsOn)
            Picker("Mode", selection: $viewModel.fanSpeed) {
                ForEach(AirConditionerViewModel.FanSpeed.allCases) { speed in
                    Text(speed.rawValue)
                }
            }
                .pickerStyle(.segmented)
                .disabled(!viewModel.airConditionerIsOn)
            
            // MARK: - 7. AC status Images
            HStack {
                switch viewModel.airConditionerMode {
                case .cool:
                    Image("snowflake")
                        .resizable()
                        .scaledToFit()
                        .frame(width: 150, height: 150)
                case .heat:
                    Image("heating")
                        .resizable()
                        .scaledToFit()
                        .frame(width: 150, height: 150)
                }
                
                if viewModel.fanIsOn {
                    VStack {
                        Image("fan")
                            .resizable()
                            .scaledToFit()
                            .frame(width: 100, height: 100)
                        switch viewModel.fanSpeed {
                        case .low:
                            Text("1x")
                        case .medium:
                            Text("2x")
                        case .high:
                            Text("3x")
                        }
                    }
                    .frame(width: 150, height: 150)
                } else {
                    Rectangle()
                        .foregroundColor(.clear)
                        .frame(width: 150, height: 150)
                }
            }
            
            // MARK: - 8. Progress Bar
            HStack {
                VStack {
                    Text("Current")
                    Text(String(format: "%.2f", viewModel.currentTemperature))
                        .frame(width: 50, height: 5)
                }
                
                ProgressView(value: viewModel.currentTemperature, total: viewModel.desiredTemperature)
                    .scaleEffect(x: 1, y: 5, anchor: .center)
                
                VStack {
                    Text("Goal")
                    Text(String(format: "%.2f", viewModel.desiredTemperature))
                        .frame(width: 50, height: 5)
                }
            }
        }
    }
}

// MARK: - UNUserNotificationCenterDelegate

extension AppDelegate: UNUserNotificationCenterDelegate {
  func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse,
    withCompletionHandler completionHandler: @escaping () -> Void
  ) {
    // 1
    let userInfo = response.notification.request.content.userInfo
    
    // 2
    if 
      let aps = userInfo["aps"] as? [String: AnyObject],
      let newsItem = NewsItem.makeNewsItem(aps) {
      (window?.rootViewController as? UITabBarController)?.selectedIndex = 1
      
      // 3
      if response.actionIdentifier == Identifiers.viewAction,
        let url = URL(string: newsItem.link) {
        let safari = SFSafariViewController(url: url)
        window?.rootViewController?
          .present(safari, animated: true, completion: nil)
      }
    }
    
    // 4
    completionHandler()
  }
}

call video play code on action , not on viewdidload

import AVFoundation
import AVKit

class VideoPlayerViewController: UIViewController, AVPlayerViewControllerDelegate {

    var playerController = AVPlayerViewController()
    
    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
    }
  
@IBAction func btnPressed(_ sender: Any) {
       guard let url = URL(string: "https://firebasestorage.googleapis.com/v0/b/kreative-app.appspot.com/o/FileMessage%2F1661341223.mp4?alt=media&token=e8ca21b2-8ea9-44bc-a28f-85598395081c")else {return}
        let player = AVPlayer(url: url)
        
        playerController = AVPlayerViewController()
     
        playerController.player = player
        playerController.allowsPictureInPicturePlayback = true
        playerController.delegate = self
        playerController.player?.play()
    self.present(playerController , animated: true, completion: nil)
    }

override func viewDidLoad() {
    super.viewDidLoad()

    myTbleView.addObserver(self, forKeyPath: "contentSize", options: .new, context: nil)
}

override func viewWillDisappear(_ animated: Bool) {
    myTbleView.removeObserver(self, forKeyPath: "contentSize")
    super.viewWillDisappear(true)
}

override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
    if(keyPath == "contentSize"){
        if let newvalue = change?[.newKey]
        {
            let newsize  = newvalue as! CGSize
           tableViewHeightConstraint.constant = newsize.height
        }
    }
}

extension NSMutableAttributedString {
    var fontSize:CGFloat { return 14 }
    var boldFont:UIFont { return UIFont(name: "AvenirNext-Bold", size: fontSize) ?? UIFont.boldSystemFont(ofSize: fontSize) }
    var normalFont:UIFont { return UIFont(name: "AvenirNext-Regular", size: fontSize) ?? UIFont.systemFont(ofSize: fontSize)}
    
    func bold(_ value:String) -> NSMutableAttributedString {
        
        let attributes:[NSAttributedString.Key : Any] = [
            .font : boldFont
        ]
        
        self.append(NSAttributedString(string: value, attributes:attributes))
        return self
    }
    
    func normal(_ value:String) -> NSMutableAttributedString {
        
        let attributes:[NSAttributedString.Key : Any] = [
            .font : normalFont,
        ]
        
        self.append(NSAttributedString(string: value, attributes:attributes))
        return self
    }
    /* Other styling methods */
    func orangeHighlight(_ value:String) -> NSMutableAttributedString {
        
        let attributes:[NSAttributedString.Key : Any] = [
            .font :  normalFont,
            .foregroundColor : UIColor.white,
            .backgroundColor : UIColor.orange
        ]
        
        self.append(NSAttributedString(string: value, attributes:attributes))
        return self
    }
    
    func blackHighlight(_ value:String) -> NSMutableAttributedString {
        
        let attributes:[NSAttributedString.Key : Any] = [
            .font :  normalFont,
            .foregroundColor : UIColor.white,
            .backgroundColor : UIColor.black
            
        ]
        
        self.append(NSAttributedString(string: value, attributes:attributes))
        return self
    }
    
    func underlined(_ value:String) -> NSMutableAttributedString {
        
        let attributes:[NSAttributedString.Key : Any] = [
            .font :  normalFont,
            .underlineStyle : NSUnderlineStyle.single.rawValue
            
        ]
        
        self.append(NSAttributedString(string: value, attributes:attributes))
        return self
    }
}