რა ხდება სისტემაში, როდესაც ჩვენ ვაჭერთ ეკრანს?

როდესაც მომხმარებელი ანიჭებს ეკრანს iOS-სამართავზე, ხდება შემდეგი:

1. შემთხვევის აღება: მოწყობილობის (ტჩ-კონტროლერი) აღრიცხვა და შემთხვევის გენერირება.
2. შემთხვევის დამუშავება IOKit-ში: მოწყობილობის დრაივერი იღებს ტჩ-ის ინფორმაციას (კოორდინატები, დაწოლა და ა.შ.).
3. შემთხვევის გაგზავნა SpringBoard-ს: IOKit გადმოგზავნის შემთხვევას სისტემურ პროცესს SpringBoard-ს.
4. შემთხვევის მარშრუტიზაცია: SpringBoard განსაზღვრავს აქტიურ აპლიკაციას და აგზავნის შემთხვევას IPC-ის საშუალებით (Inter-Process Communication) ამ აპლიკაციას.
5. შემთხვევის მიღება UIKit/SwiftUI-ში: აპლიკაციაში შემთხვევა მიიღება ფრეიმვორკის მიერ (UIKit ან SwiftUI).
6. შემთხვევის დამატება რიგში: შემთხვევა დამატებულია აპლიკაციის შემთხვევების დამუშავების რიგში.
7. შემთხვევის მიღება აპლიკაციაში: ძირითადი ციკლი (Run Loop) ამოიღებს შემთხვევას რიგიდან.
8. შემთხვევის დამუშავება UIResponder-ის მეშვეობით: შემთხვევა გადაეცემა ობიექტს UIEvent. UIKit იწყებს შემთხვევის მიწოდების პროცესს, ჩვეულებრივ დაწყებული UIWindow-ის ობიექტიდან.
9. hitTest-ის შემოწმება: სისტემა განსაზღვრავს ყველაზე ზედა ინტერაქტიულ UIView-ს (ან მის ექვივალენტს SwiftUI-ში), რომელიც მდებარეობს შეხების წერტილში, გამოყენებით მეთოდის hitTest(_:with:) (UIKit-ში). ეს მეთოდი რეკურსიულად გადის წარმოდგენების ჰიერქიას, შემოწმებს თუ მდებარეობს წერტილი bounds-ის შიგნით და არის თუ არა წარმოდგენა userInteractionEnabled-ის მქონე.
10. შემთხვევის მიწოდება: შემთხვევა გადაეცემა მოძიებულ წარმოდგენას. თუ წარმოდგენა არ დამუშავებს შემთხვევას (მაგალითად, არ აქვს შესაბამისი ჟესტი ან ახორციელებს touchesBegan:withEvent:-ს, მაგრამ არ დამუშავებს მას, ან თუ მეთოდი აბრუნებს nil hitTest-ის შემთხვევაში), მაშინ შემთხვევა გადაეცემა შემდეგ რესპონდერს ჯაჭვში (responder chain), ჩვეულებრივ სუპერვიდს ან წარმოდგენის კონტროლერს.
11. ჟესტების ან შეხების მეთოდების დამუშავება: თუ წარმოდგენას აქვს მიმაგრებული ჟესტის ამცნებლები (UIGestureRecognizer), ისინი იღებენ შემთხვევას პირველები. თუ ჟესტი ამოიცნობა, ის დამუშავდება შესაბამის objc მოქმედებით ან Swift ფუნქციით. თუ ჟესტები არ დამუშავებენ შემთხვევას ან არ არის, შემთხვევა გადაეცემა შეხების მეთოდებს (მაგალითად, touchesBegan(_:with:), touchesMoved(_:with:), touchesEnded(_:with:), touchesCancelled(_:with:)).
12. ლოგიკის შესრულება: ჟესტის ან შეხების მეთოდის დამუშავების დროს ხორციელდება მომხმარებლის ლოგიკა (მაგალითად, UI-ის მდგომარეობის შეცვლა, ნავიგაცია, მოქმედების შესრულება).
13. UI-ის განახლება: თუ ლოგიკამ გამოიწვია UI-ში ცვლილებები, ფრეიმვორკი აგზავნის გადახედვის მოთხოვნას (თუ საჭიროა).

აქ არის ძალიან მარტივი მაგალითი ტჩ-ის დამუშავების ლოგიკის, რომელიც დაკავშირებულია ღილაკთან:

// ViewController კლასში ან სხვა UIResponder-ში
@IBAction func buttonTapped(_ sender: Any) {
    // ლოგიკა, რომელიც შესრულდება ღილაკზე დაჭერისას
    print("ღილაკი დაჭერილია!")
}

მეორე მაგალითი touchesBegan-ის გამოყენების (ანუ ნაკლებ გავრცელებული მარტივი დაჭერებისთვის):

// UIView-დან მემკვიდრეობით მიღებული მომხმარებლის მიერ შექმნილი წარმოდგენისთვის
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    // პირველი შეხების მიღება
    guard let touch = touches.first else { return }

    // შეხების წერტილის მიღება წარმოდგენის კოორდინატებში
    let location = touch.location(in: self)

    print("ეკრანი შეხებულია CGPoint: \(location)")

    // თუ super-ს არ გამოიძახებთ, შემდგომი დამუშავება ჯაჭვში შეჩერდება
    // super.touchesBegan(touches, with: event)
}